有四个线程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….
请设计程序。

先试着写出四个线程交替写入A文件

public class FourThreadOneFile  
{
    public static FILE file = new FILE();

    public static void main(String[] args) 
    {
        System.out.println("Hello World!");
        ExecutorService executors = Executors.newFixedThreadPool(5);
        executors.execute(new PrintTask(1));
        executors.execute(new PrintTask(2));
        executors.execute(new PrintTask(3));
        executors.execute(new PrintTask(4));
        executors.shutdown();
    }
    static class PrintTask implements Runnable
    {
        private int id = 0;
        public PrintTask(int id){
            this.id = id;
        }
        public void run(){
            while(true){
                file.print(id);
            }
        }
    }
}

class FILE
{
    //private static Lock = new ReentrantLock();
    private static int state = 0;
    private static PrintWriter out;

    public FILE(){
        try{
            out = new PrintWriter("A.txt");
        }catch(Exception fileNotFound){

        }
    }

    public static synchronized void  print(int id) {
        if(state == (id - 1)){
            try{
                out.print(id);
                System.out.println(id);
                Thread.sleep(1000);
            }catch(InterruptedException ex1){

            }finally{
                //刷新缓冲区
                out.flush();
            }
            state++;
            if(state == 4){
                out.println();
                state = 0;
            }
        }
    }
}

扩展到四个文件

为任务类指定id和name
id表示打印的顺序
name表示打印时打印的字符

id需要根据情况在文件类里时刻调整顺序

public class FourThreadFourFile  
{
    public static FILE file = new FILE();

    public static void main(String[] args) throws Exception
    {
        System.out.println("Hello World!");
        PrintWriter o = new PrintWriter("B");
        o.println("hello");
        o.close();
        ExecutorService executors = Executors.newFixedThreadPool(5);
        executors.execute(new PrintTask(1,"1"));
        executors.execute(new PrintTask(2,"2"));
        executors.execute(new PrintTask(3,"3"));
        executors.execute(new PrintTask(4,"4"));
        executors.shutdown();
    }
    public static class PrintTask implements Runnable
    {
        private int id = 0;
        public String name;
        public PrintTask(int id,String name){
            this.id = id;
            this.name = name;
        }
        public void run(){
            while(true){
                file.printFile(id,this);
            }
        }
    }
}

class FILE
{
    //private static Lock = new ReentrantLock();
    //代表需要打印的数
    private static int state = 0;
    //选择操作文件
    //0---A
    //1---B
    //2---C
    //3---D
    private static int select = 0; 
    private static PrintWriter outA;
    private static PrintWriter outB;
    private static PrintWriter outC;
    private static PrintWriter outD;

    private static PrintWriter out;
    public FILE(){
        try{
            outA = new PrintWriter("A.txt");
            outB = new PrintWriter("B.txt");
            outC = new PrintWriter("C.txt");
            outD = new PrintWriter("D.txt");

        }catch(Exception fileNotFound){

        }
    }
    public static synchronized void printFile(int id,FourThreadFourFile.PrintTask pt){
        switch(select){
            case 0:
                out = outA;
                print(id,pt);
                break;
            case 1:
                out = outB;
                //调整id
                id = id - 1;
                if(id <= 0){
                    id += 4; 
                }
                print(id,pt);
                break;
            case 2:
                out = outC;
                //调整id
                id = id - 2;
                if(id <= 0){
                    id += 4; 
                }
                print(id,pt);
                break;
            case 3:
                out = outD;
                id = id - 3;
                //调整id
                if(id <= 0){
                    id += 4; 
                }
                print(id,pt);
                break;
        }

    }

    public static synchronized void  print(int id,FourThreadFourFile.PrintTask pt) {
        if(state == (id - 1)){
            try{
                out.print(pt.name);
                System.out.println((char)('A'+select)+"-----" + pt.name);
                Thread.sleep(1000);
            }catch(InterruptedException ex1){

            }finally{
                //刷新缓冲区
                out.flush();
            }
            state++;
            if(state == 4){
                out.println();
                state = 0;
                select++;
                if(select == 4){
                    select = 0;
                }
            }
        }
    }
}

思想：

观察个文件的内容输出：

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");
}

（Google面试题）有四个线程1、2、3、4。线程1的功能就是输出1，线程2的功能就是输出2，以此类推.........现在有四个文件ABCD。初始都为空。

 1 #include <iostream>
 2 #include <stdlib.h>
 3 #include <pthread.h>
 4 using namespace std;
 5 
 6 pthread_mutex_t myloack=PTHREAD_MUTEX_INITIALIZER;
 7 pthread_cond_t mycond=PTHREAD_COND_INITIALIZER;
 8 int n=0;
 9 void *ThreadFunc(void *arg)
10 {
11     int num=(int )arg;
12     for (int i = 0; i < 10; ++i)
13     {
14         pthread_mutex_lock(&myloack);
15         while (n!=num)
16             pthread_cond_wait(&mycond,&myloack);
17 
18         if (num==0)
19             cout<<"1";
20         else if(num==1)
21             cout<<"2";
22         else if(num==2)
23             cout<<"3";
24         else 
25             cout<<"4"<<endl;
26         n=(n+1)%4;
27         pthread_mutex_unlock(&myloack);
28         pthread_cond_broadcast(&mycond);
29     }
30     return (void *)0;
31 }
32 
33 int  main(int argc, char const *argv[])
34 {
35 
36     pthread_t id[4];
37     for (int i = 0; i < 4; ++i)
38     {
39         int err=pthread_create(&id[i],NULL,ThreadFunc,(void *)i);
40         if (err!=0)
41         {
42             cout<<"create err:"<<endl;
43             exit(-1);
44         }
45 
46     }
47 
48     for (int i = 0; i < 4; ++i)
49     {
50         int ret=pthread_join(id[i],NULL);
51         if (ret!=0)
52         {
53             cout<<"join err:"<<endl;
54             exit(-1);
55         }
56     }
57     return 0;
58 }