一.問題描述和分析

問題描述：

       雙執行緒高效下載的過程為：程式不斷的從網路中讀取資料，寫到緩衝區(即記憶體)中，然後再從緩衝區寫到磁碟中。這是一個序列執行的過程。

分析：

        生產者-消費者問題的思想為：生產者不斷地往緩衝區生產資料，消費者不斷從緩衝區中消費資料。

        該問題符合用生產者-消費者問題，程式的一部分功能負責從網路讀取資料，寫到緩衝區中，該為生產者；程式的另一部分功能負責從緩衝區讀取資料，寫道本地磁碟中，該為消費者。

       我們可以將這兩部分序列的功能，通過兩個執行緒實現並行化，一個執行緒實現生產者的功能，另一個執行緒實現消費者的功能。這裡還需要設定兩個訊號量：一個“空訊號量，即該位置為空”的訊號量；一個“滿訊號量，即該位置已有資料”的訊號量。

二.虛擬碼實現如下：

類的宣告如下：

//類的宣告如下
class Thread
{
public:
	Thread(void(*work_func)());  //該執行緒執行的函式為work_func
    ~Thread();
	void start(); //啟動執行緒
	void abort(); //終止執行緒
};

class Semaphore
{
public:
	Semaphore(int count,int max_count);//表示訊號量初始值為count，訊號量的最大值為max_count
    ~Semaphore();
	void Signal();  //count++  訊號量加一
	void Unsignal(); //count--  訊號量減一
};

class Mutex  //互斥鎖
{
public:
	WaitMutex(); //加鎖
    ReleaseMutex(); //解鎖
};
 

主函式實現如下：

#define BUFFER_COUNT 100  //定義緩衝區大小
Block g_buffer[BUFFER_COUNT]; //定義緩衝區
Thread g_threadA(PROCA); //定義執行緒A，其執行函式為PROCA
Thread g_threadB(PROCB); //定義執行緒B，其執行函式為PROCB

//由於緩衝區初始為空，所以滿訊號量g_seFull初始為0，空訊號量g_seEmpty初始為緩衝區大小BUFFER_COUNT
Semaphore g_seFull(0,BUFFER_COUNT); //定義訊號量g_seFull,初始值為0，最大為BUFFER_COUNT
Semaphore g_seEmpty(BUFFER_COUNT,BUFFER_COUNT);//定義訊號量g_seEmpty,其初始值為BUFFER_COUNT,最大值為BUFFER_COUNT

bool g_downloadComplete; //定義從網路下載是否完成

int in_index; //生產者的指標
int out_index; //消費者的指標

void main()
{
	g_downloadComplete = false;
	threadA.start();
	threadB.start();
}

//生產者，往緩衝區寫資料
void PROCA()
{
	while(true)
	{
		g_seEmpty.Unsignal();//消費掉一個空區域，g_seEmpty訊號量減一
		g_downloadComplete = GetBlockFromNet(g_buffer + in_index); //從網路讀取資料，並存放到緩衝區中
		in_index = (in_index + 1) % BUFFER_COUNT;  
		g_seFull.Signal();  //生產一個滿區域，g_seFull訊號量加一
		if(g_downloadComplete) break;
	}
}

//消費者，從緩衝區取資料
void PROCB()
{
	while(true)
	{
		g_seFull.Unsignal();  //消費掉一個滿區域，g_seFull訊號量減一
		WriteBlockToDisk(g_buffer + out_index);
		out_index  = (out_index + 1) % BUFFER_COUNT;
		g_seEmpty.Sigal();  //生產一個空區域，g_seEmpty訊號量加一
        if(g_downloadComplete && out_index == in_index)  //下載完成，並且緩衝區已為空，則推出
			break;
	}
}
 

三.總結

       如果一個程式是由K個序列的動作執行的，可以將這k個動作並行做，一個執行緒負責一個動作，以此實現多執行緒。