RabbitMQ之工作队列

      该模型适用于分发资源密集型的任务，多个消费者可以订阅同一个Queue，这时Queue中的消息会被平均分摊给多个消费者进行处理，而不是每个消费者都收到所有的消息并处理（接下来讲到的轮询调度）。

轮询调度

      采用这种模式，消息在队列中保存，以轮询的方式将消息发送给监听消息队列的消费者，可以动态的增加消费者以提高消息的处理能力。

示例代码（发送方发送多条信息，多个接收方轮询接收信息）：

发送方：

import java.io.IOException;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * 消息轮询
 * 假设有两个或多个消费者，发送方发送的消息会顺序轮询的发送给消费者
 * 例如：有消费者01和消费者02，发送的第一个消息由第一个消费者01接收，
 * 发送的第二个消息由第二个消费者02接收，发送的第三个消息又会由第一个
 * 消费者01接收，以此类推
 * @author menghh
 *
 */
public class Send02 {

	private final static String QUEUE_NAME ="queue1";
	public static void main(String[] args) throws IOException{
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("127.0.0.1");
		Connection con = factory.newConnection();
		Channel channel = con.createChannel();
		channel.queueDeclare(QUEUE_NAME, false, false,false,null);
		String[] msgs = {"第一个消息!","第二个消息!","第三个消息!","第四个消息!","第五个消息!"};  
		//发送多个消息
		for(String msg:msgs){
			channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
			System.out.println("send message["+msg+"] to "+QUEUE_NAME+" success!");
		}
       channel.close();
       con.close();
	}
}

接收方（运行两个或多个接收方代码，创建多个消息接收方）：

private final static String QUEUE_NAME ="queue1";
	public static void main(String[] args) throws IOException, ShutdownSignalException, ConsumerCancelledException, InterruptedException {
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("127.0.0.1");
		Connection conn;
		conn = factory.newConnection();
		Channel channel = conn.createChannel();
		channel.queueDeclare(QUEUE_NAME, false, false, false, null);

		//配置好获取消息得方式
		QueueingConsumer consumer =  new QueueingConsumer(channel);
		boolean autoAck = true; 
		channel.basicConsume(QUEUE_NAME, autoAck,consumer);
		//循环获取消息
		while(true){
			//获取消息，如果没有消息，这一步将会一直阻塞
			Delivery delivery = consumer.nextDelivery();
			String msg = new String(delivery.getBody());
			System.out.println("received message["+msg+"] from "+QUEUE_NAME);
		}
	}

轮询调度结果（这里创建了两个接收方）：

消息确认

        为了确保消息一定被消费者处理，rabbitMQ提供了消息确认功能，就是在消费者处理完任务之后，就给服务器一个回馈，服务器就会将该消息删除，如果消费者超时不回馈，那么服务器将就将该消息重新发送给其他消费者。

判断是否为自动确认消息的代码如下所示：

boolean autoAck = true; 
		channel.basicConsume(QUEUE_NAME, autoAck,consumer);

        默认是开启的，在消费者端通过下面的方式开启消息确认,  首先将autoAck自动确认关闭，等我们的任务执行完成之后，手动的去确认，类似JDBC的autocommit一样。

示例代码：

将消息改为手动确认的方式需要修改接收者代码（发送方代码不变）：

1、设置接收方为手动方式

2、接收到消息后回复确认标志

/**
         * 取消 autoAck 
         * 一旦将autoAck关闭之后，一定要记得处理完消息之后，向服务器确认消息，否则服务器将会一直转发该消息 
         */
boolean autoAck = false;
channel.basicConsume("hello", autoAck, consumer);

while (true) {
  QueueingConsumer.Delivery delivery = consumer.nextDelivery();
  //...     
  //确认收到消息，消息可被删除 
  channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}

消息确认测试结果：

    如果只把autoAck改为false,把确认消息的代码注释掉，不向服务器确认消息，执行发送消息后，接收方每次执行都会收到该消息，该消息一直被服务器转发

如果确认消息，则接收一次后就不再被接收了。确认收到该消息后服务器会删除该消息。

公平调度

    如果在某种情况下有两个工作者，因为消息是轮询接收的，所有奇数的消息是重量级(heavy)，偶数的消息是轻量级的，一个工作者将非常忙碌而另外一个工作者几乎不做任何工作，RabbitMQ仍然会轮询派遣消息，这种情况明显不是很合理。

    为了打破这个规则，我们可以使用basicQos的方法与prefetchCount=1设置，这告诉RabbitMQ发送消息给不忙的消息接收者。

//设置公平调度的标志
		int prefetchCount = 1;
		channel.basicQos(prefetchCount);

示例代码

发送端：

import java.io.IOException;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;

/**
 * 公平调度
 * 为了更好的观察效果，把其中一个消费者消息确认之前设置一个沉睡时间
 * @author menghh
 *
 */
public class Send05 {

	public static void main(String[] args) throws IOException {
		ConnectionFactory factory = new ConnectionFactory();
		//RabbitMQ-Server安装在本机，所以直接用127.0.0.1
		factory.setHost("127.0.0.1");
		//创建一个连接
		Connection conn = factory.newConnection();
		//创建一个通信通道
		Channel channel = conn.createChannel();
		//定义Queue名称
		String queueName = "queue01";
		//为Channel定义queue的属性，queueName为queue名称
		channel.queueDeclare(queueName, true, false,false,null);
		for(int i=0;i<10;i++){
			String msg = "公平调度：message-"+i;
			//发送持久化消息
			channel.basicPublish("", queueName, MessageProperties.PERSISTENT_TEXT_PLAIN, msg.getBytes());
			System.out.println("send message["+msg+"] to "+queueName+"success!");
		}
		//关闭通道
		channel.close();
		//关闭连接
		conn.close();
	}
}

接收端：

设置两个或多个接收者，为了更好的观察公平调度原则，把接收者设定不同的沉睡时间，这里只做其中一个消费者代码的展示

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.client.QueueingConsumer.Delivery;

/**
 * 公平调度
 * @author menghh
 *
 */
public class Recv05 {

	public static void main(String[] args) throws Exception{
		ConnectionFactory factory = new ConnectionFactory(); 
		factory.setHost("127.0.0.1");
		Connection conn = factory.newConnection();
		Channel channel = conn.createChannel();
		//设置公平调度的标志
		int prefetchCount = 1;
		channel.basicQos(prefetchCount);
		
		String queueName = "queue01";
		channel.queueDeclare(queueName, true, false, false, null);
		//以上部分和sender一样
		//配置好获取消息得方式
		QueueingConsumer consumer =  new QueueingConsumer(channel);
		channel.basicConsume(queueName, false,consumer);
		//循环获取消息
		while(true){
			//获取消息，如果没有消息，这一步将会一直阻塞
			Delivery delivery = consumer.nextDelivery();
			String msg = new String(delivery.getBody());
			//为了更好的观察公平调度原则，把接收者设定不同的沉睡时间
			Thread.sleep(1000);
			//确认消息，已经收到  
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);  
			System.out.println("received message["+msg+"] from "+queueName);
		}
	}
}

公平调度测试结果：

消息不再轮询发给每个消费者，消费者接收的信息也不再是奇偶相间的发送，而是发给不忙碌的消费者。在其中一个消费者沉睡的时候，消息就会发给其它处于工作状态的消费者