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);
		}
	}
}

公平調度測試結果：

消息不再輪詢發給每個消費者，消費者接收的信息也不再是奇偶相間的發送，而是發給不忙碌的消費者。在其中一個消費者沉睡的時候，消息就會發給其它處於工作狀態的消費者