releasesemaphore

时间:2024-10-15 14:52:58编辑:揭秘君

Spring Boot如何整合Redis

Spring Boot是目前非常流行的Java Web开发框架,Redis是非关系型数据库的一种,以键值对的形式存储。Spring对Redis的支持是通过Spring Data Redis来实现的,给我们提供了RedisTemplate和StringRedisTemplate两种模板来操作数据。Spring Boot框架也提供了对Redis的支持,下面我们来讲一下Spring Boot框架整合Redis的步骤。 工具/材料 IntelliJ IDEA 01 Spring Boot整合Redis我们需要添加依赖的jar包,spring-boot-starter-data-redis中包含spring和redis相关的jar包,jedis作为redis的客户端也需要添加到工程中,Spring Boot的版本信息在父pom中已指定,子模块中的spring相关的jar包无需另外指定。 org.springframework.boot spring-boot-starter-data-redis redis.clients jedis 3.0.0-m1 02 Spring Boot会根据application.properties中的配置对Redis的属性进行自动配置,并注入到RedisProperties类中。在application.properties配置文件中这些属性都是以spring.redis为前缀的,值得注意的是在Spring Boot 1.5.x版本中默认的Redis客户端是jedis,因此在配置文件中无需指定,如下图所示。 03 Spring Boot 1.5.x版本的整合配置网上可以搜索大量的文章,然而Spring Boot 2.x版本的整合资料却非常少,甚至提供的配置不能正常使用,因此本文主要讲解Spring Boot 2.x整合Redis以及Redis的使用情况。spring-boot 2.x版本有jedis和lettuce两种客户端,因此我们必须要去指定使用哪一种客户端,两个客户端的配置如下图所示,本文使用的是Jedis客户端连接池,具体的配置如下。 # Redis数据库索引(默认为0) spring.redis.database=0 # Redis服务器地址 spring.redis.host=127.0.0.1 # Redis服务器连接端口 spring.redis.port=6379 # Redis服务器连接密码(默认为空) spring.redis.password=xylx1.t!@# # 配置jedis连接池 # 连接池最大连接数(使用负值表示没有限制) spring.redis.jedis.pool.max-active=8 # 连接池最大阻塞等待时间(使用负值表示没有限制) spring.redis.jedis.pool.max-wait=-1ms # 连接池中的最大空闲连接 spring.redis.jedis.pool.max-idle=8 # 连接池中的最小空闲连接 spring.redis.jedis.pool.min-idle=0 # 连接超时时间(毫秒) spring.redis.timeout=5000ms 由配置我们可以看到spring-boot 2.x版本时间设置需要加单位ms,因为参数的类型为Duration。另外spring.redis.timeout尽量不要配置0,否则可能会出现io.lettuce.core.RedisCommandTimeoutException: Command timed out超时错误。 04 配置文件编辑完成后,我们开始编写代码实现Redis数据的存储和读取。我们创建一个RedisUtil工具类,该类使用@Component注解表示交由Spring管理,StringRedisTemplate是Spring提供的,可以使用@Autowired注解直接注入,接下来便可以书写存和取的代码了。 @Component public class RedisUtil { @Autowired private StringRedisTemplate redisTemplate; /** * 存字符串 * @param key 缓存键 * @param value 缓存值 * @param expireTime 过期时间(s) */ public void setString(String key, String value, int expireTime){ ValueOperations ops = redisTemplate.opsForValue(); if (expireTime != 0) { ops.set(key, value, expireTime, TimeUnit.SECONDS); } else { ops.set(key,value); } } /** * 取字符串 * @param key 缓存键 * @return 缓存值 */ public String getString(String key){ ValueOperations ops = this.redisTemplate.opsForValue(); return ops.get(key); } 05 接下来我们编写Controller层代码去调用RedisUtil工具类,实现数据的存储和读取,代码比较简单可以参考下图。若想验证Redis是否可用,还需要编写启动类,如下图所示。 06 由上图可看到我们编写了一个post请求用于存储字符串,get请求用于取出字符串。启动类通过main方法启动应用,接下来我们使用postman去模拟浏览器调用post和get请求,由下图可以看到Redis存储的数据成功被取出。 07 接下来我们介绍Jedis,这是一个封装了Redis的客户端,在Spring Boot整合Redis的基础上,可以提供更简单的API操作。因此我们需要配置JedisPool的Bean,代码如下,其中@Configuration注解表明这是一个配置类,我们在该类中注入RedisProperties,并且使用@Bean注解指定JedisPool。 @Configuration public class RedisConfiguration { @Autowired private RedisProperties properties; @Bean public JedisPool getJedisPool(){ JedisPoolConfig config = new JedisPoolConfig(); config.setMaxIdle(properties.getJedis().getPool().getMaxIdle()); config.setMaxTotal(properties.getJedis().getPool().getMaxActive()); config.setMaxWaitMillis(properties.getJedis().getPool().getMaxWait().toMillis()); JedisPool pool = new JedisPool(config,properties.getHost(), properties.getPort(),100, properties.getPassword(), properties.getDatabase()); return pool; } } 08 接下来我们编辑JedisUtil工具类,通过SpringBoot容器的@Component注解来自动创建,并且注入JedisPool,使用jedisPool.getResource()方法来获取Jedis,并最终实现操作redis数据库,其代码如下。 @Component public class JedisUtil { @Autowired JedisPool jedisPool; //获取key的value值 public String get(String key) { Jedis jedis = jedisPool.getResource(); String str = ""; try { str = jedis.get(key); } finally { try { jedis.close(); } catch (Exception e) { e.printStackTrace(); } } return str; } public String set(String key, String value) { Jedis jedis = jedisPool.getResource(); String str = ""; try { str = jedis.set(key, value); } finally { try { jedis.close(); } catch (Exception e) { e.printStackTrace(); } } return str; } } 09 JedisUtil工具类编写完成后,我们修改之前的RedisController,并注入JedisUtil,代码如下图所示。然后再用postman分别调用post和get接口,我们可以看到成功取到了新的key的value值。 特别提示 在Spring Boot整合Redis前本机需安装Redis,另外可以使用RedisDesktopManager这个Redis这个桌面管理工具查看Redis中的数据。

Spring Boot如何整合Redis

Spring Boot是目前非常流行的Java Web开发框架,Redis是非关系型数据库的一种,以键值对的形式存储。Spring对Redis的支持是通过Spring Data Redis来实现的,给我们提供了RedisTemplate和StringRedisTemplate两种模板来操作数据。Spring Boot框架也提供了对Redis的支持,下面我们来讲一下Spring Boot框架整合Redis的步骤。 工具/材料 IntelliJ IDEA Spring Boot整合Redis我们需要添加依赖的jar包,spring-boot-starter-data-redis中包含spring和redis相关的jar包,jedis作为redis的客户端也需要添加到工程中,Spring Boot的版本信息在父pom中已指定,子模块中的spring相关的jar包无需另外指定。 org.springframework.boot spring-boot-starter-data-redis redis.clients jedis 3.0.0-m1 Spring Boot会根据application.properties中的配置对Redis的属性进行自动配置,并注入到RedisProperties类中。在application.properties配置文件中这些属性都是以spring.redis为前缀的,值得注意的是在Spring Boot 1.5.x版本中默认的Redis客户端是jedis,因此在配置文件中无需指定,如下图所示。 Spring Boot 1.5.x版本的整合配置网上可以搜索大量的文章,然而Spring Boot 2.x版本的整合资料却非常少,甚至提供的配置不能正常使用,因此本文主要讲解Spring Boot 2.x整合Redis以及Redis的使用情况。spring-boot 2.x版本有jedis和lettuce两种客户端,因此我们必须要去指定使用哪一种客户端,两个客户端的配置如下图所示,本文使用的是Jedis客户端连接池,具体的配置如下。 # Redis数据库索引(默认为0) spring.redis.database=0 # Redis服务器地址 spring.redis.host=127.0.0.1 # Redis服务器连接端口 spring.redis.port=6379 # Redis服务器连接密码(默认为空) spring.redis.password=xylx1.t!@# # 配置jedis连接池 # 连接池最大连接数(使用负值表示没有限制) spring.redis.jedis.pool.max-active=8 # 连接池最大阻塞等待时间(使用负值表示没有限制) spring.redis.jedis.pool.max-wait=-1ms # 连接池中的最大空闲连接 spring.redis.jedis.pool.max-idle=8 # 连接池中的最小空闲连接 spring.redis.jedis.pool.min-idle=0 # 连接超时时间(毫秒) spring.redis.timeout=5000ms 由配置我们可以看到spring-boot 2.x版本时间设置需要加单位ms,因为参数的类型为Duration。另外spring.redis.timeout尽量不要配置0,否则可能会出现io.lettuce.core.RedisCommandTimeoutException: Command timed out超时错误。 配置文件编辑完成后,我们开始编写代码实现Redis数据的存储和读取。我们创建一个RedisUtil工具类,该类使用@Component注解表示交由Spring管理,StringRedisTemplate是Spring提供的,可以使用@Autowired注解直接注入,接下来便可以书写存和取的代码了。 @Component public class RedisUtil { @Autowired private StringRedisTemplate redisTemplate; /** * 存字符串 * @param key 缓存键 * @param value 缓存值 * @param expireTime过期时间(s) */ public void setString(String key, String value, int expireTime){ ValueOperations ops = redisTemplate.opsForValue(); if (expireTime != 0) { ops.set(key, value, expireTime, TimeUnit.SECONDS); } else { ops.set(key,value); } } /** * 取字符串 * @param key 缓存键 * @return缓存值 */ public String getString(String key){ ValueOperations ops = this.redisTemplate.opsForValue(); return ops.get(key); } 接下来我们编写Controller层代码去调用RedisUtil工具类,实现数据的存储和读取,代码比较简单可以参考下图。若想验证Redis是否可用,还需要编写启动类,如下图所示。 由上图可看到我们编写了一个post请求用于存储字符串,get请求用于取出字符串。启动类通过main方法启动应用,接下来我们使用postman去模拟浏览器调用post和get请求,由下图可以看到Redis存储的数据成功被取出。 接下来我们介绍Jedis,这是一个封装了Redis的客户端,在Spring Boot整合Redis的基础上,可以提供更简单的API操作。因此我们需要配置JedisPool的Bean,代码如下,其中@Configuration注解表明这是一个配置类,我们在该类中注入RedisProperties,并且使用@Bean注解指定JedisPool。 @Configuration public class RedisConfiguration { @Autowired private RedisProperties properties; @Bean public JedisPool getJedisPool(){ JedisPoolConfig config = new JedisPoolConfig(); config.setMaxIdle(properties.getJedis().getPool().getMaxIdle()); config.setMaxTotal(properties.getJedis().getPool().getMaxActive()); config.setMaxWaitMillis(properties.getJedis().getPool().getMaxWait().toMillis()); JedisPool pool = new JedisPool(config,properties.getHost(), properties.getPort(),100, properties.getPassword(), properties.getDatabase()); return pool; } } 接下来我们编辑JedisUtil工具类,通过SpringBoot容器的@Component注解来自动创建,并且注入JedisPool,使用jedisPool.getResource()方法来获取Jedis,并最终实现操作redis数据库,其代码如下。 @Component public class JedisUtil { @Autowired JedisPool jedisPool; //获取key的value值 public String get(String key) { Jedis jedis = jedisPool.getResource(); String str = ""; try { str = jedis.get(key); } finally { try { jedis.close(); } catch (Exception e) { e.printStackTrace(); } } return str; } public String set(String key, String value) { Jedis jedis = jedisPool.getResource(); String str = ""; try { str = jedis.set(key, value); } finally { try { jedis.close(); } catch (Exception e) { e.printStackTrace(); } } return str; } } JedisUtil工具类编写完成后,我们修改之前的RedisController,并注入JedisUtil,代码如下图所示。然后再用postman分别调用post和get接口,我们可以看到成功取到了新的key的value值。 特别提示 在Spring Boot整合Redis前本机需安装Redis,另外可以使用RedisDesktopManager这个Redis这个桌面管理工具查看Redis中的数据。

用C语言实现--生产者与消费者的问题(PV操作)

这个问题蛮好的
我给你个程序
给我加分啊
#include

#include

#include

typedef
HANDLE
Semaphore;
//
信号量的Windows原型
#define
P(S)
WaitForSingleObject(S,
INFINITE)
//
定义Windows下的P操作
#define
V(S)
ReleaseSemaphore(S,
1,
NULL)
//
定义Windows下的V操作
#define
rate
1000
#define
CONSUMER_NUM
10
/*
消费者个数
*/
#define
PRODUCER_NUM
10
/*
生产者个数
*/
#define
BUFFER_NUM
4
/*
缓冲区个数
*/
char
*thing[10]
=
{"猪脸",
"牛鞭",
"羊腰",
"驴蹄",
"狼心",
"狗肺",
"猴肝",
"老虎屁股",
"大象肚",
"河马大肠"};
struct
Buffer
{
int
product[BUFFER_NUM];
//
缓冲区
int
start,
end;
//
两个指针
}
g_buf;
Semaphore
g_semBuffer,
g_semProduct,
g_mutex;
//
消费者线程
DWORD
WINAPI
Consumer(LPVOID
para)
{
//
i表示第i个消费者
int
i
=
*(int
*)para;
int
ptr;
//
待消费的内容的指针
printf("
猪头-%03d:
猪头我来啦!\n",
i);
Sleep(300);
while
(1)
{
printf("
猪头-%03d:
我要吃.........!\n",
i);
//
等待产品
P(g_semProduct);
//
有产品,先锁住缓冲区
g_buf
P(g_mutex);
//
记录消费的物品
ptr
=
g_buf.start;
//
再移动缓冲区指针
g_buf.start
=
(g_buf.start+1)%BUFFER_NUM;
//
让其他消费者或生产者使用
g_buf
V(g_mutex);
printf("
猪头-%03d:
我吃
buf[%d]
=
%s\n",
i,
ptr,
thing[g_buf.product[ptr]]);
Sleep(rate*rand()%10+110);
//
消费完毕,并释放一个缓冲
printf("
猪头-%03d:
我爽了!
buf[%d]
=
%s\n",
i,
ptr,
thing[g_buf.product[ptr]]);
V(g_semBuffer);
}
return
0;
}
//
生产者线程
DWORD
WINAPI
Producer(LPVOID
para)
{
int
i
=
*(int
*)para
-
CONSUMER_NUM;
int
ptr;
int
data;
//
产品
printf("工作狂-%03d:
我来啦!\n",
i);
Sleep(300);
while
(1)
{
printf("工作狂-%03d:
我干干干…………\n",
i);
Sleep(rate*rand()%10+110);
data
=
rand()%10;
printf("工作狂-%03d:
搞出一个东西
data
=
%s!\n",
i,
thing[data]);
//
等待存放空间
P(g_semBuffer);
//
有地方,先锁住缓冲区
g_buf
P(g_mutex);
//
记录消费的物品
ptr
=
g_buf.end;
//
再移动缓冲区指针
g_buf.end
=
(g_buf.end+1)%BUFFER_NUM;
//
让其他消费者或生产者使用
g_buf
V(g_mutex);
printf("工作狂-%03d:
搁到
buf[%d]
=
%s\n",
i,
ptr,
thing[data]);
g_buf.product[ptr]
=
data;
Sleep(rate/2*rand()%10+110);
//
放好了完毕,释放一个产品
printf("工作狂-%03d:
buf[%d]
=
%s
放好了,大家吃!\n",
i,
ptr,
thing[g_buf.product[ptr]]);
V(g_semProduct);
}
return
0;
}
int
main(int
argc,
char
*argv[])
{
//
线程技术,前面为消费者线程,后面为生产者线程
HANDLE
hThread[CONSUMER_NUM+PRODUCER_NUM];
//
线程计数
//srand(time());
DWORD
tid;
int
i=0;
//
初始化信号量
g_mutex
=
CreateSemaphore(NULL,
BUFFER_NUM,
BUFFER_NUM,
"mutexOfConsumerAndProducer");
g_semBuffer
=
CreateSemaphore(NULL,
BUFFER_NUM,
BUFFER_NUM,
"BufferSemaphone");
g_semProduct
=
CreateSemaphore(NULL,
0,
BUFFER_NUM,
"ProductSemaphone");
if
(
!g_semBuffer
||
!g_semProduct
||
!g_mutex)
{
printf("Create
Semaphone
Error!\n");
return
-1;
}
int
totalThreads
=
CONSUMER_NUM+PRODUCER_NUM;
//
开启消费者线程
printf("先请猪头们上席!\n");
for
(i=0;
i<CONSUMER_NUM;
i++)
{
hThread[i]
=
CreateThread(NULL,
0,
Consumer,
&i,
0,
&tid);
if
(
hThread[i]
)
WaitForSingleObject(hThread[i],
10);
}
printf("厨子们就位!\n");
for
(;
i<totalThreads;
i++)
{
hThread[i]
=
CreateThread(NULL,
0,
Producer,
&i,
0,
&tid);
if
(
hThread[i]
)
WaitForSingleObject(hThread[i],
10);
}
//
生产者和消费者的执行
WaitForMultipleObjects(totalThreads,
hThread,
TRUE,
INFINITE);
return
0;
}


用C语言实现PV操作生产者消费者关系

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>

typedef HANDLE Semaphore; // 信号量的Windows原型
#define P(S) WaitForSingleObject(S, INFINITE) // 定义Windows下的P操作
#define V(S) ReleaseSemaphore(S, 1, NULL) // 定义Windows下的V操作

#define rate 1000

#define CONSUMER_NUM 10 /* 消费者个数 */
#define PRODUCER_NUM 10 /* 生产者个数 */
#define BUFFER_NUM 4 /* 缓冲区个数 */

char *thing[10] = ;

struct Buffer
{
int product[BUFFER_NUM]; // 缓冲区
int start, end; // 两个指针
} g_buf;

Semaphore g_semBuffer, g_semProduct, g_mutex;


// 消费者线程
DWORD WINAPI Consumer(LPVOID para)
{
// i表示第i个消费者
int i = *(int *)para;
int ptr; // 待消费的内容的指针

printf(" 猪头-%03d: 猪头我来啦!\n", i);

Sleep(300);
while (1)
{
printf(" 猪头-%03d: 我要吃.........!\n", i);
// 等待产品
P(g_semProduct);

// 有产品,先锁住缓冲区 g_buf
P(g_mutex);

// 记录消费的物品
ptr = g_buf.start;

// 再移动缓冲区指针
g_buf.start = (g_buf.start+1)%BUFFER_NUM;

// 让其他消费者或生产者使用 g_buf
V(g_mutex);

printf(" 猪头-%03d: 我吃 buf[%d] = %s\n", i, ptr, thing[g_buf.product[ptr]]);

Sleep(rate*rand()%10+110);

// 消费完毕,并释放一个缓冲
printf(" 猪头-%03d: 我爽了! buf[%d] = %s\n", i, ptr, thing[g_buf.product[ptr]]);
V(g_semBuffer);
}
return 0;
}

// 生产者线程
DWORD WINAPI Producer(LPVOID para)
{
int i = *(int *)para - CONSUMER_NUM;
int ptr;
int data; // 产品

printf("工作狂-%03d: 我来啦!\n", i);

Sleep(300);
while (1)
{
printf("工作狂-%03d: 我干干干…………\n", i);
Sleep(rate*rand()%10+110);

data = rand()%10;
printf("工作狂-%03d: 搞出一个东西 data = %s!\n", i, thing[data]);
// 等待存放空间
P(g_semBuffer);

// 有地方,先锁住缓冲区 g_buf
P(g_mutex);

// 记录消费的物品
ptr = g_buf.end;

// 再移动缓冲区指针
g_buf.end = (g_buf.end+1)%BUFFER_NUM;

// 让其他消费者或生产者使用 g_buf
V(g_mutex);

printf("工作狂-%03d: 搁到 buf[%d] = %s\n", i, ptr, thing[data]);
g_buf.product[ptr] = data;

Sleep(rate/2*rand()%10+110);

// 放好了完毕,释放一个产品
printf("工作狂-%03d: buf[%d] = %s 放好了,大家吃!\n", i, ptr, thing[g_buf.product[ptr]]);
V(g_semProduct);
}
return 0;
}

int main(int argc, char *argv[])
{
// 线程技术,前面为消费者线程,后面为生产者线程
HANDLE hThread[CONSUMER_NUM+PRODUCER_NUM]; // 线程计数

//srand(time());
DWORD tid;
int i=0;

// 初始化信号量
g_mutex = CreateSemaphore(NULL, BUFFER_NUM, BUFFER_NUM, "mutexOfConsumerAndProducer");
g_semBuffer = CreateSemaphore(NULL, BUFFER_NUM, BUFFER_NUM, "BufferSemaphone");
g_semProduct = CreateSemaphore(NULL, 0, BUFFER_NUM, "ProductSemaphone");

if ( !g_semBuffer || !g_semProduct || !g_mutex)
{
printf("Create Semaphone Error!\n");
return -1;
}

int totalThreads = CONSUMER_NUM+PRODUCER_NUM;
// 开启消费者线程
printf("先请猪头们上席!\n");
for (i=0; i<CONSUMER_NUM; i++)
{
hThread[i] = CreateThread(NULL, 0, Consumer, &i, 0, &tid);
if ( hThread[i] ) WaitForSingleObject(hThread[i], 10);
}

printf("厨子们就位!\n");
for (; i<totalThreads; i++)
{
hThread[i] = CreateThread(NULL, 0, Producer, &i, 0, &tid);
if ( hThread[i] ) WaitForSingleObject(hThread[i], 10);
}

// 生产者和消费者的执行
WaitForMultipleObjects(totalThreads, hThread, TRUE, INFINITE);
return 0;
}


上一篇:电视纪录片

下一篇:没有了