在项目中用到了redis作为缓存，再学习了ActiveMq之后想着用redis实现简单的消息队列，下面做记录。

 　　Redis的列表类型键可以用来实现队列，并且支持阻塞式读取，可以很容易的实现一个高性能的优先队列。同时在更高层面上，Redis还支持"发布/订阅"的消息模式，可以基于此构建一个聊天系统。

一、redis的列表类型天生支持用作消息队列。(类似于MQ的队列模型--任何时候都可以消费，一条消息只能消费一次)

　　list操作参考:https://www.cnblogs.com/qlqwjy/p/7789125.html

　　   在Redis中，List类型是按照插入顺序排序的字符串链表。和数据结构中的普通链表一样，我们可以在其头部(left)和尾部(right)添加新的元素。在插入时，如果该键并不存在，Redis将为该键创建一个新的链表。与此相反，如果链表中所有的元素均被移除，那么该键也将会被从数据库中删除。List中可以包含的最大元素数量是4294967295。
      从元素插入和删除的效率视角来看，如果我们是在链表的两头插入或删除元素，这将会是非常高效的操作，即使链表中已经存储了百万条记录，该操作也可以在常量时间内完成。然而需要说明的是，如果元素插入或删除操作是作用于链表中间，那将会是非常低效的。相信对于有良好数据结构基础的开发者而言，这一点并不难理解。(类似于java的ArrayList)

redis对list的操作命令中。L表示从左边(头部)开始插与弹出，R表示从右边(尾部)开始插与弹出。

1.redis中简单的操作list，简单的在命令行操作实现队列

(1)从左向右插入，从右向左弹出:

  1. 127.0.0.1:> lpush mylist a b c d
  2. (integer)
  3. 127.0.0.1:> lrange mylist  -
  4. ) "d"
  5. ) "c"
  6. ) "b"
  7. ) "a"
  8. 127.0.0.1:> rpop mylist
  9. "a"
  10. 127.0.0.1:> rpop mylist
  11. "b"

执行完   lpush mylist a b c d  之后数据结构如下:(满足先进先出的队列模式)

执行完第一次:rpop mylist之后数据结构如下:

(2)从右向左插入，从左向右弹出:

  1. 127.0.0.1:> rpush mylist2 a b c d
  2. (integer)
  3. 127.0.0.1:> lrange mylist2  -
  4. ) "a"
  5. ) "b"
  6. ) "c"
  7. ) "d"
  8. 127.0.0.1:> lpop mylist2
  9. "a"
  10. 127.0.0.1:> lpop mylist2
  11. "b"

执行完:rpush mylist2 a b c d之后的数据结构如下

第一次执行完   lpop mylist2  之后数据结构如下:(满足先进先出的队列模式)

2.JAVA程序实现消息队列

redis.properties

  1. redis.url=localhost
  2. redis.port=6379
  3. redis.maxIdle=30
  4. redis.minIdle=10
  5. redis.maxTotal=100
  6. redis.maxWait=10000

获取连接的工具类:

  1. import redis.clients.jedis.Jedis;
  2. import redis.clients.jedis.JedisPool;
  3. import redis.clients.jedis.JedisPoolConfig;
  4.  
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. import java.util.Properties;
  8.  
  9. /**
  10.  * @Author: qlq
  11.  * @Description
  12.  * @Date: 21:32 2018/10/9
  13.  */
  14. public class JedisPoolUtils {
  15.  
  16.     private static JedisPool pool = null;
  17.  
  18.     static {
  19.  
  20.         //加载配置文件
  21.         InputStream in = JedisPoolUtils.class.getClassLoader().getResourceAsStream("redis.properties");
  22.         Properties pro = new Properties();
  23.         try {
  24.             pro.load(in);
  25.         } catch (IOException e) {
  26.             e.printStackTrace();
  27.         }
  28.  
  29.         //获得池子对象
  30.         JedisPoolConfig poolConfig = new JedisPoolConfig();
  31.         poolConfig.setMaxIdle(Integer.parseInt(pro.get("redis.maxIdle").toString()));//最大闲置个数
  32.         poolConfig.setMaxWaitMillis(Integer.parseInt(pro.get("redis.maxWait").toString()));//最大闲置个数
  33.         poolConfig.setMinIdle(Integer.parseInt(pro.get("redis.minIdle").toString()));//最小闲置个数
  34.         poolConfig.setMaxTotal(Integer.parseInt(pro.get("redis.maxTotal").toString()));//最大连接数
  35.         pool = new JedisPool(poolConfig, pro.getProperty("redis.url"), Integer.parseInt(pro.get("redis.port").toString()));
  36.     }
  37.  
  38.     //获得jedis资源的方法
  39.     public static Jedis getJedis() {
  40.         return pool.getResource();
  41.     }
  42.  
  43.     public static void main(String[] args) {
  44.         Jedis jedis = getJedis();
  45.         System.out.println(jedis);
  46.     }
  47. }

 (1)消息生产者:(开启5个线程生产消息)

  1. import redis.clients.jedis.Jedis;
  2.  
  3. /**
  4.  * @Author: qlq
  5.  * @Description
  6.  * @Date: 21:29 2018/10/9
  7.  */
  8. public class MessageProducer extends Thread {
  9.     public static final String MESSAGE_KEY = "message:queue";
  10.     private volatile int count;
  11.  
  12.     public void putMessage(String message) {
  13.         Jedis jedis = JedisPoolUtils.getJedis();
  14.         Long size = jedis.lpush(MESSAGE_KEY, message);
  15.         System.out.println(Thread.currentThread().getName() + " put message,size=" + size + ",count=" + count);
  16.         count++;
  17.     }
  18.  
  19.     @Override
  20.     public synchronized void run() {
  21.         for (int i = 0; i < 5; i++) {
  22.             putMessage("message" + count);
  23.         }
  24.     }
  25.  
  26.     public static void main(String[] args) {
  27.         MessageProducer messageProducer = new MessageProducer();
  28.         Thread t1 = new Thread(messageProducer, "thread1");
  29.         Thread t2 = new Thread(messageProducer, "thread2");
  30.         Thread t3 = new Thread(messageProducer, "thread3");
  31.         Thread t4 = new Thread(messageProducer, "thread4");
  32.         Thread t5 = new Thread(messageProducer, "thread5");
  33.         t1.start();
  34.         t2.start();
  35.         t3.start();
  36.         t4.start();
  37.         t5.start();
  38.     }
  39. }

结果：(证明了redis是单线程操作，只能一个一个操作)

  1. thread1 put message,size=1,count=0
  2. thread1 put message,size=2,count=1
  3. thread1 put message,size=3,count=2
  4. thread1 put message,size=4,count=3
  5. thread1 put message,size=5,count=4
  6. thread3 put message,size=6,count=5
  7. thread3 put message,size=7,count=6
  8. thread3 put message,size=8,count=7
  9. thread3 put message,size=9,count=8
  10. thread3 put message,size=10,count=9
  11. thread4 put message,size=11,count=10
  12. thread4 put message,size=12,count=11
  13. thread4 put message,size=13,count=12
  14. thread4 put message,size=14,count=13
  15. thread4 put message,size=15,count=14
  16. thread5 put message,size=16,count=15
  17. thread5 put message,size=17,count=16
  18. thread5 put message,size=18,count=17
  19. thread5 put message,size=19,count=18
  20. thread5 put message,size=20,count=19
  21. thread2 put message,size=21,count=20
  22. thread2 put message,size=22,count=21
  23. thread2 put message,size=23,count=22
  24. thread2 put message,size=24,count=23
  25. thread2 put message,size=25,count=24

redis后台查看:

  1. 127.0.0.1:6379> lrange message:queue 0 -1
  2.  1) "message24"
  3.  2) "message23"
  4.  3) "message22"
  5.  4) "message21"
  6.  5) "message20"
  7.  6) "message19"
  8.  7) "message18"
  9.  8) "message17"
  10.  9) "message16"
  11. 10) "message15"
  12. 11) "message14"
  13. 12) "message13"
  14. 13) "message12"
  15. 14) "message11"
  16. 15) "message10"
  17. 16) "message9"
  18. 17) "message8"
  19. 18) "message7"
  20. 19) "message6"
  21. 20) "message5"
  22. 21) "message4"
  23. 22) "message3"
  24. 23) "message2"
  25. 24) "message1"
  26. 25) "message0"

 (2)消息消费者:(开启两个线程消费消息)

  1. import redis.clients.jedis.Jedis;
  2.  
  3. /**
  4.  * @Author: qlq
  5.  * @Description
  6.  * @Date: 22:34 2018/10/9
  7.  */
  8. public class MessageConsumer implements Runnable {
  9.     public static final String MESSAGE_KEY = "message:queue";
  10.     private volatile int count;
  11.  
  12.     public void consumerMessage() {
  13.         Jedis jedis = JedisPoolUtils.getJedis();
  14.         String message = jedis.rpop(MESSAGE_KEY);
  15.         System.out.println(Thread.currentThread().getName() + " consumer message,message=" + message + ",count=" + count);
  16.         count++;
  17.     }
  18.  
  19.     @Override
  20.     public void run() {
  21.         while (true) {
  22.             consumerMessage();
  23.         }
  24.     }
  25.  
  26.     public static void main(String[] args) {
  27.         MessageConsumer messageConsumer = new MessageConsumer();
  28.         Thread t1 = new Thread(messageConsumer, "thread6");
  29.         Thread t2 = new Thread(messageConsumer, "thread7");
  30.         t1.start();
  31.         t2.start();
  32.     }
  33. }

结果:(满足先进先出的规则)--虽然消息已经消费完了，但是仍然在不停的rpop，所以造成浪费

  1. thread6 consumer message,message=message0,count=0
  2. thread6 consumer message,message=message1,count=1
  3. thread6 consumer message,message=message2,count=2
  4. thread6 consumer message,message=message3,count=3
  5. thread7 consumer message,message=message4,count=4
  6. thread6 consumer message,message=message5,count=5
  7. thread7 consumer message,message=message6,count=6
  8. thread6 consumer message,message=message7,count=7
  9. thread7 consumer message,message=message8,count=8
  10. thread6 consumer message,message=message9,count=9
  11. thread7 consumer message,message=message10,count=10
  12. thread6 consumer message,message=message11,count=11
  13. thread7 consumer message,message=message12,count=12
  14. thread6 consumer message,message=message13,count=13
  15. thread7 consumer message,message=message14,count=14
  16. thread6 consumer message,message=message15,count=15
  17. thread7 consumer message,message=message16,count=16
  18. thread6 consumer message,message=message17,count=16
  19. thread7 consumer message,message=message18,count=18
  20. thread6 consumer message,message=message19,count=19
  21. thread7 consumer message,message=message20,count=20
  22. thread6 consumer message,message=message21,count=20
  23. thread7 consumer message,message=message22,count=22
  24. thread6 consumer message,message=message23,count=22
  25. thread7 consumer message,message=message24,count=24
  26. thread6 consumer message,message=null,count=25
  27. thread7 consumer message,message=null,count=26
  28. thread6 consumer message,message=null,count=27
  29. thread7 consumer message,message=null,count=28
  30. thread6 consumer message,message=null,count=28
  31. thread7 consumer message,message=null,count=30
  32. thread6 consumer message,message=null,count=31
    ...

　　 但上述例子中消息消费者有一个问题存在，即需要不停的调用rpop方法查看List中是否有待处理消息。每调用一次都会发起一次连接，这会造成不必要的浪费。也许你会使用Thread.sleep()等方法让消费者线程隔一段时间再消费，但这样做有两个问题：

1）、如果生产者速度大于消费者消费速度，消息队列长度会一直增大，时间久了会占用大量内存空间。

2）、如果睡眠时间过长，这样不能处理一些时效性的消息，睡眠时间过短，也会在连接上造成比较大的开销。

补充:brpop和blpop实现阻塞读取(重要)

　　也就是上面的操作需要一直调用rpop命令或者lpop命令才可以实现不停的监听且消费消息。为了解决这一问题，redis提供了阻塞命令 brpop和blpop。下面以brpop命名为例进行试验:

　　brpop命令可以接收多个键，其完整的命令格式为 BRPOP key [key ...] timeout,如:brpop key1 0。意义是同时检测多个键，如果所有键都没有元素则阻塞，如果其中一个有元素则从该键中弹出该元素(会按照key的顺序进行读取，可以实现具有优先级的队列)。例如下面试验:

开启两个客户端，第一个客户端中采用brpop阻塞读取两个键:

  1. 127.0.0.1:> brpop mylist1 mylist2

第二个客户端增加mylist1 :

  1. 127.0.0.1:> lpush mylist1
  2. (integer)

则在第一个客户端显示:

  1. 127.0.0.1:> brpop mylist1 mylist2
  2. ) "mylist1"
  3. ) ""
  4. (.31s)

也就是brpop会阻塞队列，并且每次也是弹出一个消息，如果没有消息会阻塞。

如果多个键都有元素则按照从左到右读取第一个键中的一个元素，例如我们现在queue1和queue2各自添加一个元素：

  1. 127.0.0.1:> lpush queue1
  2. (integer)
  3. 127.0.0.1:> lpush queue2
  4. (integer)

然后执行brpop命令:(会返回读取的key和value，第一个是返回的key，第二个是value)

  1. 127.0.0.1:> brpop queue1 queue2
  2. ) "queue1"
  3. ) ""

　　借此特性可以实现区分优先级的任务队列。也就是brpop会按照key的顺序依次读取一个数据。

改造上面代码实现阻塞读取:

  1. import redis.clients.jedis.Jedis;
  2.  
  3. import java.util.List;
  4.  
  5. /**
  6.  * @Author: qlq
  7.  * @Description
  8.  * @Date: 22:34 2018/10/9
  9.  */
  10. public class MessageConsumer implements Runnable {
  11.     public static final String MESSAGE_KEY = "message:queue";
  12.     private volatile int count;
  13.     private Jedis jedis = JedisPoolUtils.getJedis();
  14.  
  15.     public void consumerMessage() {
  16.         List<String> brpop = jedis.brpop(0, MESSAGE_KEY);//0是timeout,返回的是一个集合，第一个是消息的key，第二个是消息的内容
  17.         System.out.println(brpop);
  18.     }
  19.  
  20.     @Override
  21.     public void run() {
  22.         while (true) {
  23.             consumerMessage();
  24.         }
  25.     }
  26.  
  27.     public static void main(String[] args) {
  28.         MessageConsumer messageConsumer = new MessageConsumer();
  29.         Thread t1 = new Thread(messageConsumer, "thread6");
  30.         Thread t2 = new Thread(messageConsumer, "thread7");
  31.         t1.start();
  32.         t2.start();
  33.     }
  34. }

　　然后可以运行Customer，清空控制台，可以看到程序没有任何输出，阻塞在了brpop这儿。然后在打开Redis的客户端，输入指令client list，可以查看当前的连接个数。

　　当启动生产者生产消息之后，消费者会自动消费消息，而且消费者会阻塞直到有消息。

  1. [message:queue, message0]
  2. [message:queue, message1]
  3. [message:queue, message2]
  4. [message:queue, message3]
  5. [message:queue, message4]
  6. [message:queue, message5]
  7. [message:queue, message6]
  8. [message:queue, message7]
  9. [message:queue, message8]
  10. [message:queue, message9]
  11. [message:queue, message10]
  12. [message:queue, message11]
  13. [message:queue, message12]
  14. [message:queue, message13]
  15. [message:queue, message14]
  16. [message:queue, message15]
  17. [message:queue, message16]
  18. [message:queue, message17]
  19. [message:queue, message18]
  20. [message:queue, message19]
  21. [message:queue, message20]
  22. [message:queue, message21]
  23. [message:queue, message22]
  24. [message:queue, message23]
  25. [message:queue, message24]

二、发布/订阅模式(类似于MQ的主题模式-只能消费订阅之后发布的消息，一个消息可以被多个订阅者消费)

1.客户端发布/订阅

1.1   普通的发布/订阅

　　除了实现任务队列外，redis还提供了一组命令可以让开发者实现"发布/订阅"(publish/subscribe)模式。"发布/订阅"模式同样可以实现进程间的消息传递，其原理如下:

　　"发布/订阅"模式包含两种角色，分别是发布者和订阅者。订阅者可以订阅一个或者多个频道(channel),而发布者可以向指定的频道(channel)发送消息，所有订阅此频道的订阅者都会收到此消息。

(1)发布消息

　　发布者发布消息的命令是  publish,用法是 publish channel message，如向 channel1.1说一声hi

  1. 127.0.0.1:> publish channel: hi
  2. (integer)

　　这样消息就发出去了。返回值表示接收这条消息的订阅者数量。发出去的消息不会被持久化，也就是有客户端订阅channel:1后只能接收到后续发布到该频道的消息，之前的就接收不到了。

(2)订阅频道

　　订阅频道的命令是 subscribe，可以同时订阅多个频道，用法是 subscribe channel1 [channel2 ...],例如新开一个客户端订阅上面频道:(不会收到消息，因为不会收到订阅之前就发布到该频道的消息)

  1. 127.0.0.1:> subscribe channel:
  2. Reading messages... (press Ctrl-C to quit)
  3. ) "subscribe"
  4. ) "channel:1"
  5. ) (integer)

　　执行上面命令客户端会进入订阅状态，处于此状态下客户端不能使用除subscribe、unsubscribe、psubscribe和punsubscribe这四个属于"发布/订阅"之外的命令，否则会报错。

　　进入订阅状态后客户端可能收到3种类型的回复。每种类型的回复都包含3个值，第一个值是消息的类型，根据消类型的不同，第二个和第三个参数的含义可能不同。

消息类型的取值可能是以下3个:

　　(1)subscribe。表示订阅成功的反馈信息。第二个值是订阅成功的频道名称，第三个是当前客户端订阅的频道数量。

　　(2)message。表示接收到的消息，第二个值表示产生消息的频道名称，第三个值是消息的内容。

　　(3)unsubscribe。表示成功取消订阅某个频道。第二个值是对应的频道名称，第三个值是当前客户端订阅的频道数量，当此值为0时客户端会退出订阅状态，之后就可以执行其他非"发布/订阅"模式的命令了。

(3)第一个客户端重新向channel:1发送一条消息

  1. 127.0.0.1:> publish channel: hi
  2. (integer)

返回值表示订阅此频道的数量

c

上面订阅的客户端:

  1. 127.0.0.1:> subscribe channel:
  2. Reading messages... (press Ctrl-C to quit)
  3. ) "subscribe"
  4. ) "channel:1"
  5. ) (integer)
  6. 1) "message"
  7. 2) "channel:1"
  8. 3) "hi"

　　红字部分表示成功的收到消息(依次是消息类型，频道，消息内容)

1.2   按照规则发布/订阅

　　除了可以使用subscribe命令订阅指定的频道外，还可以使用psubscribe命令订阅指定的规则。规则支持通配符格式。命令格式为      psubscribe pattern [pattern ...]订阅多个模式的频道。

　　通配符中?表示1个占位符，*表示任意个占位符(包括0)，?*表示1个以上占位符。

例如:

(1)订阅者订阅三个通配符频道

  1. 127.0.0.1:> psubscribe c? b* d?*
  2. Reading messages... (press Ctrl-C to quit)
  3. ) "psubscribe"
  4. ) "c?"
  5. ) (integer)
  6. ) "psubscribe"
  7. ) "b*"
  8. ) (integer)
  9. ) "psubscribe"
  10. ) "d?*"
  11. ) (integer)

(2)新开一个客户端发送到指定频道

  1. C:\Users\liqiang>redis-cli
  2. 127.0.0.1:> publish c m1
  3. (integer)
  4. 127.0.0.1:> publish c1 m1
  5. (integer)
  6. 127.0.0.1:> publish c11 m1
  7. (integer)
  8. 127.0.0.1:> publish b m1
  9. (integer)
  10. 127.0.0.1:> publish b1 m1
  11. (integer)
  12. 127.0.0.1:> publish b11 m1
  13. (integer)
  14. 127.0.0.1:> publish d m1
  15. (integer)
  16. 127.0.0.1:> publish d1 m1
  17. (integer)
  18. 127.0.0.1:> publish d11 m1
  19. (integer)

上面返回值为1表示被订阅者所接受，可以匹配上面的通配符。

订阅者客户端:

  1. 127.0.0.1:> psubscribe c? b* d?*
  2. Reading messages... (press Ctrl-C to quit)
  3. ) "psubscribe"
  4. ) "c?"
  5. ) (integer)
  6. ) "psubscribe"
  7. ) "b*"
  8. ) (integer)
  9. ) "psubscribe"
  10. ) "d?*"
  11. ) (integer)
  12. ) "pmessage"
  13. ) "c?"
  14. ) "c1"
  15. ) "m1"
  16. ) "pmessage"
  17. ) "b*"
  18. ) "b"
  19. ) "m1"
  20. ) "pmessage"
  21. ) "b*"
  22. ) "b1"
  23. ) "m1"
  24. ) "pmessage"
  25. ) "b*"
  26. ) "b11"
  27. ) "m1"
  28. ) "pmessage"
  29. ) "d?*"
  30. ) "d1"
  31. ) "m1"
  32. ) "pmessage"
  33. ) "d?*"
  34. ) "d11"
  35. ) "m1"

　

注意:

(1)使用psubscribe命令可以重复订阅同一个频道，如客户端执行了psubscribe c? c?*。这时向c1发布消息客户端会接受到两条消息，而同时publish命令的返回值是2而不是。.同样的，如果有另一个客户端执行了subscribe c1 和psubscribe c?*的话，向c1发送一条消息该客户顿也会受到两条消息(但是是两种类型:message和pmessage)，同时publish命令也返回2.

(2)punsubscribe命令可以退订指定的规则，用法是: punsubscribe [pattern [pattern ...]],如果没有参数则会退订所有规则。

(3)使用punsubscribe只能退订通过psubscribe命令订阅的规则，不会影响直接通过subscribe命令订阅的频道；同样unsubscribe命令也不会影响通过psubscribe命令订阅的规则。另外需要注意punsubscribe命令退订某个规则时不会将其中的通配符展开，而是进行严格的字符串匹配，所以punsubscribe * 无法退订c*规则，而是必须使用punsubscribe c*才可以退订。

2.Java程序实现发布者订阅者模式

1.生产者

  1. import redis.clients.jedis.Jedis;
  2.  
  3. /**
  4.  * @Author: qlq
  5.  * @Description
  6.  * @Date: 21:29 2018/10/9
  7.  */
  8. public class MessageProducer extends Thread {
  9.     public static final String CHANNEL_KEY = "channel:1";
  10.     private volatile int count;
  11.  
  12.     public void putMessage(String message) {
  13.         Jedis jedis = JedisPoolUtils.getJedis();
  14.         Long publish = jedis.publish(CHANNEL_KEY, message);//返回订阅者数量
  15.         System.out.println(Thread.currentThread().getName() + " put message,count=" + count+",subscriberNum="+publish);
  16.         count++;
  17.     }
  18.  
  19.     @Override
  20.     public synchronized void run() {
  21.         for (int i = 0; i < 5; i++) {
  22.             putMessage("message" + count);
  23.         }
  24.     }
  25.  
  26.     public static void main(String[] args) {
  27.         MessageProducer messageProducer = new MessageProducer();
  28.         Thread t1 = new Thread(messageProducer, "thread1");
  29.         Thread t2 = new Thread(messageProducer, "thread2");
  30.         Thread t3 = new Thread(messageProducer, "thread3");
  31.         Thread t4 = new Thread(messageProducer, "thread4");
  32.         Thread t5 = new Thread(messageProducer, "thread5");
  33.         t1.start();
  34.         t2.start();
  35.         t3.start();
  36.         t4.start();
  37.         t5.start();
  38.     }
  39. }

结果:

thread1 put message,count=0,subscriberNum=0
thread1 put message,count=1,subscriberNum=0
thread1 put message,count=2,subscriberNum=0
thread1 put message,count=3,subscriberNum=0
thread1 put message,count=4,subscriberNum=0
thread4 put message,count=5,subscriberNum=0
thread4 put message,count=6,subscriberNum=0
thread4 put message,count=7,subscriberNum=0
thread4 put message,count=8,subscriberNum=0
thread4 put message,count=9,subscriberNum=0
thread5 put message,count=10,subscriberNum=0
thread5 put message,count=11,subscriberNum=0
thread5 put message,count=12,subscriberNum=0
thread5 put message,count=13,subscriberNum=0
thread5 put message,count=14,subscriberNum=0
thread2 put message,count=15,subscriberNum=0
thread2 put message,count=16,subscriberNum=0
thread2 put message,count=17,subscriberNum=0
thread2 put message,count=18,subscriberNum=0
thread2 put message,count=19,subscriberNum=0
thread3 put message,count=20,subscriberNum=0
thread3 put message,count=21,subscriberNum=0
thread3 put message,count=22,subscriberNum=0
thread3 put message,count=23,subscriberNum=0
thread3 put message,count=24,subscriberNum=0

2.消费者

(1)subscribe实现订阅消费消息(开启两个线程订阅消息)

  1. import redis.clients.jedis.Jedis;
  2. import redis.clients.jedis.JedisPubSub;
  3.  
  4. /**
  5.  * @Author: qlq
  6.  * @Description
  7.  * @Date: 22:34 2018/10/9
  8.  */
  9. public class MessageConsumer implements Runnable {
  10.     public static final String CHANNEL_KEY = "channel:1";//频道
  11.  
  12.     public static final String EXIT_COMMAND = "exit";//结束程序的消息
  13.  
  14.     private MyJedisPubSub myJedisPubSub = new MyJedisPubSub();//处理接收消息
  15.  
  16.     public void consumerMessage() {
  17.         Jedis jedis = JedisPoolUtils.getJedis();
  18.         jedis.subscribe(myJedisPubSub, CHANNEL_KEY);//第一个参数是处理接收消息，第二个参数是订阅的消息频道
  19.     }
  20.  
  21.     @Override
  22.     public void run() {
  23.         while (true) {
  24.             consumerMessage();
  25.         }
  26.     }
  27.  
  28.     public static void main(String[] args) {
  29.         MessageConsumer messageConsumer = new MessageConsumer();
  30.         Thread t1 = new Thread(messageConsumer, "thread5");
  31.         Thread t2 = new Thread(messageConsumer, "thread6");
  32.         t1.start();
  33.         t2.start();
  34.     }
  35. }
  36.  
  37. /**
  38.  * 继承JedisPubSub，重写接收消息的方法
  39.  */
  40. class MyJedisPubSub extends JedisPubSub {
  41.     @Override
  42.     /** JedisPubSub类是一个没有抽象方法的抽象类,里面方法都是一些空实现
  43.      * 所以可以选择需要的方法覆盖,这儿使用的是SUBSCRIBE指令，所以覆盖了onMessage
  44.      * 如果使用PSUBSCRIBE指令，则覆盖onPMessage方法
  45.      * 当然也可以选择BinaryJedisPubSub,同样是抽象类，但方法参数为byte[]
  46.      **/
  47.     public void onMessage(String channel, String message) {
  48.         System.out.println(Thread.currentThread().getName()+"-接收到消息:channel=" + channel + ",message=" + message);
  49.         //接收到exit消息后退出
  50.         if (MessageConsumer.EXIT_COMMAND.equals(message)) {
  51.             System.exit(0);
  52.         }
  53.     }
  54. }

我们再次启动生产者生产消息,生产者控制台:

  1. thread5 put message,count=0,subscriberNum=2
  2. thread5 put message,count=1,subscriberNum=2
  3. thread5 put message,count=2,subscriberNum=2
  4. thread5 put message,count=3,subscriberNum=2
  5. thread5 put message,count=4,subscriberNum=2
  6. thread3 put message,count=5,subscriberNum=2
  7. thread3 put message,count=6,subscriberNum=2
  8. thread3 put message,count=7,subscriberNum=2
  9. thread3 put message,count=8,subscriberNum=2
  10. thread3 put message,count=9,subscriberNum=2
  11. thread2 put message,count=10,subscriberNum=2
  12. thread2 put message,count=11,subscriberNum=2
  13. thread2 put message,count=12,subscriberNum=2
  14. thread2 put message,count=13,subscriberNum=2
  15. thread2 put message,count=14,subscriberNum=2
  16. thread4 put message,count=15,subscriberNum=2
  17. thread4 put message,count=16,subscriberNum=2
  18. thread4 put message,count=17,subscriberNum=2
  19. thread4 put message,count=18,subscriberNum=2
  20. thread4 put message,count=19,subscriberNum=2
  21. thread1 put message,count=20,subscriberNum=2
  22. thread1 put message,count=21,subscriberNum=2
  23. thread1 put message,count=22,subscriberNum=2
  24. thread1 put message,count=23,subscriberNum=2
  25. thread1 put message,count=24,subscriberNum=2
  26.  
  27. Process finished with exit code 0

消费者控制台:

  1. thread6-接收到消息:channel=channel:1,message=message0
  2. thread5-接收到消息:channel=channel:1,message=message0
  3. thread5-接收到消息:channel=channel:1,message=message1
  4. thread6-接收到消息:channel=channel:1,message=message1
  5. thread5-接收到消息:channel=channel:1,message=message2
  6. thread6-接收到消息:channel=channel:1,message=message2
  7. thread5-接收到消息:channel=channel:1,message=message3
  8. thread6-接收到消息:channel=channel:1,message=message3
  9. thread5-接收到消息:channel=channel:1,message=message4
  10. thread6-接收到消息:channel=channel:1,message=message4
  11. thread5-接收到消息:channel=channel:1,message=message5
  12. thread6-接收到消息:channel=channel:1,message=message5
  13. thread5-接收到消息:channel=channel:1,message=message6
  14. thread6-接收到消息:channel=channel:1,message=message6
  15. thread5-接收到消息:channel=channel:1,message=message7
  16. thread6-接收到消息:channel=channel:1,message=message7
  17. thread5-接收到消息:channel=channel:1,message=message8
  18. thread6-接收到消息:channel=channel:1,message=message8
  19. thread5-接收到消息:channel=channel:1,message=message9
  20. thread6-接收到消息:channel=channel:1,message=message9
  21. thread5-接收到消息:channel=channel:1,message=message10
  22. thread6-接收到消息:channel=channel:1,message=message10
  23. thread5-接收到消息:channel=channel:1,message=message11
  24. thread6-接收到消息:channel=channel:1,message=message11
  25. thread5-接收到消息:channel=channel:1,message=message12
  26. thread6-接收到消息:channel=channel:1,message=message12
  27. thread5-接收到消息:channel=channel:1,message=message13
  28. thread6-接收到消息:channel=channel:1,message=message13
  29. thread5-接收到消息:channel=channel:1,message=message14
  30. thread6-接收到消息:channel=channel:1,message=message14
  31. thread5-接收到消息:channel=channel:1,message=message15
  32. thread6-接收到消息:channel=channel:1,message=message15
  33. thread5-接收到消息:channel=channel:1,message=message16
  34. thread6-接收到消息:channel=channel:1,message=message16
  35. thread5-接收到消息:channel=channel:1,message=message17
  36. thread6-接收到消息:channel=channel:1,message=message17
  37. thread5-接收到消息:channel=channel:1,message=message18
  38. thread6-接收到消息:channel=channel:1,message=message18
  39. thread5-接收到消息:channel=channel:1,message=message19
  40. thread6-接收到消息:channel=channel:1,message=message19
  41. thread5-接收到消息:channel=channel:1,message=message20
  42. thread6-接收到消息:channel=channel:1,message=message20
  43. thread5-接收到消息:channel=channel:1,message=message21
  44. thread6-接收到消息:channel=channel:1,message=message21
  45. thread5-接收到消息:channel=channel:1,message=message22
  46. thread6-接收到消息:channel=channel:1,message=message22
  47. thread5-接收到消息:channel=channel:1,message=message23
  48. thread6-接收到消息:channel=channel:1,message=message23
  49. thread5-接收到消息:channel=channel:1,message=message24
  50. thread6-接收到消息:channel=channel:1,message=message24

(2)psubscribe实现订阅消费消息(开启两个线程订阅消息)

  1. import redis.clients.jedis.Jedis;
  2. import redis.clients.jedis.JedisPubSub;
  3.  
  4. /**
  5.  * @Author: qlq
  6.  * @Description
  7.  * @Date: 22:34 2018/10/9
  8.  */
  9. public class MessageConsumer implements Runnable {
  10.     public static final String CHANNEL_KEY = "channel*";//频道
  11.  
  12.     public static final String EXIT_COMMAND = "exit";//结束程序的消息
  13.  
  14.     private MyJedisPubSub myJedisPubSub = new MyJedisPubSub();//处理接收消息
  15.  
  16.     public void consumerMessage() {
  17.         Jedis jedis = JedisPoolUtils.getJedis();
  18.         jedis.psubscribe(myJedisPubSub, CHANNEL_KEY);//第一个参数是处理接收消息，第二个参数是订阅的消息频道
  19.     }
  20.  
  21.     @Override
  22.     public void run() {
  23.         while (true) {
  24.             consumerMessage();
  25.         }
  26.     }
  27.  
  28.     public static void main(String[] args) {
  29.         MessageConsumer messageConsumer = new MessageConsumer();
  30.         Thread t1 = new Thread(messageConsumer, "thread5");
  31.         Thread t2 = new Thread(messageConsumer, "thread6");
  32.         t1.start();
  33.         t2.start();
  34.     }
  35. }
  36.  
  37. /**
  38.  * 继承JedisPubSub，重写接收消息的方法
  39.  */
  40. class MyJedisPubSub extends JedisPubSub {
  41.     @Override
  42.     public void onPMessage(String pattern, String channel, String message) {
  43.         System.out.println(Thread.currentThread().getName()+"-接收到消息:pattern="+pattern+",channel=" + channel + ",message=" + message);
  44.         //接收到exit消息后退出
  45.         if (MessageConsumer.EXIT_COMMAND.equals(message)) {
  46.             System.exit(0);
  47.         }
  48.     }
  49. }

重写JedisPubSub 的onPMessage方法即可

启动生产者生产消息之后查看消费者控制台:

  1. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message0
  2. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message0
  3. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message1
  4. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message1
  5. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message2
  6. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message2
  7. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message3
  8. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message3
  9. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message4
  10. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message4
  11. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message5
  12. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message5
  13. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message6
  14. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message6
  15. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message7
  16. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message7
  17. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message8
  18. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message8
  19. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message9
  20. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message9
  21. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message10
  22. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message10
  23. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message11
  24. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message11
  25. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message12
  26. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message12
  27. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message13
  28. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message13
  29. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message14
  30. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message14
  31. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message15
  32. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message15
  33. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message16
  34. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message16
  35. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message17
  36. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message17
  37. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message18
  38. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message18
  39. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message19
  40. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message19
  41. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message20
  42. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message20
  43. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message21
  44. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message21
  45. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message22
  46. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message22
  47. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message23
  48. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message23
  49. thread5-接收到消息:pattern=channel*,channel=channel:1,message=message24
  50. thread6-接收到消息:pattern=channel*,channel=channel:1,message=message24

补充:订阅的时候subscribe()和psubscribe()的第二个参数支持可变参数，也就是可以实现订阅多个频道。

　　至此实现了两种方式的消息队列:

　　　　redis自带的list类型(lpush和rpop或者brpop，rpush和lpop或者blpop)---blpop和brpop是阻塞读取。

　　　　"发布/订阅"模式(publish channel message 和 subscribe channel [channel ...] 或者 psubscribe pattern [pattern ...] 通配符订阅多个频道)

补充:

1.发布订阅执行订阅之后该线程处于阻塞状态，线程不会终止，如果终止线程需要退订，需要调用JedisPubSub的unsubscribe()方法

例如:

  1. package plainTest;
  2.  
  3. import cn.xm.redisChat.util.JedisPoolUtils;
  4. import redis.clients.jedis.Jedis;
  5. import redis.clients.jedis.JedisPubSub;
  6.  
  7. /**
  8.  * @Author: qlq
  9.  * @Description
  10.  * @Date: 23:36 2018/10/13
  11.  */
  12. public class Test111 {
  13.     public static void main(String[] args) {
  14.         Jedis jedis = JedisPoolUtils.getJedis();
  15.         System.out.println("订阅前");
  16.         jedis.subscribe(new JedisPubSub() {
  17.             @Override
  18.             public void onMessage(String channel, String message) {
  19.                 super.onMessage(channel, message);
  20.             }
  21.         }, "c1");
  22.         System.out.println("订阅后");
  23.     }
  24. }

结果只会打印订阅前，而且线程不会终止。

为了使线程可以停止，必须退订，而且退订只能调用  JedisPubSub.unsubscribe()方法，例如:收到quit消息之后会退订，线程会回到主线程打印订阅后。

  1. package plainTest;
  2.  
  3. import cn.xm.redisChat.util.JedisPoolUtils;
  4. import redis.clients.jedis.Jedis;
  5. import redis.clients.jedis.JedisPubSub;
  6.  
  7. /**
  8.  * @Author: qlq
  9.  * @Description
  10.  * @Date: 23:36 2018/10/13
  11.  */
  12. public class Test111 {
  13.     public static void main(String[] args) {
  14.         Jedis jedis = JedisPoolUtils.getJedis();
  15.         System.out.println("订阅前");
  16.         jedis.subscribe(new JedisPubSub() {
  17.             @Override
  18.             public void onMessage(String channel, String message) {
  19.                 if("quit".equals(message)){
  20.                     unsubscribe("c1");
  21.                 }
  22.                 System.out.println(message);
  23.             }
  24.  
  25.             @Override
  26.             public void unsubscribe(String... channels) {
  27.                 super.unsubscribe(channels);
  28.             }
  29.         }, "c1");
  30.         System.out.println("订阅后");
  31.     }
  32. }

2.BRPOP:当给定列表内没有任何元素可供弹出的时候，连接将被BRPOP命令阻塞，直到等待超时或发现可弹出元素为止。(每次只弹出一个元素，当没有元素的时候处于阻塞，当弹出一个元素之后就会解除阻塞)

  1. package plainTest;
  2.  
  3. import cn.xm.redisChat.util.JedisPoolUtils;
  4. import redis.clients.jedis.Jedis;
  5.  
  6. import java.util.List;
  7.  
  8. /**
  9.  * @Author: qlq
  10.  * @Description
  11.  * @Date: 23:36 2018/10/13
  12.  */
  13. public class Test111 {
  14.     public static void main(String[] args) {
  15.         Jedis jedis = JedisPoolUtils.getJedis();
  16.         System.out.println("brpop之前");
  17.         List<String> messages = jedis.brpop(0,"list1");
  18.         System.out.println(messages);
  19.         System.out.println("brpop之后");
  20.     }
  21. }

没有元素的时候只会打印brpop之前。

redis实现消息队列&发布/订阅模式使用的更多相关文章

  1. Spring Data Redis实现消息队列——发布/订阅模式

    一般来说,消息队列有两种场景,一种是发布者订阅者模式,一种是生产者消费者模式.利用redis这两种场景的消息队列都能够实现. 定义:生产者消费者模式:生产者生产消息放到队列里,多个消费者同时监听队列, ...

  2. 【转】redis 消息队列发布订阅模式spring boot实现

    最近做项目的时候写到一个事件推送的场景.之前的实现方式是起job一直查询数据库,看看有没有最新的消息.这种方式非常的不优雅,反正我是不能忍,由于羡慕本身就依赖redis,刚好redis 也有消息队列的 ...

  3. redis消息通知(任务队列/优先级队列/发布订阅模式)

    1.任务队列 对于发送邮件或者是复杂计算这样的操作,常常需要比较长的时间,为了不影响web应用的正常使用,避免页面显示被阻塞,常常会将此类任务存入任务队列交由专门的进程去处理. 队列最基础的方法如下: ...

  4. redis之mq实现发布订阅模式

    示例代码-github 概述 Redis不仅可作为缓存服务器,还可用作消息队列,本示例演示如何使用redis实现发布/订阅消息队列. 在Redis中,发布者没有将消息发送给特定订阅者的程序.相反,发布 ...

  5. Redis进阶篇：发布订阅模式原理与运用

    "65 哥,如果你交了个漂亮小姐姐做女朋友,你会通过什么方式将这个消息广而告之给你的微信好友?" "那不得拍点女朋友的美照 + 亲密照弄一个九宫格图文消息在朋友圈发布大肆 ...

  6. rabbitmq消息队列——"发布订阅"

    三."发布订阅" 上一节的练习中我们创建了一个工作队列.队列中的每条消息都会被发送至一个工作进程.这节,我们将做些完全不同的事情--我们将发送单个消息发送至多个消费者.这种模式就是 ...

  7. Spring Boot使用Redis进行消息的发布订阅

    今天来学习如何利用Spring Data对Redis的支持来实现消息的发布订阅机制.发布订阅是一种典型的异步通信模型,可以让消息的发布者和订阅者充分解耦.在我们的例子中,我们将使用StringRedi ...

  8. Redis实现消息的发布/订阅

    利用spring-boot结合redis进行消息的发布与订阅: 发布: class Publish { private static String topicName = “Topic:chat”; ...

  9. Redis消息通知（任务队列和发布订阅模式）

    Redis学习笔记(十)消息通知(任务队列和发布订阅模式) 1. 任务队列 1.1 任务队列的特点 任务队列:顾名思义,就是“传递消息的队列”.与任务队列进行交互的实体有两类,一类是生产者(produ ...

随机推荐

  1. mvc 验证登录

    很多时候,我们需要多个页面验证用户是否登录 有2中方法. 一种是继承 Attrbuite属性,添加验证,这个可以网上搜索. 我一般使用下面的方式 创建BaseWebController继承Contro ...

  2. python的多线程到底有没有用？

    在群里经常听到这样的争执,有人是虚心请教问题,有人就大放厥词因为这个说python辣鸡.而争论的核心无非就是,python的多线程在同一时刻只会有一条线程跑在CPU里面,其他线程都在睡觉.这是真的吗? ...

  3. loj #117. 有源汇有上下界最小流

    题目链接 有源汇有上下界最小流,->上下界网络流 注意细节,边数组也要算上后加到SS,TT边. #include<cstdio> #include<algorithm> ...

  4. cf983E NN Country (倍增+dfs序+树状数组)

    首先可以求出从某点做$2^k$次车能到的最浅的点,这个只要dfs一下,把它的孩子能到的最浅的点更新过来就可以 然后倍增地往上跳,不能跳到lca的上面,记录坐车的次数ans 此时有三种情况(设最远能跳到 ...

  5. Learn Python The Hard Way, 2nd Edition

    看完了这本书,你决定继续做编程.也许它能成为你的一个职业,也许它能成为你的一项爱好.但你需要一些指导,确保自己不会走错了道路,或帮助你从这个新业余爱好中得到最大的乐趣. 我做了很久的编程.久的你都想象 ...

  6. VLC1.2 播放视频迟滞卡

    用libvlc 提供的示例,用1080p播放本事是720p的视频,会有卡住的现象. 后改用32位播放后正常.(R,G,B的掩码需要适当调换.我在ubuntu上编译两个项目,掩码值都需要调换,不知道为什 ...

  7. 快速幂&快速乘法

    尽管快速幂与快速乘法好像扯不上什么关系,但是东西不是很多,就一起整理到这里吧 快速幂思想就是将ax看作x个a相乘,用now记录当前答案,然后将指数每次除以2,然后将当前答案平方,如果x的2进制最后一位 ...

  8. 提高磁盘访问性能 - NtfsDisableLastAccessUpdate

    这个技巧可以提高磁盘访问性能,不过仅适用于NTFS文件系统. 我们知道,当在磁盘管理应用程序中列出目录结构时──效果类似“资源管理器”.“文件管理 器”(Windows NT  3.xx/4.0下的称 ...

  9. Adobe Premiere Pro CC ------ 快捷键

    ctrl + ~:全屏 Esc:退出全屏

  10. python类变量和实例变量的区别

    类变量:是为类服务的,类所有的实例都共享使用,在一个地方被改变,所有调用的地方变量值都改变.定义类时的写法为类名.变量名 实例变量:是在实例中生效的,每个实例变量的值都根据实例本身需求进行修改,不会影 ...