linux线程操作

初始化条件变量

int pthread_cond_init(pthread_cond_t *cv,pthread_cond_attr *cattr);
函数返回值：返回0表示成功，返回其他表示失败。
参数：        pthread_cond_attr是用来设置pthread_cond_t的属性，当传入的值是NULL的时候表示使用默认的属性。

函数返回时，创建的条件变量保存在cv所指向的内存中，可以用宏PTHREAD_COND_INITIALIZER来初始化条件变量。值得注意的是不能使用多个线程初始化同一个条件变量，当一个线程要使用条件变量的时候确保它是未被使用的。

条件变量的销毁

int pthread_cond_destroy(pthread_cond_t *cv);
返回值：返回0表示成功，返回其他值表示失败。

条件变量的使用：

int pthread_cond_wait(pthread_cond_t *cv,pthread_mutex_t *mutex)
int pthread_cond_signal(pthread_cond_t *cv);

使用方式如下：

pthread_mutex_lock(&mutex)
while or if(线程执行的条件是否成立)pthread_cond_wait(&cond,&mutex);
线程执行
pthread_mutex_unlock(&mutex);

为什么要加锁

线程在执行的部分访问的是进程的资源，有可能多个线程需要访问它，为了避免由于线程并发执行所引起的资源竞争，所以要让每个线程互斥的访问公共资源。
如果while或if判断不满足线程的执行条件时，线程回调用pthread_cond_wait阻塞自己。pthread_cond_wait被调用线程阻塞的时候，pthread_cond_wait会自动释放互斥锁。线程从调用pthread_cond_wait到操作系统把他放在线程等待队列之后的时候释放互斥锁。

使用while和if判断线程执行条件释放成立的区别。

在多线程资源竞争的时候，在一个使用资源的线程里面（消费者）判断资源是否可用，不可用便调用pthread_cond_wait，在另一个线程里面（生产者）如果判断资源可用的话，则会调用pthead_cond_signal发送一个资源可用的信号。

但是在wait成功之后，资源就不一定可以被使用，因为同时有两个或两个以上的线程正在等待次资源，wait返回后，资源可能已经被使用了，在这种情况下

while(resource == FALSE)pthread_cond_wait(&cond,&mutex);

如果之后只有一个消费者，就可使用if。

分解pthread_cond_wait动作为以下步骤：

线程放在等待队列上，解锁
等待pthread_cond_signal或者pthread_cond_broadcast信号之后去竞争锁
若竞争到互斥锁则加锁

有可能多个线程在等待这个资源可用的信号，信号发出去之后只有一个资源可用，但是有A，B两个线程在等待，B速度比较快，获得互斥锁，然后加锁，消耗资源，然后解锁，之后A获得互斥锁，但它回去发现资源已经被使用了，它便有两个选择，一个失去访问不存在的资源，另一个就是继续等待，那么等待下去的条件就是使用while，要不然使用if的话pthread_cond_wait返回后，就会顺序执行下去。

等待线程：

pthread_cond_wait 前要加锁

pthread_cond_wait 内部会解锁，然后等待条件变量被其他线程激活

pthread_cond_wait 被激活后会再自动加锁

激活线程

加锁（和等待线程用同一个锁）

pthread_cond_signal 发送信号（阶跃信号前最后判断有无等待线程）

解锁

激活线程的上面三个操作再运行时间上都是再等待线程的pthread_cond_wait函数内部。

/***
pthread_if.c
***/
#include<stdio.h>
#include<sys/types.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;int count = 0;void *decrement(void *arg)
{printf("in derment\n");pthread_mutex_lock(&mutex);if(count == 0)pthread_cond_wait(&cond,&mutex);count--;printf("----decrement:%d\n",count);printf("out decrement\n");pthread_mutex_unlock(&mutex);return NULL;
}void *increment(void *arg)
{printf("in increment\n");pthread_mutex_lock(&mutex);count++;printf("-----increment:%d\n",count);if(count != 0){pthread_cond_signal(&cond);}printf("out increment\n");pthread_mutex_unlock(&mutex);return NULL;
}int main()
{pthread_t tid_in,tid_de;pthread_create(&tid_de,NULL,(void*)decrement,NULL);sleep(1);pthread_create(&tid_in,NULL,(void*)increment,NULL);sleep(1);pthread_join(tid_de,NULL);pthread_join(tid_in,NULL);pthread_mutex_destroy(&mutex);pthread_cond_destroy(&cond);return 0;
}

/***
pthread_while.c
***/
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>typedef struct node_s
{int data;struct node_s *next;
}node_t;node_t *head = NULL;pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;void cleanup_handler(void *arg)
{printf("cleanup_handler is running.\n");free(arg);pthread_mutex_unlock(&mutex);
}void *thread_func(void *arg)
{node_t *p = NULL;pthread_cleanup_push(cleanup_handler,p);while(1){pthread_mutex_lock(&mutex);while(NULL == head)pthread_cond_wait(&cond,&mutex);p = head;head = head->next;printf("process %d node\n",p->data);free(p);pthread_mutex_unlock(&mutex);}pthread_cleanup_pop(0);return NULL;
}int main()
{pthread_t tid;node_t *temp = NULL;int i;pthread_create(&tid,NULL,(void*)thread_func,NULL);for(i = 0; i < 10; i++){temp = (node_t*)malloc(sizeof(node_t));temp->data = i;pthread_mutex_lock(&mutex);temp->next = head;head = temp;pthread_cond_signal(&cond);pthread_mutex_unlock(&mutex);sleep(1);}pthread_cancel(tid);pthread_join(tid,NULL);return 0;}