redis java 缓存 RabbitMQ的预取值以及发布确认的策略

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 outstandingConfirm = new ConcurrentSkipListMap<>();

// 开始时间

long startTime = System.currentTimeMillis();

//消息监听器监听哪些消息成功哪些消息失败

// 监听成功消息

ConfirmCallback ackCallback = (deliveryTag, multiple) -> {

if(multiple){

//2.删除已经确认的消息剩下的就是未确认的消息

ConcurrentNavigableMap 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

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

查看原文

夸智网

redis java 缓存 RabbitMQ的预取值以及发布确认的策略

运维服务器【Linux】| Linux编辑器-vim的使用

kubernetes k8s-docker之nginx dns缓存问题排查

发表评论取消回复

夸智网

redis java 缓存 RabbitMQ的预取值以及发布确认的策略

运维 服务器 【Linux】| Linux编辑器-vim的使用

kubernetes k8s-docker之nginx dns缓存问题排查

相关文章

发表评论取消回复

运维服务器【Linux】| Linux编辑器-vim的使用