Linux线程间如何通信

时间：2022-05-01 16:15:28
现在有两个linux线程：
       1）监控线程，检测从串口接收到的数据是否发生明显变化；2）USB摄像头采集线程；
要求实现的功能：
       当从串口接收到的数据未发生明显变化，USB摄像头持续采集视频；一旦接收到的数据发生明显变化，则USB摄像头停止采集，直到串口接收到的数据恢复正常。
请问：
           1） 两个线程间如何通信呢？2）若串口接收到的数据为16bit 16进制数据（如当前为0X00 0X02，前一时刻为0XFF 0XFE）如何判断是否发生明显变化（假设阈值为100（10进制数））？
         

12 个解决方案

#1

线程间通讯的话，如果你要求不高，用全局变量之类的就行，也可以man pthread，看看里面的pthread_cond_signal、pthread_cond_wait，或者信号量sem这些也是可以的。

#2

引用
线程间通讯的话，如果你要求不高，用全局变量之类的就行，也可以man pthread，看看里面的pthread_cond_signal、pthread_cond_wait，或者信号量sem这些也是可以的。

     感谢提供思路，现在在学习这方面的东西了，在http://www.ibm.com/developerworks/cn/linux/l-cn-mthreadps/中整理了一段这样的代码： 
#include <pthread.h>

#include <stdio.h>

#include <stdlib.h>

#include <iostream>

using namespace std;

// 提示出租车到达的条件变量

pthread_cond_t taxiCond=PTHREAD_COND_INITIALIZER; 

// 同步锁

pthread_mutex_t taxiMutex=PTHREAD_MUTEX_INITIALIZER; 

// 旅客人数，初始为 0 

int travelerCount=0;

// 旅客到达等待出租车

void * traveler_arrive(void *name) 

{ 

	cout<<"Traveler: "<<(char *)name<<"needs a taxi now!"<<endl; 

	pthread_mutex_lock(&taxiMutex); 

	// 提示旅客人数增加

	travelerCount++; 

	pthread_cond_wait (&taxiCond, &taxiMutex); 

	pthread_mutex_unlock (&taxiMutex); 

	cout<<"Traveler: "<< (char *)name <<"now got a taxi!"<<endl; 

	pthread_exit( (void *)0 ); 

} 


 // 出租车到达

void * taxi_arrive(void *name) 

{ 

	cout<<"Taxi "<<(char *)name<<"arrives."<<endl;

	while(true) 

	{ 

        	pthread_mutex_lock(&taxiMutex); 

        	// 当发现已经有旅客在等待时，才触发条件变量

        	if(travelerCount>0) 

        	{ 

            		pthread_cond_signal(&taxiCond); 

            		pthread_mutex_unlock (&taxiMutex); 

            		break; 

        	} 

        	pthread_mutex_unlock (&taxiMutex); 

	} 

	pthread_exit( (void *)0 ); 

 }


int main() 

{

	pthread_t thread; 

	pthread_attr_t threadAttr; 

	pthread_attr_init(&threadAttr); 


	pthread_create(&thread, & threadAttr, taxi_arrive, (void *)("Jack")); 

	sleep(1); 

	pthread_create(&thread, &threadAttr, taxi_arrive, (void *)("Mike")); 

	sleep(1); 

	pthread_create(&thread, &threadAttr, traveler_arrive, (void *)("Susan")); 

	sleep(1); 

	return 0; 

 }

     请问：“Susan”到底上了谁的车？“Jack”还是“Mike”?怎么判断呢

#3

我觉得是都有可能。因为这里三个线程共享一个互斥锁，那么理论上三个thread都有可能先于其他两个获得互斥锁。因为代码中有sleep(1), 所以我们可以假设thread(jack)最先获取互斥锁可能性最大，那么thread(mike)和thread(susan)被阻塞，当thread(jack)释放互斥锁，thread(mike)和thread(susan)都有可能获得互斥锁。如果thread(mike)获得互斥锁，那么thread(susan),和thread(jack)继续等待。等thread(mike)释放互斥锁，如果thread(susan)获得互斥锁，全局变量traverlercount变为1，然后执行到pthread_cond_wait语句，立刻释放互斥锁并等待信号。这时候等待信号的thread(mike), thread(jack)都有机会或得互斥锁，谁获得互斥锁susan就会上哪辆车。
对于thread(mike)最先获得互斥锁的情况同上，如果是thread(susan)最先最先或得互斥锁，那么情况就是从traverlercount变为1开始，由thread（mike)和thread(jack）争抢互斥锁。
但是对于你贴出来的代码，我个人觉得还是有机会能够形成死锁，因为在thread(jack)或thread(mike)优先或得互斥锁的情况下，thread(susan）可能永远都无法获取互斥锁（因为始终有thread(jack)或者thread(mike)在和她抢）。
不过这里因为没有pthread_join()所以进程还是可以正常退出，那么所有死锁和线程都会随着进程结束而销毁。但是这又带来一个问题，就是进程main thread可能先于所有其他线程结束，而main thread里用到的是return而不是pthread_exit，这样就可能变成线程随着进程结束而*被销毁。
当然这段代码如果真的跑起来，可能可以正常执行，因为这里面加了sleep()，但是在你的机器上100%正确执行可能取到别人的机器上就完全不能正确执行。所以总的来说我觉得这段代码非常的不严谨。
另外推荐楼主看一个帖子，这上面就说的比较详细一些：http://www.ibm.com/developerworks/cn/linux/thread/posix_thread1/index.html
文章有三篇，都在这个网站上可以看到，随后作者还贴了一篇较为复杂的程序源码，我觉得很有用

#4

引用 3 楼 zuoyangding 的回复:

    非常感谢帮忙分析，能加QQ聊吗？982053351

#5

引用 3 楼 zuoyangding 的回复:

        能不能帮我对这个问题：
现在有两个linux线程：
       1）监控线程，检测从串口接收到的数据是否发生明显变化；2）USB摄像头采集线程；
要求实现的功能：
       当从串口接收到的数据未发生明显变化，USB摄像头持续采集视频；一旦接收到的数据发生明显变化，则USB摄像头停止采集，直到串口接收到的数据恢复正常。
       写一个大概的模板。初学，不知道怎么下手！谢啦

#6

引用 1 楼 9527 的回复:
线程间通讯的话，如果你要求不高，用全局变量之类的就行，也可以man pthread，看看里面的pthread_cond_signal、pthread_cond_wait，或者信号量sem这些也是可以的。

      能不能抽个时间帮我写个大致的模板呢？初学，很难下手啊！谢谢！

#7

引用 6 楼 anhuidaxue100 的回复:
Quote: 引用 1 楼 9527 的回复:

线程间通讯的话，如果你要求不高，用全局变量之类的就行，也可以man pthread，看看里面的pthread_cond_signal、pthread_cond_wait，或者信号量sem这些也是可以的。

      能不能抽个时间帮我写个大致的模板呢？初学，很难下手啊！谢谢！

我觉得楼主不用考虑太多了，你上面的代码我看了，实际应用中，很少会那么做，也就是说同样的线程函数，一般只有一个副本。你提到的上谁的车，这个楼上得朋友说的很对，我也认为上谁的车都有可能。你只需要注意一点cond在wait时时自动解锁和加锁的就行。对于你的应用：
1）串口监测线程接收数据，如果符合条件，设置一个全局变量为TRUE
2）USB摄像头采集线程循环的监测这个全局变量，如果为TRUE就停止
用不到cond，如果不放心，加上mutex就可以了
模板就不写了，能吵吵的就不动手 Linux线程间如何通信

#8

引用 7 楼 9527 的回复

      仅设置一个全局变量，程序运行时出现segment default，应该是摄像头采集线程出错。唉 Linux线程间如何通信

#9

引用 8 楼 anhuidaxue100 的回复:
Quote: 引用 7 楼 9527 的回复

      仅设置一个全局变量，程序运行时出现segment default，应该是摄像头采集线程出错。唉 Linux线程间如何通信

这个和你程序写法有关的，单纯一个boolean的全局变量不会造成这种问题

#10

全局数据区 +  同步变量（互斥锁，条件变量）

#11

引用 5 楼 anhuidaxue100 的回复:
Quote: 引用 3 楼 zuoyangding 的回复:

        能不能帮我对这个问题：
现在有两个linux线程：
       1）监控线程，检测从串口接收到的数据是否发生明显变化；2）USB摄像头采集线程；
要求实现的功能：
       当从串口接收到的数据未发生明显变化，USB摄像头持续采集视频；一旦接收到的数据发生明显变化，则USB摄像头停止采集，直到串口接收到的数据恢复正常。
       写一个大概的模板。初学，不知道怎么下手！谢啦

抱歉楼主， 我这两天都没看论坛。你是安徽大学的？额。。。不会是刘峰的学生吧。。。。。
我之前看别人的帖子有一个多线程的题目，我自己写了一个代码，我觉得你可以参考一下，因为比较简单，而且同时用到了互斥锁和条件信号。如果还有什么问题可以回复我
题目是：
1）有一int型全局变量g_Flag初始值为0；
  2）在主线称中起动线程1，打印“this is thread1”，并将g_Flag设置为1
  3）在主线称中启动线程2，打印“this is thread2”，并将g_Flag设置为2
  4）线程序1需要在线程2退出后才能退出
  5）主线程在检测到g_Flag从1变为2，或者从2变为1的时候退出

代码：
#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

pthread_t thread[2];
static pthread_mutex_t mutex;
static pthread_cond_t cond;
void* thread1(void*);
void* thread2(void*);
int g_Flag=0;

int main(){
int check1=0, check2=0;
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&cond, NULL);
printf("g_Flag=%d\n", g_Flag);
pthread_mutex_lock(&mutex); //make sure that mutex is locked if cond_wait get the mutex first
check1=pthread_create(&thread[0], NULL, thread1, NULL);
if (check1!=0){
fprintf(stderr, "Thread1 create failed\n");
exit(1);
}
check2=pthread_create(&thread[1], NULL, thread2, NULL);
if (check2!=0){
fprintf(stderr, "Thread2 create failed\n");
exit(2);
}
sleep(1);//test if the cond signal works well
pthread_cond_wait(&cond, &mutex);
printf("EXIT MAN THREAD\n");
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
return 0;
}

void* thread1(void* arg){
printf("This is thread1\n");
pthread_mutex_lock(&mutex);
if (g_Flag==2)
pthread_cond_signal(&cond);
g_Flag=1;
printf("g_Flag=%d\n", g_Flag);
pthread_mutex_unlock(&mutex);
pthread_join(thread[1], NULL);
printf("Exit thread1\n");
pthread_exit(NULL);
}

void* thread2(void* arg){
printf("This is thread2\n");
pthread_mutex_lock(&mutex);
if (g_Flag==1)
pthread_cond_signal(&cond);
g_Flag=2;
printf("g_Flag=%d\n", g_Flag);
pthread_mutex_unlock(&mutex);
printf("Exit thread2\n");
pthread_exit(NULL);
}

#12

引用 11 楼 zuoyangding 的回复:
Quote: 引用 5 楼 anhuidaxue100 的回复:

Quote: 引用 3 楼 zuoyangding 的回复:

        能不能帮我对这个问题：
现在有两个linux线程：
       1）监控线程，检测从串口接收到的数据是否发生明显变化；2）USB摄像头采集线程；
要求实现的功能：
       当从串口接收到的数据未发生明显变化，USB摄像头持续采集视频；一旦接收到的数据发生明显变化，则USB摄像头停止采集，直到串口接收到的数据恢复正常。
       写一个大概的模板。初学，不知道怎么下手！谢啦

抱歉楼主， 我这两天都没看论坛。你是安徽大学的？额。。。不会是刘峰的学生吧。。。。。
我之前看别人的帖子有一个多线程的题目，我自己写了一个代码，我觉得你可以参考一下，因为比较简单，而且同时用到了互斥锁和条件信号。如果还有什么问题可以回复我
题目是：
1）有一int型全局变量g_Flag初始值为0；
  2）在主线称中起动线程1，打印“this is thread1”，并将g_Flag设置为1
  3）在主线称中启动线程2，打印“this is thread2”，并将g_Flag设置为2
  4）线程序1需要在线程2退出后才能退出
  5）主线程在检测到g_Flag从1变为2，或者从2变为1的时候退出

代码：
#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

pthread_t thread[2];
static pthread_mutex_t mutex;
static pthread_cond_t cond;
void* thread1(void*);
void* thread2(void*);
int g_Flag=0;

int main(){
int check1=0, check2=0;
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&cond, NULL);
printf("g_Flag=%d\n", g_Flag);
pthread_mutex_lock(&mutex); //make sure that mutex is locked if cond_wait get the mutex first
check1=pthread_create(&thread[0], NULL, thread1, NULL);
if (check1!=0){
fprintf(stderr, "Thread1 create failed\n");
exit(1);
}
check2=pthread_create(&thread[1], NULL, thread2, NULL);
if (check2!=0){
fprintf(stderr, "Thread2 create failed\n");
exit(2);
}
sleep(1);//test if the cond signal works well
pthread_cond_wait(&cond, &mutex);
printf("EXIT MAN THREAD\n");
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
return 0;
}

void* thread1(void* arg){
printf("This is thread1\n");
pthread_mutex_lock(&mutex);
if (g_Flag==2)
pthread_cond_signal(&cond);
g_Flag=1;
printf("g_Flag=%d\n", g_Flag);
pthread_mutex_unlock(&mutex);
pthread_join(thread[1], NULL);
printf("Exit thread1\n");
pthread_exit(NULL);
}

void* thread2(void* arg){
printf("This is thread2\n");
pthread_mutex_lock(&mutex);
if (g_Flag==1)
pthread_cond_signal(&cond);
g_Flag=2;
printf("g_Flag=%d\n", g_Flag);
pthread_mutex_unlock(&mutex);
printf("Exit thread2\n");
pthread_exit(NULL);
}

         我是安大毕业生，谢谢你的回复（你也是安大的？），我的东西做出来了，实现思路和你的基本差不多！多谢！

#1

线程间通讯的话，如果你要求不高，用全局变量之类的就行，也可以man pthread，看看里面的pthread_cond_signal、pthread_cond_wait，或者信号量sem这些也是可以的。

#2

引用
线程间通讯的话，如果你要求不高，用全局变量之类的就行，也可以man pthread，看看里面的pthread_cond_signal、pthread_cond_wait，或者信号量sem这些也是可以的。

     感谢提供思路，现在在学习这方面的东西了，在http://www.ibm.com/developerworks/cn/linux/l-cn-mthreadps/中整理了一段这样的代码： 
#include <pthread.h>

#include <stdio.h>

#include <stdlib.h>

#include <iostream>

using namespace std;

// 提示出租车到达的条件变量

pthread_cond_t taxiCond=PTHREAD_COND_INITIALIZER; 

// 同步锁

pthread_mutex_t taxiMutex=PTHREAD_MUTEX_INITIALIZER; 

// 旅客人数，初始为 0 

int travelerCount=0;

// 旅客到达等待出租车

void * traveler_arrive(void *name) 

{ 

	cout<<"Traveler: "<<(char *)name<<"needs a taxi now!"<<endl; 

	pthread_mutex_lock(&taxiMutex); 

	// 提示旅客人数增加

	travelerCount++; 

	pthread_cond_wait (&taxiCond, &taxiMutex); 

	pthread_mutex_unlock (&taxiMutex); 

	cout<<"Traveler: "<< (char *)name <<"now got a taxi!"<<endl; 

	pthread_exit( (void *)0 ); 

} 


 // 出租车到达

void * taxi_arrive(void *name) 

{ 

	cout<<"Taxi "<<(char *)name<<"arrives."<<endl;

	while(true) 

	{ 

        	pthread_mutex_lock(&taxiMutex); 

        	// 当发现已经有旅客在等待时，才触发条件变量

        	if(travelerCount>0) 

        	{ 

            		pthread_cond_signal(&taxiCond); 

            		pthread_mutex_unlock (&taxiMutex); 

            		break; 

        	} 

        	pthread_mutex_unlock (&taxiMutex); 

	} 

	pthread_exit( (void *)0 ); 

 }


int main() 

{

	pthread_t thread; 

	pthread_attr_t threadAttr; 

	pthread_attr_init(&threadAttr); 


	pthread_create(&thread, & threadAttr, taxi_arrive, (void *)("Jack")); 

	sleep(1); 

	pthread_create(&thread, &threadAttr, taxi_arrive, (void *)("Mike")); 

	sleep(1); 

	pthread_create(&thread, &threadAttr, traveler_arrive, (void *)("Susan")); 

	sleep(1); 

	return 0; 

 }

     请问：“Susan”到底上了谁的车？“Jack”还是“Mike”?怎么判断呢

#3

我觉得是都有可能。因为这里三个线程共享一个互斥锁，那么理论上三个thread都有可能先于其他两个获得互斥锁。因为代码中有sleep(1), 所以我们可以假设thread(jack)最先获取互斥锁可能性最大，那么thread(mike)和thread(susan)被阻塞，当thread(jack)释放互斥锁，thread(mike)和thread(susan)都有可能获得互斥锁。如果thread(mike)获得互斥锁，那么thread(susan),和thread(jack)继续等待。等thread(mike)释放互斥锁，如果thread(susan)获得互斥锁，全局变量traverlercount变为1，然后执行到pthread_cond_wait语句，立刻释放互斥锁并等待信号。这时候等待信号的thread(mike), thread(jack)都有机会或得互斥锁，谁获得互斥锁susan就会上哪辆车。
对于thread(mike)最先获得互斥锁的情况同上，如果是thread(susan)最先最先或得互斥锁，那么情况就是从traverlercount变为1开始，由thread（mike)和thread(jack）争抢互斥锁。
但是对于你贴出来的代码，我个人觉得还是有机会能够形成死锁，因为在thread(jack)或thread(mike)优先或得互斥锁的情况下，thread(susan）可能永远都无法获取互斥锁（因为始终有thread(jack)或者thread(mike)在和她抢）。
不过这里因为没有pthread_join()所以进程还是可以正常退出，那么所有死锁和线程都会随着进程结束而销毁。但是这又带来一个问题，就是进程main thread可能先于所有其他线程结束，而main thread里用到的是return而不是pthread_exit，这样就可能变成线程随着进程结束而*被销毁。
当然这段代码如果真的跑起来，可能可以正常执行，因为这里面加了sleep()，但是在你的机器上100%正确执行可能取到别人的机器上就完全不能正确执行。所以总的来说我觉得这段代码非常的不严谨。
另外推荐楼主看一个帖子，这上面就说的比较详细一些：http://www.ibm.com/developerworks/cn/linux/thread/posix_thread1/index.html
文章有三篇，都在这个网站上可以看到，随后作者还贴了一篇较为复杂的程序源码，我觉得很有用

#4

引用 3 楼 zuoyangding 的回复:

    非常感谢帮忙分析，能加QQ聊吗？982053351

#5

引用 3 楼 zuoyangding 的回复:

        能不能帮我对这个问题：
现在有两个linux线程：
       1）监控线程，检测从串口接收到的数据是否发生明显变化；2）USB摄像头采集线程；
要求实现的功能：
       当从串口接收到的数据未发生明显变化，USB摄像头持续采集视频；一旦接收到的数据发生明显变化，则USB摄像头停止采集，直到串口接收到的数据恢复正常。
       写一个大概的模板。初学，不知道怎么下手！谢啦

#6

引用 1 楼 9527 的回复:
线程间通讯的话，如果你要求不高，用全局变量之类的就行，也可以man pthread，看看里面的pthread_cond_signal、pthread_cond_wait，或者信号量sem这些也是可以的。

      能不能抽个时间帮我写个大致的模板呢？初学，很难下手啊！谢谢！

#7

引用 6 楼 anhuidaxue100 的回复:
Quote: 引用 1 楼 9527 的回复:

线程间通讯的话，如果你要求不高，用全局变量之类的就行，也可以man pthread，看看里面的pthread_cond_signal、pthread_cond_wait，或者信号量sem这些也是可以的。

      能不能抽个时间帮我写个大致的模板呢？初学，很难下手啊！谢谢！

我觉得楼主不用考虑太多了，你上面的代码我看了，实际应用中，很少会那么做，也就是说同样的线程函数，一般只有一个副本。你提到的上谁的车，这个楼上得朋友说的很对，我也认为上谁的车都有可能。你只需要注意一点cond在wait时时自动解锁和加锁的就行。对于你的应用：
1）串口监测线程接收数据，如果符合条件，设置一个全局变量为TRUE
2）USB摄像头采集线程循环的监测这个全局变量，如果为TRUE就停止
用不到cond，如果不放心，加上mutex就可以了
模板就不写了，能吵吵的就不动手 Linux线程间如何通信

#8

引用 7 楼 9527 的回复

      仅设置一个全局变量，程序运行时出现segment default，应该是摄像头采集线程出错。唉 Linux线程间如何通信

#9

引用 8 楼 anhuidaxue100 的回复:
Quote: 引用 7 楼 9527 的回复

      仅设置一个全局变量，程序运行时出现segment default，应该是摄像头采集线程出错。唉 Linux线程间如何通信

这个和你程序写法有关的，单纯一个boolean的全局变量不会造成这种问题

#10

全局数据区 +  同步变量（互斥锁，条件变量）

#11

引用 5 楼 anhuidaxue100 的回复:
Quote: 引用 3 楼 zuoyangding 的回复:

        能不能帮我对这个问题：
现在有两个linux线程：
       1）监控线程，检测从串口接收到的数据是否发生明显变化；2）USB摄像头采集线程；
要求实现的功能：
       当从串口接收到的数据未发生明显变化，USB摄像头持续采集视频；一旦接收到的数据发生明显变化，则USB摄像头停止采集，直到串口接收到的数据恢复正常。
       写一个大概的模板。初学，不知道怎么下手！谢啦

抱歉楼主， 我这两天都没看论坛。你是安徽大学的？额。。。不会是刘峰的学生吧。。。。。
我之前看别人的帖子有一个多线程的题目，我自己写了一个代码，我觉得你可以参考一下，因为比较简单，而且同时用到了互斥锁和条件信号。如果还有什么问题可以回复我
题目是：
1）有一int型全局变量g_Flag初始值为0；
  2）在主线称中起动线程1，打印“this is thread1”，并将g_Flag设置为1
  3）在主线称中启动线程2，打印“this is thread2”，并将g_Flag设置为2
  4）线程序1需要在线程2退出后才能退出
  5）主线程在检测到g_Flag从1变为2，或者从2变为1的时候退出

代码：
#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

pthread_t thread[2];
static pthread_mutex_t mutex;
static pthread_cond_t cond;
void* thread1(void*);
void* thread2(void*);
int g_Flag=0;

int main(){
int check1=0, check2=0;
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&cond, NULL);
printf("g_Flag=%d\n", g_Flag);
pthread_mutex_lock(&mutex); //make sure that mutex is locked if cond_wait get the mutex first
check1=pthread_create(&thread[0], NULL, thread1, NULL);
if (check1!=0){
fprintf(stderr, "Thread1 create failed\n");
exit(1);
}
check2=pthread_create(&thread[1], NULL, thread2, NULL);
if (check2!=0){
fprintf(stderr, "Thread2 create failed\n");
exit(2);
}
sleep(1);//test if the cond signal works well
pthread_cond_wait(&cond, &mutex);
printf("EXIT MAN THREAD\n");
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
return 0;
}

void* thread1(void* arg){
printf("This is thread1\n");
pthread_mutex_lock(&mutex);
if (g_Flag==2)
pthread_cond_signal(&cond);
g_Flag=1;
printf("g_Flag=%d\n", g_Flag);
pthread_mutex_unlock(&mutex);
pthread_join(thread[1], NULL);
printf("Exit thread1\n");
pthread_exit(NULL);
}

void* thread2(void* arg){
printf("This is thread2\n");
pthread_mutex_lock(&mutex);
if (g_Flag==1)
pthread_cond_signal(&cond);
g_Flag=2;
printf("g_Flag=%d\n", g_Flag);
pthread_mutex_unlock(&mutex);
printf("Exit thread2\n");
pthread_exit(NULL);
}

#12

引用 11 楼 zuoyangding 的回复:
Quote: 引用 5 楼 anhuidaxue100 的回复:

Quote: 引用 3 楼 zuoyangding 的回复:

        能不能帮我对这个问题：
现在有两个linux线程：
       1）监控线程，检测从串口接收到的数据是否发生明显变化；2）USB摄像头采集线程；
要求实现的功能：
       当从串口接收到的数据未发生明显变化，USB摄像头持续采集视频；一旦接收到的数据发生明显变化，则USB摄像头停止采集，直到串口接收到的数据恢复正常。
       写一个大概的模板。初学，不知道怎么下手！谢啦

抱歉楼主， 我这两天都没看论坛。你是安徽大学的？额。。。不会是刘峰的学生吧。。。。。
我之前看别人的帖子有一个多线程的题目，我自己写了一个代码，我觉得你可以参考一下，因为比较简单，而且同时用到了互斥锁和条件信号。如果还有什么问题可以回复我
题目是：
1）有一int型全局变量g_Flag初始值为0；
  2）在主线称中起动线程1，打印“this is thread1”，并将g_Flag设置为1
  3）在主线称中启动线程2，打印“this is thread2”，并将g_Flag设置为2
  4）线程序1需要在线程2退出后才能退出
  5）主线程在检测到g_Flag从1变为2，或者从2变为1的时候退出

代码：
#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

pthread_t thread[2];
static pthread_mutex_t mutex;
static pthread_cond_t cond;
void* thread1(void*);
void* thread2(void*);
int g_Flag=0;

int main(){
int check1=0, check2=0;
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&cond, NULL);
printf("g_Flag=%d\n", g_Flag);
pthread_mutex_lock(&mutex); //make sure that mutex is locked if cond_wait get the mutex first
check1=pthread_create(&thread[0], NULL, thread1, NULL);
if (check1!=0){
fprintf(stderr, "Thread1 create failed\n");
exit(1);
}
check2=pthread_create(&thread[1], NULL, thread2, NULL);
if (check2!=0){
fprintf(stderr, "Thread2 create failed\n");
exit(2);
}
sleep(1);//test if the cond signal works well
pthread_cond_wait(&cond, &mutex);
printf("EXIT MAN THREAD\n");
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
return 0;
}

void* thread1(void* arg){
printf("This is thread1\n");
pthread_mutex_lock(&mutex);
if (g_Flag==2)
pthread_cond_signal(&cond);
g_Flag=1;
printf("g_Flag=%d\n", g_Flag);
pthread_mutex_unlock(&mutex);
pthread_join(thread[1], NULL);
printf("Exit thread1\n");
pthread_exit(NULL);
}

void* thread2(void* arg){
printf("This is thread2\n");
pthread_mutex_lock(&mutex);
if (g_Flag==1)
pthread_cond_signal(&cond);
g_Flag=2;
printf("g_Flag=%d\n", g_Flag);
pthread_mutex_unlock(&mutex);
printf("Exit thread2\n");
pthread_exit(NULL);
}

         我是安大毕业生，谢谢你的回复（你也是安大的？），我的东西做出来了，实现思路和你的基本差不多！多谢！
标签：

相关文章