实现方法： Google面试题—有四个线程1、2、3、4。线程1的功能就是输出1，线程2的功能就是输出2，以此类推.........现在有四个文件ABCD

思想：

观察个文件的内容输出：

A：1 2 3 4 1 2 3 4 ...

B：2 3 4 1 2 3 4 1 ...

C：3 4 1 2 3 4 1 2 ...

D：4 1 2 3 4 1 2 3 ...

参考http://blog.csdn.net/lilien1010/article/details/8119325他的实现方法是规定4个线程的执行顺序

线程1 ---> 线程2 ---> 线程3 ---> 线程4 --->再到线程1 如此循环，第一次四个线程写文件的顺序是

A B C D，第二次四个线程写文件的顺序是 B C D A ，第三次写文件的顺序是 C D A B ，这种循环是通

过次句控制的：

但是我有一个考虑，感觉没有充分利用线程，因为4个线程是同步执行的即一次只能执行一个线程只写一个文件，而非异步执行即4个线程同时执行可写4个文件

因此我用另一种方法实现，已达到4个线程同时写4个文件的效果  通过规定每个线程写文件的顺序的方式：

            线程1写文件的顺序：A D C B A D C B ...

            线程2写文件的顺序：B A D C B A D C ...

            线程3写文件的顺序：C B A D C B A D ...

            线程4写文件的顺序：D C A B D C A B ...

现贴出未简化的代码，阅读时应该比较容易理解：

hA hB hC hD四个信号量分别用于实现A B C D四个文件的互斥，初始状态均为触发状态，每个线程写完当前文件后释放它的信号量，并等待下个要写入的文件的信号量被释放.

#include "stdafx.h"
#include <stdio.h>     
#include <process.h>     
#include <windows.h>   
#include <fstream>  
#include <string.h>  

using namespace std;
CRITICAL_SECTION g_cs;
HANDLE hA,hB,hC,hD;
ofstream oA,oB,oC,oD;
void SetConsolColor(WORD dw)
{
	HANDLE hstd = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleTextAttribute(hstd,dw);
}
unsigned WINAPI Thread1(void *p)
{
	int num = 0,loop = 24000;
	/*
		自由设定loop的大小，检测此方法是否正确，但要确保4个线程的循环次数是相同的,  
		因为次数不同，文件的内容就变了...
	*/  

	ofstream *oArray[4] = {&oA,&oD,&oC,&oB};
	HANDLE hArray[4] = {hA,hD,hC,hB};
	char ss[4] = {'A','D','C','B'};
	while(loop--)
	{		
		int xxx = num % 4;
		WaitForSingleObject(hArray[xxx],INFINITE);	
		EnterCriticalSection(&g_cs);
		SetConsolColor(FOREGROUND_RED);
		printf("线程1写%c文件\n",ss[xxx]);		
		LeaveCriticalSection(&g_cs);
		*(oArray[num]) << 1;
		ReleaseSemaphore(hArray[xxx],1,NULL);
		num = (num + 1) % 4;
	}
	return 0;
}

unsigned WINAPI Thread2(void *p)
{
	int num = 0,loop = 24000;
	ofstream *oArray[4] = {&oB,&oA,&oD,&oC};
	HANDLE hArray[4] = {hB,hA,hD,hC};
	char ss[4] = {'B','A','D','C'};
	while(loop--)
	{		
		int xxx = num % 4;
		WaitForSingleObject(hArray[xxx],INFINITE);		
		EnterCriticalSection(&g_cs);
		SetConsolColor(FOREGROUND_GREEN);
		printf("线程2写%c文件\n",ss[xxx]);
		LeaveCriticalSection(&g_cs);
		*(oArray[num] )<< 2;
		ReleaseSemaphore(hArray[xxx],1,NULL);
		num = (num + 1) % 4;
	}
	return 0;
}

unsigned WINAPI Thread3(void *p)
{
	int num = 0,loop = 24000;
	ofstream *oArray[4] = {&oC,&oB,&oA,&oD};
	HANDLE hArray[4] = {hC,hB,hA,hD};
	char ss[4] = {'C','B','A','D'};
	while(loop--)
	{		
		int xxx = num % 4;
		WaitForSingleObject(hArray[xxx],INFINITE);	
		EnterCriticalSection(&g_cs);
		SetConsolColor(FOREGROUND_RED|FOREGROUND_GREEN);
		printf("线程3写%c文件\n",ss[xxx]);
		LeaveCriticalSection(&g_cs);
		*(oArray[num]) << 3;
		ReleaseSemaphore(hArray[xxx],1,NULL);
		num = (num + 1) % 4;
	}
	return 0;
}

unsigned WINAPI Thread4(void *p)
{
	int num = 0,loop = 24000;
	ofstream *oArray[4] = {&oD,&oC,&oB,&oA};
	HANDLE hArray[4] = {hD,hC,hB,hA};
	char ss[4] = {'D','C','B','A'};
	while(loop--)
	{		
		int xxx = num % 4;
		WaitForSingleObject(hArray[xxx],INFINITE);
		EnterCriticalSection(&g_cs);
		SetConsolColor(FOREGROUND_RED|FOREGROUND_BLUE);
		printf("线程4写%c文件\n",ss[xxx]);
		LeaveCriticalSection(&g_cs);
		*(oArray[num]) << 4;
		ReleaseSemaphore(hArray[xxx],1,NULL);
		num = (num + 1) % 4;
	}
	return 0;
}

int main()
{
	InitializeCriticalSection(&g_cs);
	hA = CreateSemaphore(NULL,1,1,NULL);
	hB = CreateSemaphore(NULL,1,1,NULL);
	hC = CreateSemaphore(NULL,1,1,NULL);
	hD = CreateSemaphore(NULL,1,1,NULL);

	oA.open("A.txt",ios::trunc);
	oB.open("B.txt",ios::trunc);
	oC.open("C.txt",ios::trunc);
	oD.open("D.txt",ios::trunc);

	HANDLE hThread[4];

	hThread[0] = (HANDLE)_beginthreadex(NULL,0,Thread1,NULL,0,NULL);
	hThread[1] = (HANDLE)_beginthreadex(NULL,0,Thread2,NULL,0,NULL);
	hThread[2] = (HANDLE)_beginthreadex(NULL,0,Thread3,NULL,0,NULL);
	hThread[3] = (HANDLE)_beginthreadex(NULL,0,Thread4,NULL,0,NULL);

	WaitForMultipleObjects(4,hThread,TRUE,INFINITE);
	DeleteCriticalSection(&g_cs);

	CloseHandle(hThread[0]);
	CloseHandle(hThread[1]);
	CloseHandle(hThread[2]);
	CloseHandle(hThread[3]);

	oA.close();
	oB.close();
	oC.close();
	oD.close();

	system("pause");
}