2. 程式人生 > >RabbitMQ （二）工作佇列

RabbitMQ （二）工作佇列

阿新 • • 發佈：2019-02-10

本系列教程主要來自於官網入門教程的翻譯，然後自己進行了部分的修改與實驗，內容僅供參考。

上一篇部落格中我們寫了通過一個命名的佇列傳送和接收訊息，如果你還不瞭解請點選：RabbitMQ 入門 Helloworld。這篇中我們將會建立一個工作佇列用來在工作者（consumer）間分發耗時任務。

工作佇列的主要任務是：避免立刻執行資源密集型任務，然後必須等待其完成。相反地，我們進行任務排程：我們把任務封裝為訊息傳送給佇列。工作進行在後臺執行並不斷的從佇列中取出任務然後執行。當你運行了多個工作程序時，任務佇列中的任務將會被工作程序共享執行。
這樣的概念在web應用中極其有用，當在很短的HTTP請求間需要執行復雜的任務。
1、 準備

我們使用Thread.sleep來模擬耗時的任務。我們在傳送到佇列的訊息的末尾新增一定數量的點，每個點代表在工作執行緒中需要耗時1秒，例如hello…將會需要等待3秒。

傳送端：

NewTask.java

package com.zhy.rabbit._02_workqueue;

import java.io.IOException;

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

public class NewTask
{
	//佇列名稱
	private final static String QUEUE_NAME = "workqueue";

	public static void main(String[] args) throws IOException
	{
		//建立連線和頻道
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("localhost");
		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();

	}


}

接收端：

Work.java

package com.zhy.rabbit._02_workqueue;

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

public class Work
{
	//佇列名稱
	private final static String QUEUE_NAME = "workqueue";

	public static void main(String[] argv) throws java.io.IOException,
			java.lang.InterruptedException
	{
		//區分不同工作程序的輸出
		int hashCode = Work.class.hashCode();
		//建立連線和頻道
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("localhost");
		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);
		}
	}
}

Round-robin 轉發
使用任務佇列的好處是能夠很容易的並行工作。如果我們積壓了很多工作，我們僅僅通過增加更多的工作者就可以解決問題，使系統的伸縮性更加容易。
下面我們先執行3個工作者（Work.java）例項，然後執行NewTask.java，3個工作者例項都會得到資訊。但是如何分配呢？讓我們來看輸出結果：[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'

工作者1：
605645 [*] Waiting for messages. To exit press CTRL+C
605645 [x] Received 'helloworld.1'
605645 [x] Done
605645 [x] Received 'helloworld....4'
605645 [x] Done
605645 [x] Received 'helloworld.......7'
605645 [x] Done
605645 [x] Received 'helloworld..........10'
605645 [x] Done

工作者2：
18019860 [*] Waiting for messages. To exit press CTRL+C
18019860 [x] Received 'helloworld..2'
18019860 [x] Done
18019860 [x] Received 'helloworld.....5'
18019860 [x] Done
18019860 [x] Received 'helloworld........8'
18019860 [x] Done

工作者3：
18019860 [*] Waiting for messages. To exit press CTRL+C
18019860 [x] Received 'helloworld...3'
18019860 [x] Done
18019860 [x] Received 'helloworld......6'
18019860 [x] Done
18019860 [x] Received 'helloworld.........9'
18019860 [x] Done
可以看到，預設的，RabbitMQ會一個一個的傳送資訊給下一個消費者(consumer)，而不考慮每個任務的時長等等，且是一次性分配，並非一個一個分配。平均的每個消費者將會獲得相等數量的訊息。這樣分發訊息的方式叫做round-robin。

2、 訊息應答（message acknowledgments）
執行一個任務需要花費幾秒鐘。你可能會擔心當一個工作者在執行任務時發生中斷。我們上面的程式碼，一旦RabbItMQ交付了一個資訊給消費者，會馬上從記憶體中移除這個資訊。在這種情況下，如果殺死正在執行任務的某個工作者，我們會丟失它正在處理的資訊。我們也會丟失已經轉發給這個工作者且它還未執行的訊息。
上面的例子，我們首先開啟兩個任務，然後執行傳送任務的程式碼（NewTask.java），然後立即關閉第二個任務，結果為：
工作者2：

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

工作者1：
18019860 [*] Waiting for messages. To exit press CTRL+C
18019860 [x] Received 'helloworld.1'
18019860 [x] Done
18019860 [x] Received 'helloworld...3'
18019860 [x] Done
18019860 [x] Received 'helloworld.....5'
18019860 [x] Done
18019860 [x] Received 'helloworld.......7'
18019860 [x] Done
18019860 [x] Received 'helloworld.........9'
18019860 [x] Done
可以看到，第二個工作者至少丟失了6，8，10號任務，且4號任務未完成。

但是，我們不希望丟失任何任務（資訊）。當某個工作者（接收者）被殺死時，我們希望將任務傳遞給另一個工作者。
為了保證訊息永遠不會丟失，RabbitMQ支援訊息應答（message acknowledgments）。消費者傳送應答給RabbitMQ，告訴它資訊已經被接收和處理，然後RabbitMQ可以自由的進行資訊刪除。
如果消費者被殺死而沒有傳送應答，RabbitMQ會認為該資訊沒有被完全的處理，然後將會重新轉發給別的消費者。通過這種方式，你可以確認資訊不會被丟失，即使消者偶爾被殺死。
這種機制並沒有超時時間這麼一說，RabbitMQ只有在消費者連線斷開是重新轉發此資訊。如果消費者處理一個資訊需要耗費特別特別長的時間是允許的。
訊息應答預設是開啟的。上面的程式碼中我們通過顯示的設定autoAsk=true關閉了這種機制。下面我們修改程式碼（Work.java）：

boolean ack = false ; //開啟應答機制
channel.basicConsume(QUEUE_NAME, ack, consumer);
//另外需要在每次處理完成一個訊息後，手動傳送一次應答。
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);

完整修改後的Work.java

package com.zhy.rabbit._02_workqueue.ack;

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

public class Work
{
	//佇列名稱
	private final static String QUEUE_NAME = "workqueue";

	public static void main(String[] argv) throws java.io.IOException,
			java.lang.InterruptedException
	{
		//區分不同工作程序的輸出
		int hashCode = Work.class.hashCode();
		//建立連線和頻道
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("localhost");
		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);

		}

	}
}
測試：
我們把訊息數量改為5，然後先開啟兩個消費者（Work.java），然後傳送任務（NewTask.java），立即關閉一個消費者，觀察輸出：
[x] Sent 'helloworld.1'
[x] Sent 'helloworld..2'
[x] Sent 'helloworld...3'
[x] Sent 'helloworld....4'
[x] Sent 'helloworld.....5'

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

工作者1
31054905 [*] Waiting for messages. To exit press CTRL+C
31054905 [x] Received 'helloworld.1'
31054905 [x] Done
31054905 [x] Received 'helloworld...3'
31054905 [x] Done
31054905 [x] Received 'helloworld.....5'
31054905 [x] Done
31054905 [x] Received 'helloworld....4'
31054905 [x] Done

可以看到工作者2沒有完成的任務4，重新轉發給工作者1進行完成了。

3、 訊息持久化（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());
現在你可以執行一個傳送訊息的程式，然後關閉服務，再重新啟動服務，執行消費者程式做下實驗。

4、公平轉發（Fair dispatch）
或許會發現，目前的訊息轉發機制（Round-robin）並非是我們想要的。例如，這樣一種情況，對於兩個消費者，有一系列的任務，奇數任務特別耗時，而偶數任務卻很輕鬆，這樣造成一個消費者一直繁忙，另一個消費者卻很快執行完任務後等待。
造成這樣的原因是因為RabbitMQ僅僅是當訊息到達佇列進行轉發訊息。並不在乎有多少任務消費者並未傳遞一個應答給RabbitMQ。僅僅盲目轉發所有的奇數給一個消費者，偶數給另一個消費者。
為了解決這樣的問題，我們可以使用basicQos方法，傳遞引數為prefetchCount = 1。這樣告訴RabbitMQ不要在同一時間給一個消費者超過一條訊息。換句話說，只有在消費者空閒的時候會發送下一條資訊。
int prefetchCount = 1;
channel.basicQos(prefetchCount);
注：如果所有的工作者都處於繁忙狀態，你的佇列有可能被填充滿。你可能會觀察佇列的使用情況，然後增加工作者，或者使用別的什麼策略。
測試：改變傳送訊息的程式碼，將訊息末尾點數改為6-2個，然後首先開啟兩個工作者，接著傳送訊息：

[x] Sent 'helloworld......6'
[x] Sent 'helloworld.....5'
[x] Sent 'helloworld....4'
[x] Sent 'helloworld...3'
[x] Sent 'helloworld..2'

工作者1：
18019860 [*] Waiting for messages. To exit press CTRL+C
18019860 [x] Received 'helloworld......6'
18019860 [x] Done
18019860 [x] Received 'helloworld...3'
18019860 [x] Done

工作者2：
31054905 [*] Waiting for messages. To exit press CTRL+C
31054905 [x] Received 'helloworld.....5'
31054905 [x] Done
31054905 [x] Received 'helloworld....4'
31054905 [x] Done
31054905 [x] Received 'helloworld..2'
31054905 [x] Done

可以看出此時並沒有按照之前的Round-robin機制進行轉發訊息，而是當消費者不忙時進行轉發。且這種模式下支援動態增加消費者，因為訊息並沒有傳送出去，動態增加了消費者馬上投入工作。而預設的轉發機制會造成，即使動態增加了消費者，此時的訊息已經分配完畢，無法立即加入工作，即使有很多未完成的任務。


5、完整的程式碼

NewTask.java

package com.zhy.rabbit._02_workqueue.ackandpersistence;

import java.io.IOException;

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

public class NewTask
{
	// 佇列名稱
	private final static String QUEUE_NAME = "workqueue_persistence";

	public static void main(String[] args) throws IOException
	{
		// 建立連線和頻道
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("localhost");
		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 = 5; i > 0; 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();

	}

}

Work.java
package com.zhy.rabbit._02_workqueue.ackandpersistence;

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

public class Work
{
	// 佇列名稱
	private final static String QUEUE_NAME = "workqueue_persistence";

	public static void main(String[] argv) throws java.io.IOException,
			java.lang.InterruptedException
	{
		// 區分不同工作程序的輸出
		int hashCode = Work.class.hashCode();
		// 建立連線和頻道
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("localhost");
		Connection connection = factory.newConnection();
		Channel channel = connection.createChannel();
		// 宣告佇列
		boolean durable = true;
		channel.queueDeclare(QUEUE_NAME, durable, 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);
			channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);

		}

	}

	/**
	 * 每個點耗時1s
	 * 
	 * @param task
	 * @throws InterruptedException
	 */
	private static void doWork(String task) throws InterruptedException
	{
		for (char ch : task.toCharArray())
		{
			if (ch == '.')
				Thread.sleep(1000);
		}
	}
}





相關推薦

輕鬆搞定RabbitMQ（二）——工作佇列之訊息分發機制

       上一篇博文中簡單介紹了一下RabbitMQ的基礎知識，並寫了一個經典語言入門程式——HelloWorld。本篇博文中我們將會建立一個工作佇列用來在工作者（consumer）間分發耗時任務。同樣是翻譯的官網例項。 工作佇列        在前一篇博文中，我們完

RabbitMQ （二）工作佇列

本系列教程主要來自於官網入門教程的翻譯，然後自己進行了部分的修改與實驗，內容僅供參考。上一篇部落格中我們寫了通過一個命名的佇列傳送和接收訊息，如果你還不瞭解請點選：RabbitMQ 入門 Helloworld。這篇中我們將會建立一個工作佇列用來在工作者（consumer）間分

RabbitMQ入門（二）工作佇列

  在文章RabbitMQ入門（一）之Hello World，我們編寫程式通過指定的佇列來發送和接受訊息。在本文中，我們將會建立工作佇列（Work Queue）,通過多個workers來分配耗時任務。   工作佇列（Work Queue，也被成為Task Queue，任務佇列）的中心思想是，避免立即執行一個資

RabbitMQ（二） ——工作隊列

bin 生產 就是 發送 定時 順序 -h 預取 list RabbitMQ（二） ——工作隊列 （轉載請附上本文鏈接——linhxx） 一、概述 工作隊列模式（work queue），是有多個消費者的情況下，可以共同消費隊列內的內容，加快消息處理速度

機器學習（二）工作流程與模型調優

發生 較高的 mode lan 包含 因此 增加 絕對值 輸入 上一講中主要描述了機器學習特征工程的基本流程，其內容在這裏：機器學習（一）特征工程的基本流程 本次主要說明如下： 　　1）數據處理：此部分已經在上一節中詳細討論 　　2）特征工程：此部分已經在上一節中詳細討論

python采用pika庫使用rabbitmq（二） --工作隊列

col min pro red exc 理解 需要 color 工作者 消息也可以理解為任務，消息發送者可以理解為任務分配者，消息接收者可以理解為工作者，當工作者接收到一個任務，還沒完成的時候，任務分配者又發一個任務過來，那就忙不過來了，於是就需要多個工作者來共同處理這些

基於CentOS6.5使用RabbitMQ（二）

目錄 0、前言 1、啟動 2、使用者管理 3、角色管理 4、使用者許可權 0、前言 接上文《基於CentOS6.5安裝RabbitMQ》，完成了rabbitmq的安裝，接下里就是如何使用了。   1、啟動 註冊為服務，開機啟動 # chk

訊息中介軟體（二）訊息佇列常見的幾種使用場景介紹

一、訊息佇列概述 訊息佇列中介軟體是分散式系統中重要的元件，主要解決應用耦合，非同步訊息，流量削鋒等問題。實現高效能，高可用，可伸縮和最終一致性架構。是大型分散式系統不可缺少的中介軟體。 目前在生產環境，使用較多的訊息佇列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaM

學習之路-RabbitMQ（二）：Mac安裝RabbitMQ

1.安裝： RabbitMQ：brew install rabbitmq 2.RabbitMQ的安裝位置： /usr/local/Cellar/rabbitmq/3.7.9 3.配置環境變數： cd~ vi .bash_profile export RABBIT_HOME=/usr/loca

（轉）Libcap庫學習：：（二）工作原理

Libpcap工作原理介紹 Libpcap是Unix/Linux平臺下的網路資料包捕獲資料庫。它是一個獨立於系統的使用者級資料包捕獲API介面，為底層網路監測提供了一個可以移植的框架。 一個包捕獲機制包含三個主要部分，分別是面向底層的包捕獲引擎，面向中間層的資料包過濾器，面向應用

RabbitMQ（二）AMQP協議mandatory和immediate標誌位區別

mandatory和immediate是AMQP協議中basic.pulish方法中的兩個標誌位，它們都有當訊息傳遞過程中不可達目的地時將訊息返回給生產者的功能。具體區別在於： 1. mandatory標誌位 當mandatory標誌位設定為true時，如果exchange

2018年中總結（二）工作中遇到的問題（上）

年初在一家使用golang的公司待了一段時間，當時抱著一顆學習的心態試圖挑戰一下自己，結果因為自己基礎薄弱，能力不足，沒能堅持下去，但是卻學到了非常多的東西，是一段非常寶貴的工作經歷，這裡記錄一下在工作中遇到的奇奇怪怪的問題，儘量將具體的工作內容剝離出去，記錄問

訊息中介軟體Rabbitmq（二）-使用詳解

https://blog.csdn.net/Dante_003/article/details/79377908Rabbitmq 是基於amqp（高階訊息佇列協議）實現的佇列技術，在他之上可以完成多種型別的訊息轉發模型。 下面列舉一些常用的訊息轉發場景，在rabbitmq中是

RabbitMQ（二）：例項demo

1、Windows下RabbitMQ的安裝 下載Erlang，地址：http://www.erlang.org/download/otp_win32_R15B.exe ，雙擊安裝即可（首先裝） 下載RabbitMQ，地址：http://www.rabbitmq.com/re

.NET Core微服務 許可權系統+工作流（二）工作流系統

一、前言 　　接上一篇 .NET Core微服務 許可權系統+工作流（一）許可權系統 ，再來一發 　　工作流，我在接觸這塊開發的時候一直好奇它的實現方式，翻看各種工作流引擎程式碼，探究其實現方式，個人總結出來一個核心要點： 　　　　實際上工作流引擎處理流轉的核心要義是如何解析流轉XML或者JS

和朱曄一起復習Java併發（二）：佇列

和朱曄一起復習Java併發（二）：佇列 老樣子，我們還是從一些例子開始慢慢熟悉各種併發佇列。以看小說看故事的心態來學習不會顯得那麼枯燥而且更容易記憶深刻。 阻塞佇列的等待？ 阻塞佇列最適合做的事情就是做為生產消費者的中間儲存，以抵抗生產者消費者速率不匹配的問題，不但是在速率不匹配的時候能夠有地方暫存任務，而且

RabbitMQ（二）：RabbitMQ高階特性

RabbitMQ是目前非常熱門的一款訊息中介軟體，不管是網際網路大廠還是中小企業都在大量使用。作為一名合格的開發者，有必要了解一下相關知識，RabbitMQ（一）：RabbitMQ快速入門已經入門RabbitMQ，本文介紹RabbitMQ的高階特性。 過期時間（TTL） Time To Live，也就是生存時

訊息中介軟體——RabbitMQ（二）各大主流訊息中介軟體綜合對比介紹！

前言 訊息佇列已經逐漸成為企業IT系統內部通訊的核心手段。它具有低耦合、可靠投遞、廣播、流量控制、最終一致性等一系列功能，成為非同步RPC的主要手段之一。當今市面上有很多主流的訊息中介軟體，如老牌的ActiveMQ、RabbitMQ，炙手可熱的Kafka，阿里巴巴自主開發RocketMQ等。今天主要來

RabbitMQ指南之二：工作佇列（Work Queues）

在上一章的指南中，我們寫了一個命名佇列：生產者往該命名佇列傳送訊息、消費從從該命名佇列中消費訊息。在本章中，我們將建立一個工作佇列

RabbitMQ訊息佇列（二）：”Hello, World“

原文地址：http://blog.csdn.net/anzhsoft/article/details/19570187    本文將使用Python（pika 0.9.8）實現從Producer到Consumer傳遞資料”Hello, World“。      首先複習一下上篇所學：RabbitMQ實現