rabbitmq工作队列

其他 2018-08-12 13:06:35 阅读次数: 0

工作队列的主要任务是：避免立刻执行资源密集型任务，然后必须等待其完成。相反地，我们进行任务调度：我们把任务封装为消息发送给队列。工作进行在后台运行并不断的从队列中取出任务然后执行。当你运行了多个工作进程时，任务队列中的任务将会被工作进程共享执行。这样的概念在web应用中极其有用，当在很短的HTTP请求间需要执行复杂的任务。

发送端发送消息：我们使用Thread.sleep来模拟耗时的任务。我们在发送到队列的消息的末尾添加一定数量的点，每个点代表在工作线程中需要耗时1秒，例如hello…将会需要等待3秒。

代码如下：

@Test
	public void sendMessage() throws IOException, TimeoutException{
		Connection connection = factory.newConnection();
		Channel channel = connection.createChannel();
		//声明队列
		channel.queueDeclare(QUEUE_NAME, false, false, false, null);
		//发送10条消息，依次在消息后面附加1-10个点
		for (int i = 0; i < 10; i++)
		{
			String dots = "";
			for (int j = 0; j <= i; j++)
			{
				dots += ".";
			}
			String message = "helloworld" + dots+dots.length();
			channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
			System.out.println(" [x] Sent '" + message + "'");
		}
		//关闭频道和资源
		channel.close();
		connection.close();
	}

控制台输出：

 [x] Sent 'helloworld.1'
 [x] Sent 'helloworld..2'
 [x] Sent 'helloworld...3'
 [x] Sent 'helloworld....4'
 [x] Sent 'helloworld.....5'
 [x] Sent 'helloworld......6'
 [x] Sent 'helloworld.......7'
 [x] Sent 'helloworld........8'
 [x] Sent 'helloworld.........9'

 [x] Sent 'helloworld..........10'

接收端代码如下：

@Test
	public void receiveMessage() throws IOException, TimeoutException, ShutdownSignalException, ConsumerCancelledException, InterruptedException{
		//区分不同工作进程的输出
		int hashCode = Work.class.hashCode();
		Connection connection = factory.newConnection();
		Channel channel = connection.createChannel();
		//声明队列
		channel.queueDeclare(QUEUE_NAME, false, false, false, null);
		System.out.println(hashCode
				+ " [*] Waiting for messages. To exit press CTRL+C");
	
		QueueingConsumer consumer = new QueueingConsumer(channel);
		// 指定消费队列
		channel.basicConsume(QUEUE_NAME, true, consumer);
		while (true){
			QueueingConsumer.Delivery delivery = consumer.nextDelivery();
			String message = new String(delivery.getBody());
 
			System.out.println(hashCode + " [x] Received '" + message + "'");
			doWork(message);
			System.out.println(hashCode + " [x] Done");
		}
	}
		 
	/**
	 * 每个点耗时1s
	 * @param task
	 * @throws InterruptedException
	 */
	private static void doWork(String task) throws InterruptedException{
		for (char ch : task.toCharArray()){
			if (ch == '.')
				Thread.sleep(1000);
		}
	}

默认的，RabbitMQ会一个一个的发送信息给下一个消费者(consumer)，而不考虑每个任务的时长等等，且是一次性分配，并非一个一个分配。平均的每个消费者将会获得相等数量的消息。这样分发消息的方式叫做round-robin，控制台打印消息如下：

消费者线程1：

1128920667 [*] Waiting for messages. To exit press CTRL+C
1128920667 [x] Received 'helloworld.1'
1128920667 [x] Done
1128920667 [x] Received 'helloworld....4'
1128920667 [x] Done
1128920667 [x] Received 'helloworld.......7'
1128920667 [x] Done
1128920667 [x] Received 'helloworld..........10'

1128920667 [x] Done

消费者线程2：

751629024 [*] Waiting for messages. To exit press CTRL+C
751629024 [x] Received 'helloworld..2'
751629024 [x] Done
751629024 [x] Received 'helloworld.....5'
751629024 [x] Done
751629024 [x] Received 'helloworld........8'

751629024 [x] Done

消费者线程3：

1130194714 [*] Waiting for messages. To exit press CTRL+C
1130194714 [x] Received 'helloworld...3'
1130194714 [x] Done
1130194714 [x] Received 'helloworld......6'
1130194714 [x] Done
1130194714 [x] Received 'helloworld.........9'

1130194714 [x] Done

Rabbitmq的消息应答（message acknowledgments）

执行一个任务需要花费几秒钟。当一个工作者在执行任务时发生中断。按照上面的代码，一旦RabbItMQ交付了一个信息给消费者，会马上从内存中移除这个信息。在这种情况下，如果杀死正在执行任务的某个工作者，我们会丢失它正在处理的信息。我们也会丢失已经转发给这个工作者且它还未执行的消息。上面的例子，我们首先开启两个任务，然后执行发送任务的代码，然后立即关闭第二个任务，结果为：

消费者线程1：

1128920667 [x] Received 'helloworld..2'
1128920667 [x] Done
1128920667 [x] Received 'helloworld....4'
1128920667 [x] Done
1128920667 [x] Received 'helloworld......6'
1128920667 [x] Done
1128920667 [x] Received 'helloworld........8'
1128920667 [x] Done
1128920667 [x] Received 'helloworld..........10'

1128920667 [x] Done

消费者线程2：

751629024 [x] Received 'helloworld.1'
751629024 [x] Done
751629024 [x] Received 'helloworld...3'
751629024 [x] Done

751629024 [x] Received 'helloworld.....5'

可以看到，第二个工作者至少丢失了7,9号任务，且5号任务未完成。

但是，我们不希望丢失任何任务（信息）。当某个工作者（接收者）被杀死时，我们希望将任务传递给另一个工作者。
为了保证消息永远不会丢失，RabbitMQ支持消息应答（message acknowledgments）。消费者发送应答给RabbitMQ，告诉它信息已经被接收和处理，然后RabbitMQ可以自由的进行信息删除。如果消费者被杀死而没有发送应答，RabbitMQ会认为该信息没有被完全的处理，然后将会重新转发给别的消费者。通过这种方式，可以确认信息不会被丢失，即使消者偶尔被杀死。这种机制并没有超时时间这么一说，RabbitMQ只有在消费者连接断开是重新转发此信息。如果消费者处理一个信息需要耗费特别特别长的时间是允许的。

消息应答默认是打开的。上面的代码中我们通过显示的设置autoAsk=true关闭了这种机制，修改后代码如下：注意标红部分，在开启消息应答之后，消息处理完成之后需要向服务器发送应答

@Test
	public void receiveMessage() throws IOException, TimeoutException, ShutdownSignalException, ConsumerCancelledException, InterruptedException{
		//区分不同工作进程的输出
		int hashCode = Work.class.hashCode();
		Connection connection = factory.newConnection();
		Channel channel = connection.createChannel();
		//声明队列
		channel.queueDeclare(QUEUE_NAME, false, false, false, null);
		System.out.println(hashCode
				+ " [*] Waiting for messages. To exit press CTRL+C");
	
		QueueingConsumer consumer = new QueueingConsumer(channel);
		boolean ack = false ; //打开应答机制
		// 指定消费队列
		channel.basicConsume(QUEUE_NAME, ack, consumer);
		while (true){
			QueueingConsumer.Delivery delivery = consumer.nextDelivery();
			String message = new String(delivery.getBody());
 
			System.out.println(hashCode + " [x] Received '" + message + "'");
			doWork(message);
			System.out.println(hashCode + " [x] Done");
			//发送应答
			channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
		}
	}
此时， 打开两个消费者，然后发送任务，立即关闭一个消费者，观察输出：
消费者线程1：
1826774922 [*] Waiting for messages. To exit press CTRL+C
1826774922 [x] Received 'helloworld.1'
1826774922 [x] Done
1826774922 [x] Received 'helloworld...3'
1826774922 [x] Done
1826774922 [x] Received 'helloworld.....5'
1826774922 [x] Done
1826774922 [x] Received 'helloworld.......7'
1826774922 [x] Done
1826774922 [x] Received 'helloworld.........9'
1826774922 [x] Done
1826774922 [x] Received 'helloworld......6'
1826774922 [x] Done
1826774922 [x] Received 'helloworld........8'
1826774922 [x] Done
1826774922 [x] Received 'helloworld..........10'

1826774922 [x] Done

消费者线程2：

2082519650 [*] Waiting for messages. To exit press CTRL+C
2082519650 [x] Received 'helloworld..2'
2082519650 [x] Done
2082519650 [x] Received 'helloworld....4'
2082519650 [x] Done

2082519650 [x] Received 'helloworld......6'

可以看到消费者线程2没有完成的任务6，重新转发给消费者线程1进行完成了。

消息持久化（Message durability）

我们已经学习了即使消费者被杀死，消息也不会被丢失。但是如果此时RabbitMQ服务被停止，我们的消息仍然会丢失。

当RabbitMQ退出或者异常退出，将会丢失所有的队列和信息，除非你告诉它不要丢失。我们需要做两件事来确保信息不会被丢失：我们需要给所有的队列和消息设置持久化的标志。
第一， 我们需要确认RabbitMQ永远不会丢失我们的队列。为了这样，我们需要声明它为持久化的。
boolean durable = true;
channel.queueDeclare("task_queue", durable, false, false, null);
注：RabbitMQ不允许使用不同的参数重新定义一个队列，所以已经存在的队列，我们无法修改其属性。
第二， 我们需要标识我们的信息为持久化的。通过设置MessageProperties（implements BasicProperties）值为PERSISTENT_TEXT_PLAIN。
channel.basicPublish("", "task_queue",MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes());

现在你可以执行一个发送消息的程序，然后关闭服务，再重新启动服务，运行消费者程序做下实验

公平转发（Fair dispatch）
或许会发现，目前的消息转发机制（Round-robin）并非是我们想要的。例如，这样一种情况，对于两个消费者，有一系列的任务，奇数任务特别耗时，而偶数任务却很轻松，这样造成一个消费者一直繁忙，另一个消费者却很快执行完任务后等待。
造成这样的原因是因为RabbitMQ仅仅是当消息到达队列进行转发消息。并不在乎有多少任务消费者并未传递一个应答给RabbitMQ。仅仅盲目转发所有的奇数给一个消费者，偶数给另一个消费者。

为了解决这样的问题，我们可以使用basicQos方法，传递参数为prefetchCount = 1。这样告诉RabbitMQ不要在同一时间给一个消费者超过一条消息。换句话说，只有在消费者空闲的时候会发送下一条信息。

//设置最大服务转发消息数量
int prefetchCount = 1;
channel.basicQos(prefetchCount);

完整代码如下：

发送端：

@Test
	public void sendMessage() throws IOException, TimeoutException{
		Connection connection = factory.newConnection();
		Channel channel = connection.createChannel();
		//声明队列
		boolean durable = true;// 1、设置队列持久化
		channel.queueDeclare(QUEUE_NAME, durable, false, false, null);
		//发送10条消息，依次在消息后面附加1-10个点
		for (int i = 0; i < 10; i++)
		{
			String dots = "";
			for (int j = 0; j <= i; j++)
			{
				dots += ".";
			}
			String message = "helloworld" + dots+dots.length();
			// MessageProperties 2、设置消息持久化
			channel.basicPublish("", QUEUE_NAME,MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
			System.out.println(" [x] Sent '" + message + "'");
		}
		//关闭频道和资源
		channel.close();
		connection.close();
	}

接收端代码如下：

@Test
	public void receiveMessage() throws IOException, TimeoutException, ShutdownSignalException, ConsumerCancelledException, InterruptedException{
		//区分不同工作进程的输出
		int hashCode = Work.class.hashCode();
		Connection connection = factory.newConnection();
		Channel channel = connection.createChannel();
		//声明队列
		channel.queueDeclare(QUEUE_NAME, false, false, false, null);
		System.out.println(hashCode
				+ " [*] Waiting for messages. To exit press CTRL+C");
		//设置最大服务转发消息数量
		int prefetchCount = 1;
		channel.basicQos(prefetchCount);
		QueueingConsumer consumer = new QueueingConsumer(channel);
		// 指定消费队列
		boolean ack = false ; //打开应答机制
		// 指定消费队列
		channel.basicConsume(QUEUE_NAME, ack, consumer);
		while (true){
			QueueingConsumer.Delivery delivery = consumer.nextDelivery();
			String message = new String(delivery.getBody());
 
			System.out.println(hashCode + " [x] Received '" + message + "'");
			doWork(message);
			System.out.println(hashCode + " [x] Done");
			//发送应答
			channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
		}
	}

转自http://blog.csdn.net/lmj623565791/article/details/37620057

猜你喜欢

转载自blog.csdn.net/BingoXing/article/details/81011997
今日推荐
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
周排行
浏览器对同一域名进行请求的最大并发连接数
React Hook之自定义Hook
【转】MyBatis缓存机制
-Java-泛型
自动化测试常用脚本-发送邮件
LeetCode#859: Buddy Strings
java、Python处理字符串
第二篇の博客
Hadoop伪分布式环境安装
SQL Server进阶（十一）临时表、表变量
每日归档
更多
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022