RabbitMQ - tutorial 2：task queue,distributing tasks among workers

最新推荐文章于 2020-01-20 22:43:09 发布

原创最新推荐文章于 2020-01-20 22:43:09 发布 · 305 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#rabbit mq #message queue

本文介绍RabbitMQ中如何通过消息确认、消息持久性和基本QoS设置来保证消息不丢失，并实现工作负载的均衡分配。

本例说明RabbitMQ提高的处理以下3个问题的机制，并给出一个例子。

consumer奔溃，如何保证消息不丢失（比如消息处理到一半，异常退出）- message acknowledgment
RabbitMQ Server挂掉，如何保证消息以及消息队列不丢失 - message durability
消息处理任务繁重程度差异很大时，如何保证每个consumer均衡的承担任务而不会导致有的过重有的又很空闲 - basicQos设置

Task Queue

Work Queue(Task Queue)主要思想是避免立即执行资源密集型任务，且等待其完成。相反，我们将任务封装为消息并将其发送到队列。然后由后台worker从消息队列取出执行。

Task Queue的优点之一就是可以并行运行；如果有很多的积压Task，只要增加worker(Consumer)就可以并行处理，从而加快处理进度。而RabbitMQ将按顺序将消息发送给下一个使用者(Consumer)，就平均而言，每个Consumer将获得相同数量的消息。这种分配消息的方式称为循环法(round-robin)。

消息确认（Message acknowledgment）

运行任务需要一定的时间，但如果执行了一部分consumer就挂掉了，会发生什么呢？RabbitMQ支持Message acknowledgment.消息确认由consumer告诉给RabbitMQ，某个特定的消息被接收，处理了，这样RabbitMQ可以删除这个消息了。

如果一个consumer挂掉(channel关闭，或者connection关闭，或者TCP connection丢失)，但没有发ack(消息确认)，RabbitMQ就会知道该消息没有被完整的处理，它就会将该消息重新入队列。如果这时有其它的consumer在线，RabbitMQ就会把消息redeliver给这个consumer。这样，即使consumer挂掉，RabbitMQ也能保证消息不会丢失。

默认情况下手动处理消息确认（Manual message acknowledgments）开启，可以通过autoAck=true关闭。开启手动处理之后，consumer在完成task后需要手动发送acknowledgment给RabbitMQ。

消息持久性(Message durability)

通过ack，能确保consumber挂掉，也不会导致消息丢失；那么如果RabbitMQ server挂掉呢？当RabbitMQ退出或崩溃时，它会忘记队列和消息，除非我们告诉它不要：这需要将队列和消息标记为持久（durable）。

(1)Producer和Consumer双方都需要指定durable=true. 这样就能确保”task_queue”队列即使重启RabbitMQ也不会丢失。

boolean durable = true;
channel.queueDeclare("task_queue", durable, false, false, null);

(2)MessageProperties.PERSISTENT_TEXT_PLAIN

通过MessageProperties设置为MessageProperties.PERSISTENT_TEXT_PLAIN来使消息变为持久。

channel.basicPublish("", "task_queue",
            MessageProperties.PERSISTENT_TEXT_PLAIN,
            message.getBytes());

(3)消息持久化的说明（Note on message persistence）

Marking messages as persistent doesn’t fully guarantee that a message won’t be lost. Although it tells RabbitMQ to save the message to disk, there is still a short time window when RabbitMQ has accepted a message and hasn’t saved it yet. Also, RabbitMQ doesn’t do fsync(2) for every message – it may be just saved to cache and not really written to the disk. The persistence guarantees aren’t strong, but it’s more than enough for our simple task queue. If you need a stronger guarantee then you can use publisher confirms.

公平分派（Fair dispatch）

RabbitMQ按顺序将消息公平的分派给多个consumer，而不管各个consumer是否很忙。举个例子，比如第奇数个task(message)都很耗时，而偶数个task都很轻松；现在有两个consumer，那么第一个consumer总是被分派奇数个task，所以很忙；而第二个consumber总是被分派偶数个task，很轻松。

要解决这种情况，RabbitMQ提供了如下channel.basicQos设置。告诉RabbitMQ不要给consumer分派超过1个的task(message)，也就是只有在consumer处理完一个task并返回确认(ack)之后，才会再分派新的task给该consumer。

int prefetchCount = 1;
channel.basicQos(prefetchCount);

如果所有的consumer都很忙，那么消息队列就可能被填满，这时你就需要采取措施，比如增加新的consumer。

Tutorial 2 - task queue（Distributing tasks among workers）

本例一个消息只发送给一个consumer，以后还会介绍一个消息发送给多个consumer的case。

新建maven project，一个parent，两个child project，结构如下图：
这里写图片描述

Publisher

使用一个线程，每隔3s发送一条随机生成的message给RabbitMQ服务器。

MyTask.java - 线程实现

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;

import java.util.Random;

public class MyTask implements Runnable {
    //message index,用来查看多个consumer同时从broker取消息时，消息是怎么被分派的
    private static Integer index = 0;

    //define name of the queue
    private static final String TASK_QUEUE_NAME = "task_queue";
    //connection to the server(broker)
    private Connection rbtMqConn;
    //channel
    private Channel rbtMqChnl;

    //控制停止线程
    private boolean isStop = false;
    public void setIsStop(boolean stop){
        this.isStop = stop;
    }

    @Override
    public void run() {

        try{
            //1.创建一个connection链接到RabbitMQ服务器（connection为我们处理socket/协议/认证授权等）
            ConnectionFactory factory = new ConnectionFactory();
            //本例使用本机作为服务器；Consumer也从这个broker接收消息，也可以使用其它主机，比如172.16.21.111
            factory.setHost("localhost");
            rbtMqConn = factory.newConnection();

            //2.创建一个channel
            rbtMqChnl = rbtMqConn.createChannel();

            //3.声明消息队列，并标记为持久;
            //3.1.producer和consumer需要指定相同的队列名；
            //3.2.producer和consumer都需要声明队列为durable=true，
            //来确保消息队列不会丢失(即使重启RabbitMQ也不会丢失)；
            boolean durable = true;
            rbtMqChnl.queueDeclare(TASK_QUEUE_NAME, durable, false, false, null);

            //send message per 3s
            while (!isStop){
                //message to send
                String message = getMessage(index++);
                //4.消息标记为持久，并发布消息：
                //MessageProperties.PERSISTENT_TEXT_PLAIN将消息标记为持久，
                //来确保即使重启RabbitMQ消息也不会丢失
                rbtMqChnl.basicPublish("", TASK_QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
                System.out.println(" [Publisher] Sent '" + message + "'");
                Thread.sleep(3000);
            }

            //5.最后，使用完之后，关闭channel和connection;
            rbtMqChnl.close();
            rbtMqConn.close();
        }catch(Exception ex){
            System.out.println(ex.getMessage());
        }

        System.out.println(" [Publisher] Send task stop");
    }

    /**
     * 生成随机消息用于发送给RabbitMQ服务器
     * */
    private static String getMessage(Integer index) {
        StringBuilder dotMsg = new StringBuilder("");
        dotMsg.append(String.format("[%d]", index));

        Random rand = new Random();
        Integer num = rand.nextInt(5) + 1;//[1, 5]
        for(Integer i=1; i <= num; ++i){
            dotMsg.append(".").append(i.toString());
        }

        return dotMsg.toString();
    }

}

MyPublisher.java - 控制发送线程运行120s

public class MyPublisher {
    public static void main(String[] argv) throws Exception {
        MyTask sendTask = new MyTask();
        Thread thread = new Thread(sendTask);
        thread.start();
        //let the thread run 120 seconds
        Thread.sleep(120000);
        sendTask.setIsStop(true);
    }
}

Consumer

MyConsumer.java - 链接到RabbitMQ，指定使用于MyPublisher相同的消息队列，并设置负载均衡，设置手动返回ack。

import com.rabbitmq.client.*;
import java.io.IOException;
import java.lang.management.ManagementFactory;


public class MyConsumer {
    private static final String TASK_QUEUE_NAME = "task_queue";

    public static void main(String[] argv) throws Exception {
        //1.创建connection链接到RabbitMQ Server
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");//使用本机的RabbitMQ Server
        final Connection connection = factory.newConnection();
        //2.创建channel
        final Channel channel = connection.createChannel();
        //3.声明消息队列，并标记为持久;
        //3.1.producer和consumer需要指定相同的队列名
        //3.2.producer和consumer都需要声明队列为durable=true，
        //来确保消息队列不会丢失(即使重启RabbitMQ也不会丢失)
        boolean durable = true;
        channel.queueDeclare(TASK_QUEUE_NAME, durable, false, false, null);

        //4.设置basicQos使consumer负载均衡：
        //一次只接收一个消息，consumer处理完一个消息，
        //并且RabbitMQ收到ack之后才会给该consumer分派新的task(message)
        channel.basicQos(1);

        //5.创建consumer，这里使用DefaultConsumer，
        //并且在一个task(message)处理完之后，手动给RabbitMQ返回消息确认(ack)
        final Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");

                long id = Thread.currentThread().getId();
                String runtimeName = ManagementFactory.getRuntimeMXBean().getName();
                String info = String.format("%s, %d, [Consumer] Received '%s'", runtimeName, id, message);
                System.out.println(info);
                try {
                    doWork(message);
                } finally {
                    System.out.println(" [Consumer] a task was Done");
                    //It's a common mistake to miss the basicAck.
                    // It's an easy error, but the consequences are serious.
                    // Messages will be redelivered when your client quits (which may look like random redelivery),
                    // but RabbitMQ will eat more and more memory as it won't be able to release any unacked messages.
                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
            }
        };
        //6.关闭自动消息确认，开启手动消息确认，并开始接收消息
        boolean autoAck = false;//见上面第5步，手动返回ack
        channel.basicConsume(TASK_QUEUE_NAME, autoAck, consumer);
    }

    private static void doWork(String task) {
        for (char ch : task.toCharArray()) {
            if (ch == '.') {
                try {
                    System.out.println(" [Consumer] sleep 1 second");
                    Thread.sleep(1000);//模拟消息处理
                } catch (InterruptedException _ignored) {
                    System.out.println(" [Consumer] exception happen");
                    Thread.currentThread().interrupt();
                }
            }
        }
    }
}