RabbitMQ的预取值以及发布确认的策略
RabbitMQ的预取值
RabbitMQ的信道上肯定不止只有一个消息，因此这里就存在一个未确认的消息缓冲区，因此希望开发人员能限制此缓冲区的大小，以避免缓冲区里面无限制的未确认消息问题。这个时候就可以通过使用 channel.basicQos() 方法设置“预取计数”值来完成的。该值定义通道上允许的未确认消息的最大数量。。一旦数量达到配置的数量，RabbitMQ 将停止在通道上传递更多消息，除非至少有一个未处理的消息被确认
代码演示
- 消费者,开启手动确认，同时给两个消费者设置不同的预取值，一个为2另一个为5，让两个程序分别进行不同时间的休眠，一个休眠1秒，一个休眠10秒，但是休眠1s的程序预取值为2，休眠10s的消费者预取值为5，两个消费者除了预取值与休眠时间外全部相等，以下为其中一个的代码
public class Worker01 {
//设置队列名称
public static final String TASK_QUEUE_NAME = "ack_queue";
public static void main(String[] args) throws IOException, TimeoutException {
//创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 工厂IP，连接RabbitMQ队列(安装RabbitMQ机器的IP地址)
factory.setHost("xxx.xxx.xxx.xxx");
//用户名
factory.setUsername("username");
//密码
factory.setPassword("password");
// 创建连接
Connection connection = factory.newConnection();
// 获取信道
Channel channel = connection.createChannel();
System.out.println("C1等待接收消息处理，时间较短。。");
// 推送的消息如何进行消费的接口回调
DeliverCallback deliverCallback = (consumerTag, message) -> {
// 沉睡1S
try {
Thread.sleep(1000 * 1);
} catch (InterruptedException _ignored) {
Thread.currentThread().interrupt();
}
System.out.println("接收到的消息：" + new String(message.getBody(),"UTF-8"));
// 手动应答
/**
* 1. 消息的标记 tag
* 2. 是否批量应答 false 不批量，true 批量
*/
channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
};
// 取消消息时的回调
CancelCallback cancelCallback = consumerTag -> {
System.out.println("消息消费被中断");
};
// 设置预取值为2
channel.basicQos(2);
//采用手动应答
Boolean autoAck = false;
channel.basicConsume(TASK_QUEUE_NAME,autoAck,deliverCallback,cancelCallback);
}
}
- 生产者与普通生产者相同，但需要注意，开启生产者的发布确认 // 开启发布确认
channel.confirmSelect();
public class Task {
//设置队列名称
public static final String TASK_QUEUE_NAME = "ack_queue";
public static void main(String[] args) throws IOException, TimeoutException {
=========与上述的获取信道的方式相同==========
// 开启发布确认
channel.confirmSelect();
/**
* 生成一个队列
* 1. 队列名称
* 2. 队列中的消息是否需要持久话（磁盘），默认情况消息存储在内存中
* 3. 该队列是否只供一个消费者进行消费，是否进行消息共享，true可以多个消费者消费，false只能一个消费者消费
* 4. 是否自动删除，最后一个消费者断开连接后，该队列是否自动删除 true自动删除，false则相反
* 5. 其他参数
*/
Boolean durable = true ; // 需要队列持久化
channel.queueDeclare(TASK_QUEUE_NAME,durable,false,false,null);
Scanner scanner = new Scanner(System.in);
while(scanner.hasNext()){
String message = scanner.next();
// 设置生产者发送消息为持久化消息（要求保存在磁盘上），
channel.basicPublish("",TASK_QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes("UTF-8"));
System.out.println("生产者发出消息："+message);
}
}
}
结果
- work01的虽然处理消息较快，但是也只处理了五个，但是由于work02处理的消息较慢，所以队列中存在未确认的消息，消息维持在5条，work02每处理一个，未确认的消息就减一
发布确认的三种策略
发布确认默认是没有开启的，如果要开启需要调用方法 channel.confirmSelect();，生产者将信道设置成 confirm 模式，一旦信道进入 confirm 模式，所有在该信道上面发布的消息都将会被指派一个唯一的 ID(从 1 开始)，一旦消息被投递到所有匹配的队列之后，broker就会发送一个确认给生产者(包含消息的唯一 ID)，这就使得生产者知道消息已经正确到达目的队列了
单个发布确认
这是一种简单的确认方式，它是一种同步确认发布的方式，也就是发布一个消息之后只有它
被确认发布，后续的消息才能继续发布这种确认方式有一个最大的缺点就是:发布速度特别的慢，因为如果没有确认发布的消息就会阻塞所有后续消息的发布，这种方式最多提供每秒不超过数百条发布消息的吞吐量。通过channel.waitForConfirms();来判断消息是否被确认，以下为单个发布的方法
// 单个确认
public static void publicMessageIndividually() throws Exception {
//创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 工厂IP，连接RabbitMQ队列
factory.setHost("xxx.xxx.xxx.xxx");
//用户名
factory.setUsername("username");
//密码
factory.setPassword("password");
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
//声明随机队列
String queueName = UUID.randomUUID().toString();
channel.queueDeclare(queueName, false, false, false, null);
//开启发布确认
channel.confirmSelect();
// 开始时间
long startTime = System.currentTimeMillis();
// 批量发消息
for (int i = 0; i < MESSAGE_COUNT; i++) {
String message = i + "";
channel.basicPublish("", queueName, null, message.getBytes());
//单个消息马上就进行发布确认
boolean flag = channel.waitForConfirms();
if (flag) {
System.out.println("消息发送成功！");
}
}
//结束时间
long endTime = System.currentTimeMillis();
System.out.println("发布" + MESSAGE_COUNT + "条单独确认消息，耗时：" + (endTime - startTime) + "ms");
}
批量发布确认
上面那种方式非常慢，与单个等待确认消息相比，先发布一批消息然后一起确认可以极大地
提高吞吐量，当然这种方式的缺点就是:当发生故障导致发布出现问题时，不知道是哪个消息出现
问题了，我们必须将整个批处理保存在内存中，以记录重要的信息而后重新发布消息。当然这种
方案仍然是同步的，也一样阻塞消息的发布，通过设置一个批量确认的大小，在发送相同大小数据的时候进行一次确认
// 批量确认发布
public static void publishMessageBatch() throws Exception {
========上述获取信道的方法获取信道=========
//声明随机队列
String queueName = UUID.randomUUID().toString();
channel.queueDeclare(queueName, false, false, false, null);
//开启发布确认
channel.confirmSelect();
// 开始时间
long startTime = System.currentTimeMillis();
// 批量确认消息的大小
int batchSize = 100;
// 批量发消息
for (int i = 0; i < MESSAGE_COUNT; i++) {
String message = i + "";
channel.basicPublish("", queueName, null, message.getBytes());
// 当达到100条消息的时候，批量确认一次
if (i % batchSize == 0) {
// 发布确认
channel.waitForConfirms();
}
}
//结束时间
long endTime = System.currentTimeMillis();
System.out.println("发布" + MESSAGE_COUNT + "条批量确认消息，耗时：" + (endTime - startTime) + "ms");
}
异步确认
异步确认虽然编程逻辑比上两个要复杂，但是性价比最高，无论是可靠性还是效率都没得说，
他是利用回调函数来达到消息可靠性传递的，这个中间件也是通过函数回调来保证是否投递成功，通过配置信道的 channel.addConfirmListener(ackCallback,nackCallback);方法来进行异步确认，该方法的两个参数第一个为成功确认的消息监听器，第二个为失败的消息监听器
//异步发布确认
public static void publicMessageAsync() throws IOException, TimeoutException {
===========与上述的获取信道的方式相同============
//声明随机队列
String queueName = UUID.randomUUID().toString();
channel.queueDeclare(queueName, false, false, false, null);
//开启发布确认
channel.confirmSelect();
/**
* 线程安全有序的哈希表，适用于高并发情况下
* 1. 轻松将序号与消息进行关联
* 2. 轻松批量删除条目 只要给到序号
* 3. 指出高并发（多线程）
*/
ConcurrentSkipListMap<Long,String> outstandingConfirm = new ConcurrentSkipListMap<>();
// 开始时间
long startTime = System.currentTimeMillis();
//消息监听器 监听哪些消息成功 哪些消息失败
// 监听成功消息
ConfirmCallback ackCallback = (deliveryTag, multiple) -> {
if(multiple){
//2.删除已经确认的消息 剩下的就是未确认的消息
ConcurrentNavigableMap<Long, String> confirmed =
outstandingConfirm.headMap(deliveryTag);
confirmed.clear();
}else {
outstandingConfirm.remove(deliveryTag);
}
System.out.println("成功确认的消息：" + deliveryTag);
};
// 监听失败消息
/**
* 1. 消息的标识
* 2. 是否为批量确认
*/
ConfirmCallback nackCallback = (deliveryTag,multiple) -> {
String message = outstandingConfirm.get(deliveryTag);
System.out.println("未确认的消息：" + deliveryTag);
};
channel.addConfirmListener(ackCallback,nackCallback);
for (int i=0;i<MESSAGE_COUNT;i++){
String message = "消息"+i;
channel.basicPublish("", queueName, null, message.getBytes());
// 记录下要发送的所有消息 消息的总和
outstandingConfirm.put(channel.getNextPublishSeqNo(),message);
}
//结束时间
long endTime = System.currentTimeMillis();
System.out.println("发布" + MESSAGE_COUNT + "条异步发布确认消息，耗时：" + (endTime - startTime) + "ms");
}
总结
- 单独发布消息 ：同步等待确认，简单，但吞吐量非常有限。
- 批量发布消息 批量同步等待确认，简单，合理的吞吐量，一旦出现问题但很难推断出是那条
消息出现了问题。 - 异步处理： 最佳性能和资源使用，在出现错误的情况下可以很好地控制，但是实现起来稍微难些
尚硅谷B站RabbitMQ教程：尚硅谷RabbitMQ
扫一扫
1796
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
