双线程高效下载问题

一.问题描述和分析

问题描述：

       双线程高效下载的过程为：程序不断的从网络中读取数据，写到缓冲区(即内存)中，然后再从缓冲区写到磁盘中。这是一个串行执行的过程。

分析：

        生产者-消费者问题的思想为：生产者不断地往缓冲区生产数据，消费者不断从缓冲区中消费数据。

        该问题符合用生产者-消费者问题，程序的一部分功能负责从网络读取数据，写到缓冲区中，该为生产者；程序的另一部分功能负责从缓冲区读取数据，写道本地磁盘中，该为消费者。

       我们可以将这两部分串行的功能，通过两个线程实现并行化，一个线程实现生产者的功能，另一个线程实现消费者的功能。这里还需要设置两个信号量：一个“空信号量，即该位置为空”的信号量；一个“满信号量，即该位置已有数据”的信号量。

二.伪代码实现如下：

类的声明如下：

//类的声明如下
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个动作并行做，一个线程负责一个动作，以此实现多线程。