实现方法： 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");
}