RabbitMQ学习==》消息队列

工作队列

​ 创建工作队列，用于多个工作人员之间分配耗时的任务

1、消息确认

为了确保消息永远不会丢失，RabbitMQ 支持 消息确认。消费者发回一个确认，告诉 RabbitMQ 一个特定的消息已经被接收、处理并且 RabbitMQ 可以自由地删除它。

如果消费者在没有发送 ack 的情况下死亡（其通道关闭、连接关闭或 TCP 连接丢失），RabbitMQ 将理解消息未完全处理并将重新排队。

默认情况下消息确认是打开的。

boolean autoAck = true;
channel.basicConsume("hello",autoAck, deliverCallback, consumerTag -> { });

当上面的变量autoAck为true时，会确认消费消息，不会有重复消费的消息，当为false时，会有重复消息

2、消息持久化

// 定义消息队列持久化
boolean durable = true;
channel.queueDeclare("hello", durable, false, false, null);
// 定义消息持久化
channel.basicPublish("", "task_queue",
            MessageProperties.PERSISTENT_TEXT_PLAIN,
            message.getBytes());

将消息标记为持久性并不能完全保证消息不会丢失。虽然它告诉 RabbitMQ 将消息保存到磁盘，但是当 RabbitMQ 接受消息并且还没有保存它时，仍然有很短的时间窗口。此外，RabbitMQ 不会对每条消息都执行fsync(2) ——它可能只是保存到缓存中而不是真正写入磁盘。持久性保证并不强，但对于我们简单的任务队列来说已经绰绰有余了。如果您需要更强的保证，那么您可以使用发布者确认。

3、任务调度公平化

​ 例如，在有两个工人的情况下，当所有奇数消息很重而偶数消息都很轻时，一个工人将一直很忙，另一个工人几乎不做任何工作。为了解决这个问题，可以将prefetchCount = 1,这样在工作人员未确认消息时，不会再向该工作人员发送消息。

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

如果所有工作人员都很忙，您的队列可能会被填满。你会想要关注这一点，可能会增加更多的工人，或者有一些其他的策略。

4、完整示例代码

产生任务：

private static final String TASK_QUEUE_NAME = "task_queue";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.6.128");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("admin");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 定义一个队列，第二个参数表示是一个持久化的队列
            channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);

            String message = String.join(" ", argv);
            // 发布消息，第二个参数表示持久化消息
            channel.basicPublish("", TASK_QUEUE_NAME,
                    MessageProperties.PERSISTENT_TEXT_PLAIN,
                    message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }

任务调度及工作者：

	private static final String TASK_QUEUE_NAME = "task_queue";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.6.128");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("admin");
        final Connection connection = factory.newConnection();
        final Channel channel = connection.createChannel();
        // 定义一个队列，第二个参数表示是一个持久化的队列
        channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        channel.basicQos(1);

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");

            System.out.println(" [x] Received '" + message + "'");
            try {
                doWork(message);
            } finally {
                System.out.println(" [x] Done");
                // 最终确认，不确认会消耗更多内存，从而导致内存无法释放
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
            }
        };
        channel.basicConsume(TASK_QUEUE_NAME, false, deliverCallback, consumerTag -> { });
    }

    private static void doWork(String task) {
        for (char ch : task.toCharArray()) {
            if (ch == '.') {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException _ignored) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }