精华内容
下载资源
问答
  • 2016-12-04 20:20:52

    现在有四个文件ABCD。初始都为空。现要让四个文件呈如下格式:

    A1 2 3 4 1 2....

    B2 3 4 1 2 3....

    C3 4 1 2 3 4....

    D4 1 2 3 4 1....

    /*threadA.c*/
    #include <stdio.h>
    #include <stdlib.h>
    #include <pthread.h>
    #define NUM 4
    
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    
    int n = 0;
    
    void *thread_func(void *argv)
    {
    	int p = (int)argv;
    	int i;
    
    	for(i = 0; i < 10; i++)
    	{
    		pthread_mutex_lock(&mutex);
    		while(p != n)
    		{
    			pthread_cond_wait(&cond,&mutex);
    		}
    		printf("%d ",p+1);
    		n= (n + 1) % NUM;
    		pthread_mutex_unlock(&mutex);
    		pthread_cond_broadcast(&cond);
    	}
    }
    int main()
    {
    	pthread_t tid[NUM];
    	int ret;
    	int i;
    
    	pthread_mutex_init(&mutex,NULL);
    	pthread_cond_init(&cond,NULL);
    
    	for(i = 0; i< NUM; i++)
    	{
    		ret = pthread_create(&tid[i],NULL,thread_func,(void *)i);
    		if(ret == -1)
    		{
    			printf("pthread_create pid[%d] error!\n",i);
    			exit(-1);
    		}
    	}
    
    	for(i = 0; i < NUM; i++)
    	{
    		ret = pthread_join(tid[i],NULL);
    		if(ret == -1)
    		{
    			printf("pthread_join pid[%d] error!\n",i);
    			exit(-1);
    		}
    	}
    	printf("\n");
        return 0;
    }
    B,C,,D文件里分别把全局变量n改为1,2,3。

    更多相关内容
  • 线程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…. 请设计程序。先试着写出...

    有四个线程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个线程...

    思想:

    观察个文件的内容输出:

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

    展开全文
  • 线程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....
    

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

    现要让四个文件呈如下格式:

    A1 2 3 4 1 2....

    B2 3 4 1 2 3....

    C3 4 1 2 3 4....

    D4 1 2 3 4 1....

    请设计程序。

     

    下面举例A,对于B、C、D只是需要把修改一下全局变量n的初始化值即可:

     

     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 }
    展开全文
  • //因为多个线程共用一条件变量,所以在田间变量被signal后,需要用while来确定是否本线程获得执行权 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 ...
  • 有四个线程1234线程1功能就是输出1线程2功能就是输出2以此类推.........  现在有四个文件A B C D, 初始都为空。现要让四个文件呈如下格式: A:1 2 3 4 1 2.... B:2 3 4 1 2 3.... C:3 ...
  • 线程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…. 请设计...
  • 线程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....请设计...
  • 线程功能

    2013-09-01 09:57:29
    用窗体创建线程的启动计算11百万的值,可以暂停、恢复(点击一次只能恢复一个线程)、终止
  • 线程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: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,对于B、C、D
  • java3个线程轮流输出1,2,3,4,5...75

    千次阅读 2018-01-18 17:17:47
    启动3个线程打印递增的数字, 线程1先打印1,2,3,4,5, 然后是线程2打印6,7,8,9,10, 然后是线程3打印11,12,13,14,15. 接着再由线程1打印16,17,18,19,20….以此类推, 直到打印到75.  其实这里可以在每个线程中...
  • 个线程 t1,t2,t3,怎么确保它们按顺序执行
  • 启动3个线程打印递增的数字, 线程1先打印1,2,3,4,5, 然后是线程2打印6,7,8,9,10, 然后是线程3打印11,12,13,14,15. 接着再由线程1打印16,17,18,19,20….以此类推, 直到打印到75. 代码实现: class MyThread ...
  • 研究了一下Reentrantlock在并发过程中的使用,下面是实现三个线程按顺序输出1,2,3: import java.util.concurrent.locks.ReentrantLock; /** * 标题、简要说明. * 类详细说明. * * Copyright: ...
  • 个人记录:2018年,工作的第6到7年头。重点研究自己不太擅长的技术:...题目:有3个线程ABC。按照ABC来运行(A线程输出A,B线程输出B,C线程输出C,以此类推,循环输出)。实现方法1: 有个网友给了点提示:用 Re...
  • 有3个线程ABC。按照ABC来运行(A线程输出A,B线程输出B,C线程输出C,以此类推,循环输出)。就是线程之间的协作。请问咋做呢?这种情况是只用一锁来实现可以吗?问题出处:http://ifeve.com/question/%e6%9c...
  • #include #include #include #include int i=0, a=0, b=0, c=0; void* A() { while(i) { while(a!=0); while(i>=10); printf("A"); a=1; b=0; } } v
  • C#线程会合实例

    2020-12-22 17:17:41
    这样一个题目:线程t1,t2,t3,t4,向4个文件中写入数据,要求:t1只能写入“1”,t2只能写入“2”,t3只能写入“3”,t4只能写入“4”,对4个文件A,B,C,D写入如下内容:  A:123412341234…..  B:...
  • 1:启动3个线程打印递增的数字, 线程1先打印1,2,3,4,5, 然后是线程2打印6,7,8,9,10, 然后是线程3打印11,12,13,14,15. 接着再由线程1打印16,17,18,19,20....以此类推, 直到打印到75. 程序的输出结果应该为: 线程1: 1...
  • 01编写10个线程,第一个线程1加到10,第二个线程从11加20…第十个线程从91加到100,最后再把10个线程结果相加(递归算法)。 要求很明了:就是要求10个线程,每个线程执行加操作,然后顺序执行!这里我采用的方法...
  •  * 一关于线程的经典面试题,要求用三个线程,按顺序打印1,2,3,4,5.... 71,72,73,74, 75. 线程1先打印1,2,3,4,5,  * 然后是线程2打印6,7,8,9,10, 然后是线程3打印11,12,13,14,15. 接着再由线程1打印16,17,18,19,...
  • 1 callable和future ...一般情况,我们实现多线程都是Thread或者Runnable(后者比较多),但是,这两种都是没返回值的,所以我们需要使用callable(返回值的多线程)和future(获得线程的返回值)来实现了。 pu
  • 1:启动3个线程打印递增的数字, 线程1先打印1,2,3,4,5, 然后是线程2打印6,7,8,9,10, 然后是线程3打印11,12,13,14,15. 接着再由线程1打印16,17,18,19,20…以此类推, 直到打印到75. 程序的输出结果应该为: 线程1: 1 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,526
精华内容 12,610
关键字:

有四个线程1、2、3、4。线程1的功能就是输出1,线程2的功能就是输出2,以此类推....