9824247-01481244ec2d6199.jpg
在上篇中我们实现了程序来从一个已经命名的队列里发送和接收消息。本篇博文中我们将要创建工作队列用来把一些比较耗时的任务分配给多个worker。
工作队列的主要思想就是避开立刻处理某个资源消耗交大的任务并且需要等待它执行完成。取而代之的是我们可以将它加入计划列表，并在后边执行这些任务。我们将任务分装成一个消息，并发送到队列中。后台的工作程序在接收到消息后将会立刻执行任务。当运行多个执行器时，任务将会在他们之间共享。
为什么会出现work queues?
前提:使用simple队列的时候 我们应用程序在是使用消息系统的时候,一般生产者P生产消息是毫不费力的(发送消息即可),而消费者接收完消息后的需要处理,会耗费一定的时间,这时候,就有可能导致很多消息堆积在队列里面,一个消费者有可能不够用 那么怎么让消费者同事处理多个消息呢? 在同一个队列上创建多个消费者,让他们相互竞争,这样消费者就可以同时处理多条消息了 使用任务队列的优点之一就是可以轻易的并行工作。如果我们积压了好多工作，我们可以通过增加工作者（消费者）来解决这一问题，使得系统的伸缩性更加容易。
image.png
1.Round-robin（轮询分发）
轮询分发结果就是不管服务器谁忙或清闲，都不会给谁多一个任务或少一个任务，任务总是你一个我一个的分。
1.1 消息提供者
package com.hrabbit.rabbitmq.send;
import com.hrabbit.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @Auther: hrabbit
* @Date: 2018-06-27 下午2:37
* @Description:
*/
public class Send {
private final static String QUEUE_NAME = "hrabbit_queue_work";
public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
// 获取到连接以及mq通道
Connection connection = ConnectionUtils.getConnection();
Channel channel = connection.createChannel();
// 声明队列
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
for (int i = 0; i < 50; i++) {
// 消息内容
String message = "." + i;
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.println(" [x] Sent '" + message + "'");
Thread.sleep(i * 10);
}
channel.close();
connection.close();
}
}
1.1 消费者一号
package com.hrabbit.rabbitmq.recover;
import com.hrabbit.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @Auther: hrabbit
* @Date: 2018-06-27 下午2:42
* @Description:
*/
public class Received {
private final static String QUEUE_NAME = "hrabbit_queue_work";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnection();
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(" [1] 消费消息: '" + message + "'");
try {
doWork(message);
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println(" [1] 消费消息结束");
}
}
};
boolean autoAck = true;
//消息的确认模式自动应答
channel.basicConsume(QUEUE_NAME, autoAck, consumer);
}
private static void doWork(String task) throws InterruptedException {
Thread.sleep(1000);
}
}
1.1 消费者二号
package com.hrabbit.rabbitmq.recover;
import com.hrabbit.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @Auther: hrabbit
* @Date: 2018-06-27 下午2:42
* @Description:
*/
public class Received2 {
private final static String QUEUE_NAME = "hrabbit_queue_work";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnection();
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(" [2] 消费消息: '" + message + "'");
try {
doWork(message);
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println(" [2] 消费消息结束");
}
}
};
boolean autoAck = true;
//消息的确认模式自动应答
channel.basicConsume(QUEUE_NAME, autoAck, consumer);
}
private static void doWork(String task) throws InterruptedException {
Thread.sleep(2000);
}
}
最后消费者一号和消费者二号的输出结果：
消费者一号：
image.png
消费者二号：
image.png
注:消费者1 我们处理时间是1s ;而消费者2中处理时间是2s; 但是我们看到的现象并不是 1处理的多 消费者2处理的少，消费者1中将偶数部分处理掉了 ，消费者2中将基数部分处理掉了 。
测试结果:
1.消费者1和消费者2获取到的消息内容是不同的,同一个消息只能被一个消费者获取
2.消费者1和消费者2货到的消息数量是一样的 一个奇数一个偶数 按道理消费者1 获取的比消费者2要多
这种方式叫做轮询分发 结果就是不管谁忙或清闲，都不会给谁多一个任务或少一个任务，任务总是你一个我一个的分。
2.Fair dispatch（公平分发）
image.png
虽然上面的分配法方式也还行，但是有个问题就是：比如：现在有2个消费者，所有的偶数的消息都是繁忙的，而奇数则是轻松的。按照轮询的方式，偶数的任务交给了第一个消费者，所以一直在忙个不停。奇数的任务交给另一个消费者，则立即完成任务，然后闲得不行。 而RabbitMQ则是不了解这些的。他是不知道你消费者的消费能力的,这是因为当消息进入队列，RabbitMQ就会分派消息。而rabbitmq只是盲目的将消息轮询的发给消费者。你一个我一个的这样发送.
为了解决这个问题，我们使用basicQos( prefetchCount = 1)方法，来限制RabbitMQ只发不超过1条的消息给同一个消费者。当消息处理完毕后，有了反馈ack，才会进行第二次发送。(也就是说需要手动反馈给Rabbitmq ) 还有一点需要注意，使用公平分发，必须关闭自动应答，改为手动应答。
2.1 生产者
代码基本不用修改，只需要添加一行代码：channel.basicQos(1);
package com.hrabbit.rabbitmq.send;
import com.hrabbit.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @Auther: hrabbit
* @Date: 2018-06-27 下午2:37
* @Description:
*/
public class Send {
private final static String QUEUE_NAME = "hrabbit_queue_work";
private static Integer prefetchCount=1;
public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
// 获取到连接以及mq通道
Connection connection = ConnectionUtils.getConnection();
Channel channel = connection.createChannel();
//每个消费者发送确认信号之前，消息队列不发送下一个消息过来，一次只处理一个消息
//限制发给同一个消费者不得超过1条消息
channel.basicQos(prefetchCount);
// 声明队列
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
for (int i = 0; i < 50; i++) {
// 消息内容
String message = "." + i;
channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
System.out.println(" [x] Sent '" + message + "'");
Thread.sleep(i * 10);
}
channel.close();
connection.close();
}
}
2.2 消费者一
首先设置channel.basicQos(1);保证一次只分发一次，其次将autoAck设置为fase,在每次消息处理完成之后，手动确认消息channel.basicAck(envelope.getDeliveryTag(), false);
package com.hrabbit.rabbitmq.recover;
import com.hrabbit.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @Auther: hrabbit
* @Date: 2018-06-27 下午2:42
* @Description:
*/
public class Received {
private final static String QUEUE_NAME = "hrabbit_queue_work";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnection();
final Channel channel = connection.createChannel();
// 声明队列，主要为了防止消息接收者先运行此程序，队列还不存在时创建队列。
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
channel.basicQos(1);//保证一次只分发一个
//定义一个消息的消费者
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(" [1] 消费消息: '" + message + "'");
try {
doWork(message);
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println(" [1] 消费消息结束");
//手动应答
channel.basicAck(envelope.getDeliveryTag(), false);
}
}
};
boolean autoAck = false;
//消息的确认模式关闭自动
channel.basicConsume(QUEUE_NAME, autoAck, consumer);
}
private static void doWork(String task) throws InterruptedException {
Thread.sleep(1000);
}
}
2.2 消费者二
package com.hrabbit.rabbitmq.recover;
import com.hrabbit.rabbitmq.utils.ConnectionUtils;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
* @Auther: hrabbit
* @Date: 2018-06-27 下午2:42
* @Description:
*/
public class Received2 {
private final static String QUEUE_NAME = "hrabbit_queue_work";
public static void main(String[] args) throws IOException, TimeoutException {
Connection connection = ConnectionUtils.getConnection();
final Channel channel = connection.createChannel();
// 声明队列，主要为了防止消息接收者先运行此程序，队列还不存在时创建队列。
channel.queueDeclare(QUEUE_NAME, false, false, false, null);
channel.basicQos(1);//保证一次只分发一个
//定义一个消息的消费者
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(" [2] 消费消息: '" + message + "'");
try {
doWork(message);
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println(" [2] 消费消息结束");
channel.basicAck(envelope.getDeliveryTag(), false);
}
}
};
boolean autoAck = false;
//消息的确认模式自动应答关闭
channel.basicConsume(QUEUE_NAME, autoAck, consumer);
}
private static void doWork(String task) throws InterruptedException {
//消息的处理时间为2000
Thread.sleep(2000);
}
}
最后消费者一号和消费者二号的输出结果：
消费者一：
image.png
消费者二：
image.png
这时候现象就是消费者1 速度大于消费者2 。
系列文章：
RabbitMQ：RabbitMQ-理论基础
RabbitMQ：快速入门hello word
RabbitMQ：RabbitMQ：消息应答与消息持久化
RabbitMQ：发布/订阅 Publish/Subscribe
RabbitMQ：路由Routing
RabbitMQ：Topic类型的exchange
RabbitMQ：RabbitMQ之消息确认机制（事务+Confirm）
RabbitMQ：spring整合RabbitMQ