devbox
一键难忘520
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Springboot整合activemq（二）：收发具有优先级的队列方法_springboot activemq-优先级队列

作者：一键难忘520 | 2024-06-27 17:58:04

赞

踩

springboot activemq-优先级队列

在使用mq作为中间件做异步消息推送时，可能会遇到一个场景，就是消息在消费后执行一系列的逻辑到一半，突然遇到异常或者是断电等之类问题，这时消息在mq的队列中已经出队列，而正常逻辑没有执行完就异常终止，这样就可能会造成数据的缺失和数据的不完整，如何解决这个问题？其实挺简单的，就是在消息进入消费者消费的同时做一个记录，再在逻辑执行完成后再删除这条记录或者是改变这条记录的状态，同时，在项目初始化时或者是执行一个定时任务扫描这个记录表，如果存在则产生一条相同的记录发送到activemq中（相同的队列）。这样就能解决这个问题。然而，今天在开发中我又思考到一个问题，如图：

假设消息1没有消费完成，则消息1要重新进入队列，此时有一条消息4跟消息1操作的是同一条数据，如果消息1再进入队列，则4会在1之前消费掉，此时数据就会发生错乱，如果要保证消息1在消息4之前消费，则就需要对重新入队列的消息1进行一些操作来使得消息1优先消费。

activemq是提供对队列设置为具有优先级消息属性的功能，那么下面就要来实现具有优先级属性的消息队列：

第一步，进入activemq的conf文件夹下，修改activemq.xml配置文件，在<policyEntries>标签下插入一个配置：

<policyEntry queue="queue1" strictOrderDispatch="true" useCache="false" queuePrefetch="1" prioritizedMessages="true" />

完成后保存，并重启mq服务。这条配置就配置了对于queue1这个队列内的消息是具有优先级的属性的。

第二步，整合一个springboot+activemq的demo项目用于测试。

第三步，就是具体的代码实现了，首先我们来关注下springboot整合activemq的源码：

1.JmsMessagingTemplate这个类是实现发送消息的主要类，正常我们只需要在producer中注入这个类，调用其中发送消息的方法就能够实现消息的发送。具体代码如下：

  1. import org.springframework.beans.factory.annotation.Autowired;
  2. import org.springframework.jms.core.JmsMessagingTemplate;
  3. import org.springframework.stereotype.Service;
  4.  
  5. import javax.jms.Destination;
  6.  
  7. @Service
  8. public class TestProducer {
  9.  
  10.     @Autowired
  11.     private JmsMessagingTemplate jmsMessagingTemplate;
  12.  
  13.     public void sendMsg(Destination destination, String text){
  14.         jmsMessagingTemplate.convertAndSend(destination,text);
  15.     }
  16.  
  17. }

但是，此消息是不具有优先级的，接着往下看源码。

           2.在JmsMessagingTemplate类中实际上是封装了一个JmsTemplate这个类，实际上这个类才是真正实现消息发送的类，它只是将它进一步封装而已。

  1. package org.springframework.jms.core;
  2.  
  3. import java.util.Map;
  4. import javax.jms.ConnectionFactory;
  5. import javax.jms.Destination;
  6. import javax.jms.JMSException;
  7. import javax.jms.Session;
  8. import org.springframework.beans.factory.InitializingBean;
  9. import org.springframework.jms.InvalidDestinationException;
  10. import org.springframework.jms.JmsException;
  11. import org.springframework.jms.support.converter.MessageConverter;
  12. import org.springframework.jms.support.converter.MessagingMessageConverter;
  13. import org.springframework.jms.support.destination.DestinationResolutionException;
  14. import org.springframework.lang.Nullable;
  15. import org.springframework.messaging.Message;
  16. import org.springframework.messaging.MessagingException;
  17. import org.springframework.messaging.converter.MessageConversionException;
  18. import org.springframework.messaging.core.AbstractMessagingTemplate;
  19. import org.springframework.messaging.core.MessagePostProcessor;
  20. import org.springframework.util.Assert;
  21.  
  22. public class JmsMessagingTemplate extends AbstractMessagingTemplate<Destination> implements JmsMessageOperations, InitializingBean {
  23.     @Nullable
  24.     private JmsTemplate jmsTemplate;
  25.     private MessageConverter jmsMessageConverter = new MessagingMessageConverter();
  26.     private boolean converterSet;
  27.     @Nullable
  28.     private String defaultDestinationName;
  29.  
  30.     public JmsMessagingTemplate() {
  31.     }
  32.  
  33.     public JmsMessagingTemplate(ConnectionFactory connectionFactory) {
  34.         this.jmsTemplate = new JmsTemplate(connectionFactory);
  35.     }
  36.  
  37.     public JmsMessagingTemplate(JmsTemplate jmsTemplate) {
  38.         Assert.notNull(jmsTemplate, "JmsTemplate must not be null");
  39.         this.jmsTemplate = jmsTemplate;
  40.     }
  41.  
  42.     public void setConnectionFactory(ConnectionFactory connectionFactory) {
  43.         if (this.jmsTemplate != null) {
  44.             this.jmsTemplate.setConnectionFactory(connectionFactory);
  45.         } else {
  46.             this.jmsTemplate = new JmsTemplate(connectionFactory);
  47.         }
  48.  
  49.     }
  50.  
  51.     @Nullable
  52.     public ConnectionFactory getConnectionFactory() {
  53.         return this.jmsTemplate != null ? this.jmsTemplate.getConnectionFactory() : null;
  54.     }
  55.  
  56.     public void setJmsTemplate(@Nullable JmsTemplate jmsTemplate) {
  57.         this.jmsTemplate = jmsTemplate;
  58.     }
  59.  
  60.     @Nullable
  61.     public JmsTemplate getJmsTemplate() {
  62.         return this.jmsTemplate;
  63.     }
  64.  
  65.     public void setJmsMessageConverter(MessageConverter jmsMessageConverter) {
  66.         Assert.notNull(jmsMessageConverter, "MessageConverter must not be null");
  67.         this.jmsMessageConverter = jmsMessageConverter;
  68.         this.converterSet = true;
  69.     }
  70.  
  71.     public MessageConverter getJmsMessageConverter() {
  72.         return this.jmsMessageConverter;
  73.     }
  74.  
  75.     public void setDefaultDestinationName(@Nullable String defaultDestinationName) {
  76.         this.defaultDestinationName = defaultDestinationName;
  77.     }
  78.  
  79.     @Nullable
  80.     public String getDefaultDestinationName() {
  81.         return this.defaultDestinationName;
  82.     }
  83.  
  84.     public void afterPropertiesSet() {
  85.         Assert.notNull(this.jmsTemplate, "Property 'connectionFactory' or 'jmsTemplate' is required");
  86.         if (!this.converterSet && this.jmsTemplate.getMessageConverter() != null) {
  87.             ((MessagingMessageConverter)this.jmsMessageConverter).setPayloadConverter(this.jmsTemplate.getMessageConverter());
  88.         }
  89.  
  90.     }
  91.  
  92.     private JmsTemplate obtainJmsTemplate() {
  93.         Assert.state(this.jmsTemplate != null, "No JmsTemplate set");
  94.         return this.jmsTemplate;
  95.     }
  96.  
  97.     public void send(Message<?> message) {
  98.         Destination defaultDestination = (Destination)this.getDefaultDestination();
  99.         if (defaultDestination != null) {
  100.             this.send(defaultDestination, message);
  101.         } else {
  102.             this.send(this.getRequiredDefaultDestinationName(), message);
  103.         }
  104.  
  105.     }
  106.  
  107.     public void convertAndSend(Object payload) throws MessagingException {
  108.         this.convertAndSend((Object)payload, (MessagePostProcessor)null);
  109.     }
  110.  
  111.     public void convertAndSend(Object payload, @Nullable MessagePostProcessor postProcessor) throws MessagingException {
  112.         Destination defaultDestination = (Destination)this.getDefaultDestination();
  113.         if (defaultDestination != null) {
  114.             this.convertAndSend((Object)defaultDestination, payload, (MessagePostProcessor)postProcessor);
  115.         } else {
  116.             this.convertAndSend(this.getRequiredDefaultDestinationName(), payload, postProcessor);
  117.         }
  118.  
  119.     }
  120.  
  121.     public void send(String destinationName, Message<?> message) throws MessagingException {
  122.         this.doSend(destinationName, message);
  123.     }
  124.  
  125.     public void convertAndSend(String destinationName, Object payload) throws MessagingException {
  126.         this.convertAndSend(destinationName, payload, (Map)null);
  127.     }
  128.  
  129.     public void convertAndSend(String destinationName, Object payload, @Nullable Map<String, Object> headers) throws MessagingException {
  130.         this.convertAndSend(destinationName, payload, headers, (MessagePostProcessor)null);
  131.     }
  132.  
  133.     public void convertAndSend(String destinationName, Object payload, @Nullable MessagePostProcessor postProcessor) throws MessagingException {
  134.         this.convertAndSend(destinationName, payload, (Map)null, postProcessor);
  135.     }
  136.  
  137.     public void convertAndSend(String destinationName, Object payload, @Nullable Map<String, Object> headers, @Nullable MessagePostProcessor postProcessor) throws MessagingException {
  138.         Message<?> message = this.doConvert(payload, headers, postProcessor);
  139.         this.send(destinationName, message);
  140.     }
  141.  
  142.     @Nullable
  143.     public Message<?> receive() {
  144.         Destination defaultDestination = (Destination)this.getDefaultDestination();
  145.         return defaultDestination != null ? this.receive(defaultDestination) : this.receive(this.getRequiredDefaultDestinationName());
  146.     }
  147.  
  148.     @Nullable
  149.     public <T> T receiveAndConvert(Class<T> targetClass) {
  150.         Destination defaultDestination = (Destination)this.getDefaultDestination();
  151.         return defaultDestination != null ? this.receiveAndConvert(defaultDestination, targetClass) : this.receiveAndConvert(this.getRequiredDefaultDestinationName(), targetClass);
  152.     }
  153.  
  154.     @Nullable
  155.     public Message<?> receive(String destinationName) throws MessagingException {
  156.         return this.doReceive(destinationName);
  157.     }
  158.  
  159.     @Nullable
  160.     public <T> T receiveAndConvert(String destinationName, Class<T> targetClass) throws MessagingException {
  161.         Message<?> message = this.doReceive(destinationName);
  162.         return message != null ? this.doConvert(message, targetClass) : null;
  163.     }
  164.  
  165.     @Nullable
  166.     public Message<?> sendAndReceive(Message<?> requestMessage) {
  167.         Destination defaultDestination = (Destination)this.getDefaultDestination();
  168.         return defaultDestination != null ? this.sendAndReceive(defaultDestination, requestMessage) : this.sendAndReceive(this.getRequiredDefaultDestinationName(), requestMessage);
  169.     }
  170.  
  171.     @Nullable
  172.     public Message<?> sendAndReceive(String destinationName, Message<?> requestMessage) throws MessagingException {
  173.         return this.doSendAndReceive(destinationName, requestMessage);
  174.     }
  175.  
  176.     @Nullable
  177.     public <T> T convertSendAndReceive(String destinationName, Object request, Class<T> targetClass) throws MessagingException {
  178.         return this.convertSendAndReceive(destinationName, request, (Map)null, (Class)targetClass);
  179.     }
  180.  
  181.     @Nullable
  182.     public <T> T convertSendAndReceive(Object request, Class<T> targetClass) {
  183.         return this.convertSendAndReceive((Object)request, (Class)targetClass, (MessagePostProcessor)null);
  184.     }
  185.  
  186.     @Nullable
  187.     public <T> T convertSendAndReceive(String destinationName, Object request, @Nullable Map<String, Object> headers, Class<T> targetClass) throws MessagingException {
  188.         return this.convertSendAndReceive(destinationName, request, headers, targetClass, (MessagePostProcessor)null);
  189.     }
  190.  
  191.     @Nullable
  192.     public <T> T convertSendAndReceive(Object request, Class<T> targetClass, @Nullable MessagePostProcessor postProcessor) {
  193.         Destination defaultDestination = (Destination)this.getDefaultDestination();
  194.         return defaultDestination != null ? this.convertSendAndReceive((Object)defaultDestination, request, (Class)targetClass, (MessagePostProcessor)postProcessor) : this.convertSendAndReceive(this.getRequiredDefaultDestinationName(), request, targetClass, postProcessor);
  195.     }
  196.  
  197.     @Nullable
  198.     public <T> T convertSendAndReceive(String destinationName, Object request, Class<T> targetClass, @Nullable MessagePostProcessor requestPostProcessor) throws MessagingException {
  199.         return this.convertSendAndReceive(destinationName, request, (Map)null, targetClass, requestPostProcessor);
  200.     }
  201.  
  202.     @Nullable
  203.     public <T> T convertSendAndReceive(String destinationName, Object request, @Nullable Map<String, Object> headers, Class<T> targetClass, @Nullable MessagePostProcessor postProcessor) {
  204.         Message<?> requestMessage = this.doConvert(request, headers, postProcessor);
  205.         Message<?> replyMessage = this.sendAndReceive(destinationName, requestMessage);
  206.         return replyMessage != null ? this.getMessageConverter().fromMessage(replyMessage, targetClass) : null;
  207.     }
  208.  
  209.     protected void doSend(Destination destination, Message<?> message) {
  210.         try {
  211.             this.obtainJmsTemplate().send(destination, this.createMessageCreator(message));
  212.         } catch (JmsException var4) {
  213.             throw this.convertJmsException(var4);
  214.         }
  215.     }
  216.  
  217.     protected void doSend(String destinationName, Message<?> message) {
  218.         try {
  219.             this.obtainJmsTemplate().send(destinationName, this.createMessageCreator(message));
  220.         } catch (JmsException var4) {
  221.             throw this.convertJmsException(var4);
  222.         }
  223.     }
  224.  
  225.     @Nullable
  226.     protected Message<?> doReceive(Destination destination) {
  227.         try {
  228.             javax.jms.Message jmsMessage = this.obtainJmsTemplate().receive(destination);
  229.             return this.convertJmsMessage(jmsMessage);
  230.         } catch (JmsException var3) {
  231.             throw this.convertJmsException(var3);
  232.         }
  233.     }
  234.  
  235.     @Nullable
  236.     protected Message<?> doReceive(String destinationName) {
  237.         try {
  238.             javax.jms.Message jmsMessage = this.obtainJmsTemplate().receive(destinationName);
  239.             return this.convertJmsMessage(jmsMessage);
  240.         } catch (JmsException var3) {
  241.             throw this.convertJmsException(var3);
  242.         }
  243.     }
  244.  
  245.     @Nullable
  246.     protected Message<?> doSendAndReceive(Destination destination, Message<?> requestMessage) {
  247.         try {
  248.             javax.jms.Message jmsMessage = this.obtainJmsTemplate().sendAndReceive(destination, this.createMessageCreator(requestMessage));
  249.             return this.convertJmsMessage(jmsMessage);
  250.         } catch (JmsException var4) {
  251.             throw this.convertJmsException(var4);
  252.         }
  253.     }
  254.  
  255.     @Nullable
  256.     protected Message<?> doSendAndReceive(String destinationName, Message<?> requestMessage) {
  257.         try {
  258.             javax.jms.Message jmsMessage = this.obtainJmsTemplate().sendAndReceive(destinationName, this.createMessageCreator(requestMessage));
  259.             return this.convertJmsMessage(jmsMessage);
  260.         } catch (JmsException var4) {
  261.             throw this.convertJmsException(var4);
  262.         }
  263.     }
  264.  
  265.     private JmsMessagingTemplate.MessagingMessageCreator createMessageCreator(Message<?> message) {
  266.         return new JmsMessagingTemplate.MessagingMessageCreator(message, this.getJmsMessageConverter());
  267.     }
  268.  
  269.     protected String getRequiredDefaultDestinationName() {
  270.         String name = this.getDefaultDestinationName();
  271.         if (name == null) {
  272.             throw new IllegalStateException("No 'defaultDestination' or 'defaultDestinationName' specified. Check configuration of JmsMessagingTemplate.");
  273.         } else {
  274.             return name;
  275.         }
  276.     }
  277.  
  278.     @Nullable
  279.     protected Message<?> convertJmsMessage(@Nullable javax.jms.Message message) {
  280.         if (message == null) {
  281.             return null;
  282.         } else {
  283.             try {
  284.                 return (Message)this.getJmsMessageConverter().fromMessage(message);
  285.             } catch (Exception var3) {
  286.                 throw new MessageConversionException("Could not convert '" + message + "'", var3);
  287.             }
  288.         }
  289.     }
  290.  
  291.     protected MessagingException convertJmsException(JmsException ex) {
  292.         if (!(ex instanceof DestinationResolutionException) && !(ex instanceof InvalidDestinationException)) {
  293.             return (MessagingException)(ex instanceof org.springframework.jms.support.converter.MessageConversionException ? new MessageConversionException(ex.getMessage(), ex) : new MessagingException(ex.getMessage(), ex));
  294.         } else {
  295.             return new org.springframework.messaging.core.DestinationResolutionException(ex.getMessage(), ex);
  296.         }
  297.     }
  298.  
  299.     private static class MessagingMessageCreator implements MessageCreator {
  300.         private final Message<?> message;
  301.         private final MessageConverter messageConverter;
  302.  
  303.         public MessagingMessageCreator(Message<?> message, MessageConverter messageConverter) {
  304.             this.message = message;
  305.             this.messageConverter = messageConverter;
  306.         }
  307.  
  308.         public javax.jms.Message createMessage(Session session) throws JMSException {
  309.             try {
  310.                 return this.messageConverter.toMessage(this.message, session);
  311.             } catch (Exception var3) {
  312.                 throw new MessageConversionException("Could not convert '" + this.message + "'", var3);
  313.             }
  314.         }
  315.     }
  316. }

我们可以跟踪方法的执行，进入到JmsTemplate这个类中，发现里面336行封装着一个方法。

  1. protected void doSend(MessageProducer producer, Message message) throws JMSException {
  2.         if (this.deliveryDelay >= 0L) {
  3.             producer.setDeliveryDelay(this.deliveryDelay);
  4.         }
  5.  
  6.         if (this.isExplicitQosEnabled()) {
  7.             producer.send(message, this.getDeliveryMode(), this.getPriority(), this.getTimeToLive());
  8.         } else {
  9.             producer.send(message);
  10.         }
  11.  
  12.     }

这里就可以看到producer这个对象调用的send方法中有设置几个参数：

(1)、message不用说了，就是要发送的消息内容；

(2)、Delivery Mode翻译过来就是发送模式发送模式；

(3)、priority！这就是我们要找的优先级，传入0-9整数，数字越大优先级越高；

(4)、timeToLive延时发送时间；

Ok，到这里我们就可以看到，如果要执行这个方法就只需要isExplicitQosEnabled()这个方法返回值为true。

再看代码的第175行的方法：

  1. public void setQosSettings(QosSettings settings) {
  2.         Assert.notNull(settings, "Settings must not be null");
  3.         this.setExplicitQosEnabled(true);
  4.         this.setDeliveryMode(settings.getDeliveryMode());
  5.         this.setPriority(settings.getPriority());
  6.         this.setTimeToLive(settings.getTimeToLive());
  7.     }

这个方法就是设置上面几个参数的设置，只需传入QosSettings这个对象就行。

来看JmsTemplate这个类的构造方法：

  1. public JmsTemplate() {
  2.         this.transactionalResourceFactory = new JmsTemplate.JmsTemplateResourceFactory();
  3.         this.messageIdEnabled = true;
  4.         this.messageTimestampEnabled = true;
  5.         this.pubSubNoLocal = false;
  6.         this.receiveTimeout = 0L;
  7.         this.deliveryDelay = -1L;
  8.         this.explicitQosEnabled = false;
  9.         this.deliveryMode = 2;
  10.         this.priority = 4;
  11.         this.timeToLive = 0L;
  12.         this.initDefaultStrategies();
  13.     }

可以看到几个参数的默认值，也就是没有执行任何操作时如果将explicitQosEnabled设置为true则该消息发送出去优先级默认为4。

          3.所以我们将生产者代码进行修改：

  1. import org.springframework.beans.factory.annotation.Autowired;
  2. import org.springframework.jms.core.JmsMessagingTemplate;
  3. import org.springframework.jms.core.JmsTemplate;
  4. import org.springframework.jms.support.QosSettings;
  5. import org.springframework.stereotype.Service;
  6.  
  7. import javax.jms.DeliveryMode;
  8. import javax.jms.Destination;
  9.  
  10. @Service
  11. public class TestProducer {
  12.  
  13.     @Autowired
  14.     private JmsMessagingTemplate jmsMessagingTemplate;
  15.  
  16.     public void sendMsg(Destination destination, String text, int priority){
  17.         //获取jmsTemplate对象
  18.         JmsTemplate jmsTemplate = jmsMessagingTemplate.getJmsTemplate();
  19.         //创建QosSettings对象
  20.         QosSettings settings = new QosSettings();
  21.         //设置优先级
  22.         settings.setPriority(priority);
  23.         //设置发送模式
  24.         settings.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
  25.         //设置延时发送时间
  26.         settings.setTimeToLive(1000L);
  27.         //将设置传入
  28.         jmsTemplate.setQosSettings(settings);
  29.         //发送消息
  30.         jmsMessagingTemplate.convertAndSend(destination,text);
  31.     }
  32.  
  33. }

这样生产者就写完了。

           4.测试

           首先，先写一个消费者，监听队列queue1：

  1. import org.springframework.jms.annotation.JmsListener;
  2. import org.springframework.stereotype.Component;
  3.  
  4. @Component
  5. public class TestConsumer {
  6.  
  7.     @JmsListener(destination = "queue1")
  8.     public void receiveTest(String text){
  9.         System.out.println("接收到queue1发送的消息："+text);
  10.     }
  11. }

再写一个controller类可以通过前端调用发送消息的方法：

  1. import com.example.springboot.mq.demo.producer.TestProducer;
  2. import org.apache.activemq.command.ActiveMQQueue;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.RestController;
  6.  
  7. import javax.jms.Destination;
  8. import java.util.Random;
  9.  
  10. @RestController
  11. public class TestController {
  12.  
  13.     @Autowired
  14.     private TestProducer producer;
  15.  
  16.     @RequestMapping("/test")
  17.     public String test(){
  18.         Destination destination = new ActiveMQQueue("queue1");
  19.         Random random = new Random(10);
  20.         for (int i=0;i < 100;i++){
  21.             //随机产生优先级数字
  22.             int priority = random.nextInt(9);
  23.             producer.sendMsg(destination,"消息No."+i+"优先级为:"+priority,priority);
  24.         }
  25.         return "发送成功";
  26.     }
  27. }

然后启动项目进行测试，测试结果：

  1. 发送消息优先级为：0
  2. 发送消息优先级为：6
  3. 发送消息优先级为：6
  4. 发送消息优先级为：0
  5. 发送消息优先级为：4
  6. 发送消息优先级为：1
  7. 发送消息优先级为：1
  8. 发送消息优先级为：4
  9. 发送消息优先级为：3
  10. 发送消息优先级为：1
  11. 发送消息优先级为：1
  12. 发送消息优先级为：2
  13. 发送消息优先级为：6
  14. 发送消息优先级为：6
  15. 发送消息优先级为：3
  16. 发送消息优先级为：3
  17. 发送消息优先级为：1
  18. 发送消息优先级为：1
  19. 发送消息优先级为：4
  20. 发送消息优先级为：7
  21. 发送消息优先级为：8
  22. 发送消息优先级为：7
  23. 发送消息优先级为：6
  24. 发送消息优先级为：8
  25. 发送消息优先级为：5
  26. 发送消息优先级为：1
  27. 发送消息优先级为：5
  28. 发送消息优先级为：5
  29. 发送消息优先级为：8
  30. 发送消息优先级为：8
  31. 发送消息优先级为：2
  32. 发送消息优先级为：8
  33. 发送消息优先级为：6
  34. 发送消息优先级为：8
  35. 发送消息优先级为：7
  36. 发送消息优先级为：1
  37. 发送消息优先级为：7
  38. 发送消息优先级为：1
  39. 发送消息优先级为：0
  40. 发送消息优先级为：4
  41. 发送消息优先级为：8
  42. 发送消息优先级为：1
  43. 发送消息优先级为：8
  44. 发送消息优先级为：0
  45. 发送消息优先级为：7
  46. 发送消息优先级为：5
  47. 发送消息优先级为：6
  48. 发送消息优先级为：0
  49. 发送消息优先级为：2
  50. 发送消息优先级为：4

接收到的消息：

  1. 消息内容：1优先级为：6
  2. 消息内容：20优先级为：8
  3. 消息内容：23优先级为：8
  4. 消息内容：28优先级为：8
  5. 消息内容：29优先级为：8
  6. 消息内容：31优先级为：8
  7. 消息内容：33优先级为：8
  8. 消息内容：40优先级为：8
  9. 消息内容：42优先级为：8
  10. 消息内容：19优先级为：7
  11. 消息内容：21优先级为：7
  12. 消息内容：34优先级为：7
  13. 消息内容：36优先级为：7
  14. 消息内容：44优先级为：7
  15. 消息内容：2优先级为：6
  16. 消息内容：12优先级为：6
  17. 消息内容：13优先级为：6
  18. 消息内容：22优先级为：6
  19. 消息内容：32优先级为：6
  20. 消息内容：46优先级为：6
  21. 消息内容：24优先级为：5
  22. 消息内容：26优先级为：5
  23. 消息内容：27优先级为：5
  24. 消息内容：45优先级为：5
  25. 消息内容：4优先级为：4
  26. 消息内容：7优先级为：4
  27. 消息内容：18优先级为：4
  28. 消息内容：39优先级为：4
  29. 消息内容：49优先级为：4
  30. 消息内容：8优先级为：3
  31. 消息内容：14优先级为：3
  32. 消息内容：15优先级为：3
  33. 消息内容：11优先级为：2
  34. 消息内容：30优先级为：2
  35. 消息内容：48优先级为：2
  36. 消息内容：5优先级为：1
  37. 消息内容：6优先级为：1
  38. 消息内容：9优先级为：1
  39. 消息内容：10优先级为：1
  40. 消息内容：16优先级为：1
  41. 消息内容：17优先级为：1
  42. 消息内容：25优先级为：1
  43. 消息内容：35优先级为：1
  44. 消息内容：37优先级为：1
  45. 消息内容：41优先级为：1
  46. 消息内容：0优先级为：0
  47. 消息内容：3优先级为：0
  48. 消息内容：38优先级为：0
  49. 消息内容：43优先级为：0
  50. 消息内容：47优先级为：0

结果显示，除第一条外，其他消息的接收全部是按消息的优先级出队列。所以大功告成，至于第一个消息为什么没有按优先级出队列后续我再研究一下。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/一键难忘520/article/detail/763282
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号