工作队列，又称任务队列，主要思想是避免立即执行资源密集型任务，并且必须等待完成。相反地，我们进行任务调度，我们将一个任务封装成一个消息，并将其发送到队列。工作进行在后台运行不断的从队列中取出任务然后执行。当你运行了多个工作进程时，这些任务队列中的任务将会被工作进程共享执行。
这个概念在 Web 应用程序中特别有用，在短时间 HTTP 请求内需要执行复杂的任务。
准备工作
现在，假装我们很忙，我们使用 Thread.sleep 来模拟耗时的任务。
发送端
public class NewTask {
private final static String QUEUE_NAME = "hello";
public static void main(String[] args) throws IOException, TimeoutException {
// 创建连接
ConnectionFactory factory = new ConnectionFactory();
// 设置 RabbitMQ 的主机名
factory.setHost("localhost");
// 创建一个连接
Connection connection = factory.newConnection();
// 创建一个通道
Channel channel = connection.createChannel();
// 指定一个队列
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
// 发送消息
for (int i = 0; i < 10; i++) {
String message = "Liang:" + i;
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.println(" [x] Sent ‘" + message + "‘");
}
// 关闭频道和连接
channel.close();
connection.close();
}
}
接收端
public class Worker {
private final static String QUEUE_NAME = "hello";
public static void main(String[] args) throws IOException, TimeoutException {
// 创建连接
ConnectionFactory factory = new ConnectionFactory();
// 设置 RabbitMQ 的主机名
factory.setHost("localhost");
// 创建一个连接
Connection connection = factory.newConnection();
// 创建一个通道
Channel channel = connection.createChannel();
// 指定一个队列
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
// 创建队列消费者
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");
System.out.println(" [x] Received ‘" + message + "‘");
try {
doWork(message);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
// acknowledgment is covered below
boolean autoAck = true;
channel.basicConsume(QUEUE_NAME, autoAck, consumer);
}
private static void doWork(String task) throws InterruptedException {
String[] taskArr = task.split(":");
TimeUnit.SECONDS.sleep(Long.valueOf(taskArr[1]));
}
}
轮询调度（Round-robin dispatching）
使用任务队列的优点之一是能够轻松地并行工作。如果我们积压了很多任务，我们可以增加更多的工作进程，这样可以轻松扩展。
首先，我们尝试在同一时间运行两个工作进程实例。他们都会从队列中获取消息，但是究竟如何？让我们来看看。
你需要三个控制台打开。两个将运行工作程序。这些控制台将是我们两个消费者 – C1 和 C2。
Worker1
[x] Received ‘Liang:0‘ [x] Received ‘Liang:2‘ [x] Received ‘Liang:4‘ [x] Received ‘Liang:6‘ [x] Received ‘Liang:8‘
Worker2
[x] Received ‘Liang-1‘ [x] Received ‘Liang-3‘ [x] Received ‘Liang-5‘ [x] Received ‘Liang-7‘ [x] Received ‘Liang-9‘
再做一个实验，我们开启三个工作程序。
Worker1
[x] Received ‘Liang-0‘ [x] Received ‘Liang-3‘ [x] Received ‘Liang-6‘ [x] Received ‘Liang-9‘
Worker2
[x] Received ‘Liang-1‘ [x] Received ‘Liang-4‘ [x] Received ‘Liang-7‘
Worker3
[x] Received ‘Liang-2‘ [x] Received ‘Liang-5‘ [x] Received ‘Liang-8‘
我们发现，通过增加更多的工作程序就可以进行并行工作，并且接受的消息平均分配。注意的是，这种分配过程是一次性分配，并非一个一个分配。
默认情况下，RabbitMQ 将会发送的每一条消息按照顺序给下一个消费者。平均每一个消费者将获得相同数量的消息。这种分发消息的方式叫做轮询调度。
消息应答（Message acknowledgment）
执行一个任务可能需要几秒钟。你可能会想，如果一个消费者开始一个长期的任务，并且只有部分地完成它，会发生什么事情？使用我们当前的代码，一旦 RabbitMQ 向客户发送消息，它立即将其从内存中删除。在这种情况下，如果你杀死正在执行任务的某个工作进程，我们会丢失它正在处理的信息。我们还会丢失所有发送给该特定工作进程但尚未处理的消息。
但是，我们不想失去任何消息。如果某个工作进程被杀死时，我们希望把这个任务交给另一个工作进程。
为了确保消息永远不会丢失，RabbitMQ 支持消息应答。从消费者发送一个确认信息告诉 RabbitMQ 已经收到消息并已经被接收和处理，然后RabbitMQ 可以自由删除它。
如果消费者被杀死而没有发送应答，RabbitMQ 会认为该信息没有被完全的处理，然后将会重新转发给别的消费者。如果同时有其他消费者在线，则会迅速将其重新提供给另一个消费者。这样就可以确保没有消息丢失，即使工作进程偶尔也会死亡。
默认情况下，消息应答是开启的。在前面的例子中，我们通过 autoAck = true 标志明确地将它们关闭。现在是一旦完成任务，将此标志设置为false ，并向工作进程发送正确的确认。
发送端
public class AckNewTask {
private final static String QUEUE_NAME = "hello";
public static void main(String[] args) throws IOException, TimeoutException {
// 创建连接
ConnectionFactory factory = new ConnectionFactory();
// 设置 RabbitMQ 的主机名
factory.setHost("localhost");
// 创建一个连接
Connection connection = factory.newConnection();
// 创建一个通道
Channel channel = connection.createChannel();
// 指定一个队列
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
// 发送消息
for (int i = 0; i < 10; i++) {
String message = "Liang:" + i;
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.println(" [x] Sent ‘" + message + "‘");
}
// 关闭频道和连接
channel.close();
connection.close();
}
}
接收端
public class AckWorker {
private final static String QUEUE_NAME = "hello";
public static void main(String[] args) throws IOException, TimeoutException {
// 创建连接
ConnectionFactory factory = new ConnectionFactory();
// 设置 RabbitMQ 的主机名
factory.setHost("localhost");
// 创建一个连接
Connection connection = factory.newConnection();
// 创建一个通道
final Channel channel = connection.createChannel();
// 指定一个队列
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
// 创建队列消费者
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");
System.out.println(" [x] Received ‘" + message + "‘");
try {
doWork(message);
} catch (InterruptedException e) {
e.printStackTrace();
} finally{
// 每次处理完成一个消息后，手动发送一次应答。
channel.basicAck(envelope.getDeliveryTag(), false);
}
}
};
boolean autoAck = false;
channel.basicConsume(QUEUE_NAME, autoAck, consumer);
}
private static void doWork(String task) throws InterruptedException {
String[] taskArr = task.split(":");
TimeUnit.SECONDS.sleep(Long.valueOf(taskArr[1]));
}
}]));
其中，首先关闭自动应答机制。
boolean ack = false ; channel.basicConsume(QUEUE_NAME, ack, consumer);
然后，每次处理完成一个消息后，手动发送一次应答。
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
此时，我们开启三个工作进程，然后，随机关闭一个工作进程，观察输出结果。
消息持久化（Message durability）
我们已经学会了如何确保即使消费者死了，任务也不会丢失。但是如果 RabbitMQ 服务器停止，我们的任务仍然会丢失。
当 RabbitMQ 退出或崩溃时，将会丢失所有的队列和信息，除非你告诉它不要丢失。需要两件事来确保消息不丢失：我们需要分别将队列和消息标记为持久化。
首先，我们需要确保 RabbitMQ 永远不会失去我们的队列。为了这样做，我们需要将其声明为持久化的。
boolean durable = true;
channel.queueDeclare("hello_dirable", durable, false, false, null);
其次，我们需要标识我们的信息为持久化的。通过设置 MessageProperties 值为 PERSISTENT_TEXT_PLAIN。
channel.basicPublish("", "hello_dirable", MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
注意的是，在RabbitMQ 中，已经存在的队列，我们无法修改其属性。
此时，我们开启一个发送者发送消息，然后，关闭 RabbitMQ 服务，再重新开启，观察输出结果。
公平转发（Fair dispatch）
您可能已经注意到，调度仍然无法正常工作。例如在两个工作线程的情况下，一个工作线程将不断忙碌，另一个工作人员几乎不会做任何工作。那么，RabbitMQ 不知道什么情况，还会平均分配消息。
这是因为当消息进入队列时，RabbitMQ 只会分派消息。它不看消费者的未确认消息的数量。它只是盲目地向第 n 个消费者发送每个第 n 个消息。
为了解决这样的问题，我们可以使用 basicQos 方法，并将传递参数为 prefetchCount = 1。
这样告诉 RabbitMQ 不要一次给一个工作线程多个消息。换句话说，在处理并确认前一个消息之前，不要向工作线程发送新消息。相反，它将发送到下一个还不忙的工作线程。
public class FairNewTask {
private final static String QUEUE_NAME = "hello";
public static void main(String[] args) throws IOException, TimeoutException {
// 创建连接
ConnectionFactory factory = new ConnectionFactory();
// 设置 RabbitMQ 的主机名
factory.setHost("localhost");
// 创建一个连接
Connection connection = factory.newConnection();
// 创建一个通道
Channel channel = connection.createChannel();
// 指定一个队列
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
// 公平转发
int prefetchCount = 1;
channel.basicQos(prefetchCount);
// 发送消息
for (int i = 10; i >0; i--) {
String message = "Liang:" + i;
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.println(" [x] Sent ‘" + message + "‘");
}
// 关闭频道和连接
channel.close();
connection.close();
}
}
其中，使用 basicQos 方法，并将传递参数为 prefetchCount = 1。
int prefetchCount = 1; channel.basicQos(prefetchCount) ;
源代码
原文地址：https://www.cnblogs.com/pokid/p/10519633.html