linux 线程边学边总结

      今天在linux敲代码的时候突然遇到__LINE__当时是懵逼的，经过查询之后那是linux下的宏定义，一般有这几个：

               __LINE__      代码执行到多少行

               __FILE__      文件名

               __DATE__     日期

               __TIME__      具体时间

类似这样的就可以了printf（"%s   \n",__LINE__）; //这里是两个下横线。

pthread_cond_t   是定义条件变量的；需要配合mutex使用

pthread_mutex_lock( &g_mtx );    //加锁

pthread_cond_wait( &g_cond , &g_mtx );   //阻塞,释放锁

pthread_mutex_unlock( &g_mtx );         //解锁

pthread_cond_signal( g_cond )；      // 发信号

 

使用pthread_cond_wait 需要在 lock/unlock 之间，以防止在进入wait状态前有signal。需要先lock, 一旦进行wait状态，会释放 mutex的lock。而一旦有收到signal信号就会自动重新获到mutex的lock。而且cond的lock是原子操作。
在需要的地方进行 pthread_cond_signal( g_cond ), 之前的wait 位置就可以执行，达到多个线程同步。

下面是代码;

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
pthread_mutex_t  mutex = PTHREAD_MUTEX_INITIALIZER;//静态初始化
pthread_cond_t   cond = PTHREAD_COND_INITIALIZER;//静态初始化

// 线程执行的两个函数</span>
void *thread1(void *);
void *thread2(void *);
int  i  = 1;                         //全局变量，其实就是用来让线程共享

void *thread1(void *arg)
{
for(i = 1; i <= 6; i++){
pthread_mutex_lock(&mutex);
printf("thread1:lock %d\n",__LINE__);
if(i % 3 == 0){
printf("thread1:signal 1 %d\n",__LINE__);
pthread_cond_signal(&cond);  //条件改变，发送信号，通知t_b进程
printf("thread1_signal 2 %d\n",__LINE__);
sleep(1);
}//end if
pthread_mutex_unlock(&mutex);
printf("thread1: unlock %d\n",__LINE__);
sleep(1);
}//end for
}// end  void *thread1

void *thread2(void *arg)
{
while( i < 6)
{
pthread_mutex_lock(&mutex);
printf("thread2 lock %d\n",__LINE__);
if(i % 3 != 0){
printf("thread2: wait 1 %d\n",__LINE__);
pthread_cond_wait(&cond,&mutex);// 解锁mutex，并等待cond改变
printf("thread2: wait 2 %d\n",__LINE__);
}// end if
pthread_mutex_unlock(&mutex);
printf("thread2:unlock %d\n",__LINE__);
sleep(1);
}//end while
}

int main(int argc,char *argv[])
{
pthread_t  t_a;
pthread_t  t_b;
if(pthread_create(&t_a,NULL,(void *)thread1,NULL)){
printf("pthread_create failed\n");
exit(1);
}

if(pthread_create(&t_b,NULL,(void *)thread2,NULL)){
printf("pthread_create failed\n");
exit(1);
}

pthread_join(t_a,NULL);
pthread_join(t_b,NULL);
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
return 0;
}

号外，随便闲扯一下，互斥锁本身也有不足之处，虽然lock阻塞之后，但是她还是占着资源，采用轮询的方式，这就很麻烦了，如果只有一把锁，而好多线程都在不停的看，问，这个锁有没有释放，非常耗资源（CPU），但是条件变量刚好弥补了互斥锁的这点不足之处，等锁好了我通知你，不用你来自己问了，感觉很不靠谱的例子，之前在服务器上会出现惊群现象，一个请求了，很多服务器抢着来干活，这样不好吧，仅仅一个请求就成这个样子，那么我专门来一个管理这些服务器的leader，请求来了，如果我让你做，我给你通知，这样就不会出现惊群现象。条件变量就可以认为是管理这些服务器的leader。对于具体的什么动态初始化，没静态初始化我也就不写了，么意思