（大部分内容也是摘自网络，整理一下 供自己收藏，也可以给大家看一下）。
主要是使用event事件实现线程的同步。在新建工程若编译出现问题，修改：工程-》设置-》C/C++-》use run-time library:选择DebugMultiThreaded
第1题（某培训机构的练习题）：
子线程循环 10 次，接着主线程循环 100 次，接着又回到子线程循环 10 次，接着再回到主线程又循环 100 次，如此循环50次，试写出代码。

第2题（迅雷笔试题）：
编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推。

第3题（Google面试题）
有四个线程1、2、3、4。线程1的功能就是输出1，线程2的功能就是输出2，以此类推………现在有四个文件ABCD。初始都为空。现要让四个文件呈如下格式：
A：1 2 3 4 1 2….
B：2 3 4 1 2 3….
C：3 4 1 2 3 4….
D：4 1 2 3 4 1….
请设计程序。

/*************************************************************************
    > File Name: multiThread.cpp
    > Author:zc 
    > Mail: zhangchuan402@gamil.com
    > Created Time: 2016年04月17日 星期日 00时50分42秒
 ************************************************************************/
//经典线程同步互斥问题  
#include <stdio.h>  
#include <process.h>  
#include <windows.h> 
#include <iostream>
#include <fstream>
using namespace std;

//problem 1
unsigned int __stdcall Fun1(void *pPM);  
const int THREAD_NUM = 1;  

//循环次数
const int LOOP = 50;

//两个互斥事件,使用事件对象实现
HANDLE g_hThreadEvent1;
HANDLE g_hThreadEvent2;

//problem 2
unsigned int __stdcall Fun2_1(void *pPM);

const int THREAD_NUM_2 = 3;  
const int LOOP2 = 10;
HANDLE g_hThreadEventProblem2[THREAD_NUM_2];

//problem 3
unsigned int __stdcall Fun3(void *pPM); 
//线程个数  
const int THREAD_NUM_3 = 4;  
const int FILE_NUM = 4;  
HANDLE g_hThreadEventProblem3[THREAD_NUM_3];
ofstream ofile[FILE_NUM];  
//某个线程的下一个要写的文件  
int FILE_THREAD[FILE_NUM]={0,1,2,3};  
int NEXT_LOOP[FILE_NUM]={0,1,2,3,};  

//临界区对象
CRITICAL_SECTION g_csFile;  
//循环次数  
const int LOOP3 = 16; 

int main()  
{  

    int i = 0;
    int j = 0;

    cout<<"多线程笔试题汇总"<<endl;
    cout<<"1. 子线程循环 10 次，接着主线程循环 100 次，接着又回到子线程循环 10 次，接着再回到主线程又循环 100 次，如此循环50次"<<endl;

    cout<<"2. 编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推"<<endl;

    cout<<"3. 有四个线程1、2、3、4。线程1的功能就是输出1，线程2的功能就是输出2，现在有四个文件ABCD,现要让四个文件呈如下格式：n1 2 3 4 1 2....n2 3 4 1 2 3....n3 4 1 2 3 4....n4 1 2 3 4 1...."<<endl;

    int caseNum = 0;

    while (1)
    {

    cout<<"inputnum:"<<endl;
    cin>>caseNum;

    HANDLE hdl[THREAD_NUM];
    HANDLE hdl2[THREAD_NUM_2]; 
    HANDLE hdl3[THREAD_NUM_3];

    char FILE_THREAD[] ="A.txt";  

    for (i = 0; i < FILE_NUM; i++)   
    {  

        FILE_THREAD[0] = i + 'A';  
        ofile[i].open(FILE_THREAD,ios::trunc);  

        if(ofile[i].fail())  
        {  
                printf("打开文件%s 失败",FILE_THREAD);  
                continue;  
        }  
    }  
    switch (caseNum)
    {
        case 1:

            printf("t子线程循环 10 次，接着主线程循环 100 次，接着又回到子线程循环10 次，n接着再回到主线程又循环 100 次，如此循环50次n");          



            g_hThreadEvent1 = CreateEvent(NULL,FALSE,FALSE,NULL);
            g_hThreadEvent2 = CreateEvent(NULL,FALSE,TRUE,NULL);


            hdl[0] = (HANDLE)_beginthreadex(NULL,0,Fun1,NULL,0,NULL);



            for( i = 0 ; i < LOOP; i++)
            {
                WaitForSingleObject(g_hThreadEvent1,INFINITE);

                for(j = 0 ; j<100; j++)
                {
                    printf(" 主要线程编号是%d ,在循环第 %d 次n",GetCurrentThreadId(), j+1);     
                }
                SetEvent(g_hThreadEvent2);
                Sleep(200);

            }

            CloseHandle(g_hThreadEvent2);  
            CloseHandle(g_hThreadEvent1); 

            for (i = 0; i < THREAD_NUM; i++)  
                CloseHandle(hdl[i]);  

             break;
        case 2:

            printf("开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示n");  


            for (i = 0; i < THREAD_NUM_2; i++)   
                g_hThreadEventProblem2[i] = CreateEvent(NULL,FALSE,FALSE,NULL);  

            //将线程编号作为线程参数传进去，先转换为指针，再转换为整形，  
            for (i = 0; i < THREAD_NUM_2; i++)   
                hdl2[i] = (HANDLE)_beginthreadex(NULL,0,Fun2_1,(void*)i,0,NULL);  

            SetEvent(g_hThreadEventProblem2[0] );  

            WaitForMultipleObjects(THREAD_NUM_2,hdl2,TRUE,INFINITE);  

            for (i = 0; i < THREAD_NUM_2; i++)  
            {  
                CloseHandle(hdl2[i]);  
                CloseHandle(g_hThreadEventProblem2[i]);  
            }  
            break;
        case 3:
            printf("t有四个线程1、2、3、4。线程1的功能就是输出1，线程2的功能就是输出2n");  
            printf("以此类推.........现在有四个文件ABCD。初始都为空。现要让四个文件呈如下格式n");  

            InitializeCriticalSection(&g_csFile);  

            //事件开启的时候是没有触发的  
            for (i = 0; i < THREAD_NUM_3; i++)   
                g_hThreadEventProblem3[i] = CreateEvent(NULL,FALSE,FALSE,NULL);  

            //将线程编号作为线程参数传进去，先转换为指针，再转换为整形，  



            for (i = 0; i < THREAD_NUM_3; i++)   
                hdl3[i] = (HANDLE)_beginthreadex(NULL,0,Fun3,(void*)i,0,NULL);  


            //触发第一个线程，线程函数会按顺序自己触发下一个要执行的线程  
            SetEvent( g_hThreadEventProblem3[0] );  


            WaitForMultipleObjects(THREAD_NUM_3,hdl3,TRUE,INFINITE);  

            //清理  
            for (i = 0; i < THREAD_NUM_3; i++)  
            {  
                CloseHandle(hdl3[i]);  
                CloseHandle(g_hThreadEventProblem3[i]);  
            }  

            for( i  = 0 ; i< FILE_NUM;i++)  
            {  
                ofile[i].close();  
            }  
             DeleteCriticalSection(&g_csFile);  
            break;
        case 4:

            break;
        case 5:


            break;
        case 6:


            break;
        case 7:


            break;

    }

    }//while loop

    return 0;  
}  

unsigned int __stdcall Fun1(void *pPM)
{
    int num = 0;
    int i = 0;

    for( i  = 0 ; i< LOOP;i++)
    {
        WaitForSingleObject(g_hThreadEvent2,INFINITE);

        for(num = 0;num < 10 ; num++)
        {
            printf("  线程编号是 %d ,在循环第 %d 次n",GetCurrentThreadId(),num+1);    
        }

        SetEvent(g_hThreadEvent1);
    }
    return 0;
}

//problem 2
unsigned int __stdcall Fun2_1(void *pPM)
{
    int num = (int)pPM;  
    int i = 0;  

    for( i  = 0 ; i< LOOP;i++)  
    {  
        WaitForSingleObject(g_hThreadEventProblem2[num],INFINITE);  

        printf(" %c ",num+'A');  

        if(num+1 == THREAD_NUM_2 )  
        {
            //printf(" n");  
        }

        SetEvent(g_hThreadEventProblem2[(num+1)%THREAD_NUM_2]);  
    }  
    return 0;
}


//problem 3
unsigned int __stdcall Fun3(void *pPM)  
{  

    int num = (int)pPM ;  
    int i = 0;  
    for( i  = 0 ; i< LOOP3;i++)  
    {  
        //等待顺序触发  
        WaitForSingleObject(g_hThreadEventProblem3[num],INFINITE);        

        EnterCriticalSection(&g_csFile);  

        printf("  线程 %d 正在向%c文件写入，下一次对文件%c操作的是线程%dn",  
            num + 1 , FILE_THREAD[num] + 'A',FILE_THREAD[num] + 'A',(num+1)%(THREAD_NUM_3) +1);  

        ofile[FILE_THREAD[num]]<<num+1<<" ";  

        Sleep(200);  

        //记录下一轮对应序号要操作的文件， (num+1)%(FILE_NUM) 事件对应的线程，操作文件FILE_THREAD[num]  
        NEXT_LOOP[ (num+1)%(THREAD_NUM_3) ] = FILE_THREAD[num] ;  

        if( num + 1 == THREAD_NUM_3)  
        {  
            printf("n");  
            //本轮写入结束，将计算好的下一轮文件操作顺序取过来  
            memcpy(&FILE_THREAD,&NEXT_LOOP,THREAD_NUM_3 *sizeof(int));  
        }  

        LeaveCriticalSection(&g_csFile);       

        //触发下一个线程，1触发2 ，2触发3，3触发4，4触发1  
        SetEvent(g_hThreadEventProblem3[(num+1)%THREAD_NUM_3 ]);  
    }  
    return 0;  
} 

运行结果：

欢迎评论。
工程下载见我的资源http://download.csdn.net/detail/neo_qiye/9493770。