java 用 redis实现消息队列&发布/订阅模式使用
Redis的列表类型键可以用来实现队列,并且支持阻塞式读取,可以很容易的实现一个高性能的优先队列。同时在更高层面上,Redis还支持"发布/订阅"的消息模式,可以基于此构建一个聊天系统。
一、redis的列表类型天生支持用作消息队列。(类似于MQ的队列模型–任何时候都可以消费,一条消息只能消费一次)
list操作参考:https://www.cnblogs.com/qlqwjy/p/7789125.html
在Redis中,List类型是按照插入顺序排序的字符串链表。和数据结构中的普通链表一样,我们可以在其头部(left)和尾部(right)添加新的元素。在插入时,如果该键并不存在,Redis将为该键创建一个新的链表。与此相反,如果链表中所有的元素均被移除,那么该键也将会被从数据库中删除。List中可以包含的最大元素数量是4294967295。
从元素插入和删除的效率视角来看,如果我们是在链表的两头插入或删除元素,这将会是非常高效的操作,即使链表中已经存储了百万条记录,该操作也可以在常量时间内完成。然而需要说明的是,如果元素插入或删除操作是作用于链表中间,那将会是非常低效的。相信对于有良好数据结构基础的开发者而言,这一点并不难理解。(类似于java的ArrayList)
public class JedisPoolUtils {
private static JedisPoolConfig pool = null;
static {
//加载配置文件
InputStream in = JedisPoolUtils.class.getClassLoader().getResourceAsStream("redis.properties");
Properties pro = new Properties();
try {
pro.load(in);
} catch (IOException e) {
e.printStackTrace();
}
//获得池子对象
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxIdle(Integer.parseInt(pro.get("redis.maxIdle").toString()));//最大闲置个数
poolConfig.setMaxWaitMillis(Integer.parseInt(pro.get("redis.maxWait").toString()));//最大闲置个数
poolConfig.setMinIdle(Integer.parseInt(pro.get("redis.minIdle").toString()));//最小闲置个数
poolConfig.setMaxTotal(Integer.parseInt(pro.get("redis.maxTotal").toString()));//最大连接数
// 哨兵信息
Set<String> sentinels = new HashSet<>(Arrays.asList("128.196.96.43:7101",
"128.196.96.43:7102","128.196.96.43:7103"));
// 创建连接池
JedisSentinelPool pool = new JedisSentinelPool("mymaster", sentinels,jedisPoolConfig,"redis123");
}
//获得jedis资源的方法
public static Jedis getJedis() {
return pool.getResource();
}
public static void main(String[] args) {
Jedis jedis = getJedis();
System.out.println(jedis);
}
}
在调用redis连接池时一直报验证问题,在Linux客户端./redis-cli -h 128.196.96.43 -p 7101
info 命令提示要验证,输入密码提示正确
追踪源码,发现源码在通过哨兵地址查询redis服务器地址时没有增加验证,
在JedisSentinelPool里增加哨兵验证
增加生产者(开启5个线程)
import redis.clients.jedis.Jedis;
/**
* @Author: qlq
* @Description
* @Date: 21:29 2018/10/9
*/
public class MessageProducer extends Thread {
public static final String MESSAGE_KEY = "message:queue";
private volatile int count;
public void putMessage(String message) {
Jedis jedis = JedisPoolUtils.getJedis();
Long size = jedis.lpush(MESSAGE_KEY, message);
System.out.println(Thread.currentThread().getName() + " put message,size=" + size + ",count=" + count);
count++;
}
@Override
public synchronized void run() {
for (int i = 0; i < 5; i++) {
putMessage("message" + count);
}
}
public static void main(String[] args) {
MessageProducer messageProducer = new MessageProducer();
Thread t1 = new Thread(messageProducer, "thread1");
Thread t2 = new Thread(messageProducer, "thread2");
Thread t3 = new Thread(messageProducer, "thread3");
Thread t4 = new Thread(messageProducer, "thread4");
Thread t5 = new Thread(messageProducer, "thread5");
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}
}
结果:(证明了redis是单线程操作,只能一个一个操作)
thread1 put message,size=1,count=0
thread1 put message,size=2,count=1
thread1 put message,size=3,count=2
thread1 put message,size=4,count=3
thread1 put message,size=5,count=4
thread3 put message,size=6,count=5
thread3 put message,size=7,count=6
thread3 put message,size=8,count=7
thread3 put message,size=9,count=8
thread3 put message,size=10,count=9
thread4 put message,size=11,count=10
thread4 put message,size=12,count=11
thread4 put message,size=13,count=12
thread4 put message,size=14,count=13
thread4 put message,size=15,count=14
thread5 put message,size=16,count=15
thread5 put message,size=17,count=16
thread5 put message,size=18,count=17
thread5 put message,size=19,count=18
thread5 put message,size=20,count=19
thread2 put message,size=21,count=20
thread2 put message,size=22,count=21
thread2 put message,size=23,count=22
thread2 put message,size=24,count=23
thread2 put message,size=25,count=24
(2)消息消费者:(开启两个线程消费消息)
import redis.clients.jedis.Jedis;
/**
* @Author: qlq
* @Description
* @Date: 22:34 2018/10/9
*/
public class MessageConsumer implements Runnable {
public static final String MESSAGE_KEY = "message:queue";
private volatile int count;
public void consumerMessage() {
Jedis jedis = JedisPoolUtils.getJedis();
String message = jedis.rpop(MESSAGE_KEY);
System.out.println(Thread.currentThread().getName() + " consumer message,message=" + message + ",count=" + count);
count++;
}
@Override
public void run() {
while (true) {
consumerMessage();
}
}
public static void main(String[] args) {
MessageConsumer messageConsumer = new MessageConsumer();
Thread t1 = new Thread(messageConsumer, "thread6");
Thread t2 = new Thread(messageConsumer, "thread7");
t1.start();
t2.start();
}
}
结果:(满足先进先出的规则)–消息已经消费完了(但是多线程会重复消费,并且仍然在不停的rpop,所以造成浪费,最后抛出异常c)
根据上述例子中消息消费者有一个问题存在,即需要不停的调用rpop方法查看List中是否有待处理消息。每调用一次都会发起一次连接,这会造成不必要的浪费。也许你会使用Thread.sleep()等方法让消费者线程隔一段时间再消费,但这样做有两个问题:
1)、如果生产者速度大于消费者消费速度,消息队列长度会一直增大,时间久了会占用大量内存空间 和连接资源。
2)、如果睡眠时间过长,这样不能处理一些时效性的消息,睡眠时间过短,也会在连接上造成比较大的开销。
补充:brpop和blpop实现阻塞读取(重要)
也就是上面的操作需要一直调用rpop命令或者lpop命令才可以实现不停的监听且消费消息。为了解决这一问题,redis提供了阻塞命令 brpop和blpop,也就是brpop会阻塞队列,并且每次也是弹出一个消息,如果没有消息会阻塞。
改造上面代码实现阻塞读取:
import redis.clients.jedis.Jedis;
import java.util.List;
/**
* @Author: qlq
* @Description
* @Date: 22:34 2018/10/9
*/
public class MessageConsumer implements Runnable {
public static final String MESSAGE_KEY = "message:queue";
private volatile int count;
private Jedis jedis = JedisPoolUtils.getJedis();
public void consumerMessage() {
List<String> brpop = jedis.brpop(0, MESSAGE_KEY);//0是timeout,返回的是一个集合,第一个是消息的key,第二个是消息的内容
System.out.println(brpop);
}
@Override
public void run() {
while (true) {
consumerMessage();
}
}
public static void main(String[] args) {
MessageConsumer messageConsumer = new MessageConsumer();
Thread t1 = new Thread(messageConsumer, "thread6");
Thread t2 = new Thread(messageConsumer, "thread7");
t1.start();
t2.start();
}
}
重新生产消息,消费者会自动消费消息,而且消费者会阻塞直到有消息。
二、发布/订阅模式(类似于MQ的主题模式-只能消费订阅之后发布的消息,一个消息可以被多个订阅者消费)
1.客户端发布/订阅
1.1 普通的发布/订阅
除了实现任务队列外,redis还提供了一组命令可以让开发者实现"发布/订阅"(publish/subscribe)模式。"发布/订阅"模式同样可以实现进程间的消息传递,其原理如下:
"发布/订阅"模式包含两种角色,分别是发布者和订阅者。订阅者可以订阅一个或者多个频道(channel),而发布者可以向指定的频道(channel)发送消息,所有订阅此频道的订阅者都会收到此消息。
1.2 按照规则发布/订阅
除了可以使用subscribe命令订阅指定的频道外,还可以使用psubscribe命令订阅指定的规则。规则支持通配符格式。命令格式为 psubscribe pattern [pattern …]订阅多个模式的频道。
通配符中?表示1个占位符,*表示任意个占位符(包括0),?*表示1个以上占位符
1.生产者
import redis.clients.jedis.Jedis;
/**
* @Author: qlq
* @Description
* @Date: 21:29 2018/10/9
*/
public class MessageProducer extends Thread {
public static final String CHANNEL_KEY = "channel:1";
private volatile int count;
public void putMessage(String message) {
Jedis jedis = JedisPoolUtils.getJedis();
Long publish = jedis.publish(CHANNEL_KEY, message);//返回订阅者数量
System.out.println(Thread.currentThread().getName() + " put message,count=" + count+",subscriberNum="+publish);
count++;
}
@Override
public synchronized void run() {
for (int i = 0; i < 5; i++) {
putMessage("message" + count);
}
}
public static void main(String[] args) {
MessageProducer messageProducer = new MessageProducer();
Thread t1 = new Thread(messageProducer, "thread1");
Thread t2 = new Thread(messageProducer, "thread2");
Thread t3 = new Thread(messageProducer, "thread3");
Thread t4 = new Thread(messageProducer, "thread4");
Thread t5 = new Thread(messageProducer, "thread5");
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}
}
2.消费者
(1)subscribe实现订阅消费消息(开启两个线程订阅消息)
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPubSub;
/**
* @Author: qlq
* @Description
* @Date: 22:34 2018/10/9
*/
public class MessageConsumer implements Runnable {
public static final String CHANNEL_KEY = "channel:1";//频道
public static final String EXIT_COMMAND = "exit";//结束程序的消息
private MyJedisPubSub myJedisPubSub = new MyJedisPubSub();//处理接收消息
public void consumerMessage() {
Jedis jedis = JedisPoolUtils.getJedis();
jedis.subscribe(myJedisPubSub, CHANNEL_KEY);//第一个参数是处理接收消息,第二个参数是订阅的消息频道
}
@Override
public void run() {
while (true) {
consumerMessage();
}
}
public static void main(String[] args) {
MessageConsumer messageConsumer = new MessageConsumer();
Thread t1 = new Thread(messageConsumer, "thread5");
Thread t2 = new Thread(messageConsumer, "thread6");
t1.start();
t2.start();
}
}
/**
* 继承JedisPubSub,重写接收消息的方法
*/
class MyJedisPubSub extends JedisPubSub {
@Override
/** JedisPubSub类是一个没有抽象方法的抽象类,里面方法都是一些空实现
* 所以可以选择需要的方法覆盖,这儿使用的是SUBSCRIBE指令,所以覆盖了onMessage
* 如果使用PSUBSCRIBE指令,则覆盖onPMessage方法
* 当然也可以选择BinaryJedisPubSub,同样是抽象类,但方法参数为byte[]
**/
public void onMessage(String channel, String message) {
System.out.println(Thread.currentThread().getName()+"-接收到消息:channel=" + channel + ",message=" + message);
//接收到exit消息后退出
if (MessageConsumer.EXIT_COMMAND.equals(message)) {
System.exit(0);
}
}
}
(2)psubscribe实现订阅消费消息(开启两个线程订阅消息)
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPubSub;
/**
* @Author: qlq
* @Description
* @Date: 22:34 2018/10/9
*/
public class MessageConsumer implements Runnable {
public static final String CHANNEL_KEY = "channel*";//频道
public static final String EXIT_COMMAND = "exit";//结束程序的消息
private MyJedisPubSub myJedisPubSub = new MyJedisPubSub();//处理接收消息
public void consumerMessage() {
Jedis jedis = JedisPoolUtils.getJedis();
jedis.psubscribe(myJedisPubSub, CHANNEL_KEY);//第一个参数是处理接收消息,第二个参数是订阅的消息频道
}
@Override
public void run() {
while (true) {
consumerMessage();
}
}
public static void main(String[] args) {
MessageConsumer messageConsumer = new MessageConsumer();
Thread t1 = new Thread(messageConsumer, "thread5");
Thread t2 = new Thread(messageConsumer, "thread6");
t1.start();
t2.start();
}
}
/**
* 继承JedisPubSub,重写接收消息的方法
*/
class MyJedisPubSub extends JedisPubSub {
@Override
public void onPMessage(String pattern, String channel, String message) {
System.out.println(Thread.currentThread().getName()+"-接收到消息:pattern="+pattern+",channel=" + channel + ",message=" + message);
//接收到exit消息后退出
if (MessageConsumer.EXIT_COMMAND.equals(message)) {
System.exit(0);
}
}
}
补充:订阅的时候subscribe()和psubscribe()的第二个参数支持可变参数,也就是可以实现订阅多个频道。
至此实现了两种方式的消息队列:
redis自带的list类型(lpush和rpop或者brpop,rpush和lpop或者blpop)—blpop和brpop是阻塞读取。
"发布/订阅"模式(publish channel message 和 subscribe channel [channel …] 或者 psubscribe pattern [pattern …] 通配符订阅多个频道)
补充:
1.发布订阅执行订阅之后该线程处于阻塞状态,线程不会终止,如果终止线程需要退订,需要调用JedisPubSub的unsubscribe()方法
例如:
package plainTest;
import cn.xm.redisChat.util.JedisPoolUtils;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPubSub;
/**
* @Author: qlq
* @Description
* @Date: 23:36 2018/10/13
*/
public class Test111 {
public static void main(String[] args) {
Jedis jedis = JedisPoolUtils.getJedis();
System.out.println("订阅前");
jedis.subscribe(new JedisPubSub() {
@Override
public void onMessage(String channel, String message) {
super.onMessage(channel, message);
}
}, "c1");
System.out.println("订阅后");
}
}
结果只会打印订阅前,而且线程不会终止。
为了使线程可以停止,必须退订,而且退订只能调用 JedisPubSub.unsubscribe()方法,例如:收到quit消息之后会退订,线程会回到主线程打印订阅后。
package plainTest;
import cn.xm.redisChat.util.JedisPoolUtils;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPubSub;
/**
* @Author: qlq
* @Description
* @Date: 23:36 2018/10/13
*/
public class Test111 {
public static void main(String[] args) {
Jedis jedis = JedisPoolUtils.getJedis();
System.out.println("订阅前");
jedis.subscribe(new JedisPubSub() {
@Override
public void onMessage(String channel, String message) {
if("quit".equals(message)){
unsubscribe("c1");
}
System.out.println(message);
}
@Override
public void unsubscribe(String... channels) {
super.unsubscribe(channels);
}
}, "c1");
System.out.println("订阅后");
}
}
2.BRPOP:当给定列表内没有任何元素可供弹出的时候,连接将被BRPOP命令阻塞,直到等待超时或发现可弹出元素为止。(每次只弹出一个元素,当没有元素的时候处于阻塞,当弹出一个元素之后就会解除阻塞)
package plainTest;
import cn.xm.redisChat.util.JedisPoolUtils;
import redis.clients.jedis.Jedis;
import java.util.List;
/**
* @Author: qlq
* @Description
* @Date: 23:36 2018/10/13
*/
public class Test111 {
public static void main(String[] args) {
Jedis jedis = JedisPoolUtils.getJedis();
System.out.println("brpop之前");
List<String> messages = jedis.brpop(0,"list1");
System.out.println(messages);
System.out.println("brpop之后");
}
}
没有元素的时候只会打印brpop之前
本文Redis队列实现来自https://www.cnblogs.com/qlqwjy/p/9763754.html
以此实现的消息队列有个致命的问题:
1、消息一旦发布,不能接收。换句话就是发布时若客户端不在线或者处理消息时出现异常,则消息丢失,不能寻回
2、不能保证每个消费者接收的时间是一致的
若消费者客户端出现消息积压,到一定程度,会被强制断开,导致消息意外丢失。通常发生在消息的生产远大于消费速度时