线程同步

1. 线程同步概念：

        线程同步，指一个线程发出某一功能调用时，在没有得到结果之前，该调用不返回。同时其它线程为保证数据一致性，不能调用该功能。

2. 锁的使用

Linux 中提供一把互斥锁 mutex（也称之为互斥量）。
       每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束解锁。
       资源还是共享的，线程间也还是竞争的。

 

3. 主要应用函数：

       pthread_mutex_init                 初始化一个互斥锁 函数

       pthread_mutex_destory          销毁一个互斥锁 函数

       pthread_mutex_lock                加锁 函数

       pthread_mutex_trylock           尝试加锁 函数

       pthread_mutex_unlock            解锁 函数

以上5个函数的返回值都是：成功返回0，失败返回错误号

        pthread_mutex_t 类型，其本质是一个结构体。为简化理解，应用时可忽略其实现细节，简单当成整数看待。pthread_mutex_t mutex；变量mutex只有两种取值：0,1

4. 使用mutex(互斥量、互斥锁)一般步骤：

 

初始化互斥量：

pthread_mutex_t mutex;

1. pthread_mutex_init(&mutex, NULL);                  动态初始化。

2. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;      静态初始化。

使用mutex(互斥量、互斥锁)一般步骤：

1. pthread_mutex_t lock;  创建锁

2 .pthread_mutex_init; 初始化            1

3. pthread_mutex_lock;加锁               1--   --> 0

4. 访问共享数据（stdout)           

5. pthrad_mutext_unlock();解锁          0++ --> 1

6. pthead_mutex_destroy；销毁锁

5. 使用锁实现互斥访问共享区：

 

#include   
#include   
#include   
#include   
#include   
  
pthread_mutex_t mutex;      // 定义一把互斥锁  
  
void *tfn(void *arg)  
{  
    srand(time(NULL));  
  
    while (1) {  
        pthread_mutex_lock(&mutex);     // 加锁  
        printf("hello ");  
        sleep(rand() % 3);  // 模拟长时间操作共享资源，导致cpu易主，产生与时间有关的错误  
        printf("world\n");  
        pthread_mutex_unlock(&mutex);   // 解锁  
        sleep(rand() % 3);  
    }  
  
    return NULL;  
}  
  
int main(void)  
{  
	    pthread_t tid;  
    srand(time(NULL));  
    int ret = pthread_mutex_init(&mutex, NULL);    // 初始化互斥锁  
    if(ret != 0){  
        fprintf(stderr, "mutex init error:%s\n", strerror(ret));  
        exit(1);  
    }  
  
    pthread_create(&tid, NULL, tfn, NULL);  
    while (1) {  
        pthread_mutex_lock(&mutex);     // 加锁  
        printf("HELLO ");  
        sleep(rand() % 3);  
        printf("WORLD\n");  
        pthread_mutex_unlock(&mutex);   // 解锁  
        sleep(rand() % 3);  
    }  
    pthread_join(tid, NULL);  
      
    pthread_mutex_destory(&mutex);     // 销毁互斥锁  
  
    return 0;  
}  

编译运行，结果如下：

 

6. 两种死锁

是使用锁不恰当导致的现象：

1. 对一个锁反复lock。

2. 两个线程，各自持有一把锁，请求另一把。

 

条件变量

1. 条件变量是什么？

条件变量：

        条件变量本身不是锁！但它也可以造成线程阻塞。通常与互斥锁配合使用。给多线程提供一个会合的场所。

       主要应用函数：

pthread_cond_t cond;

       初始化条件变量：

       1. pthread_cond_init(&cond, NULL);                                     动态初始化。

       2. pthread_cond_t cond = PTHREAD_COND_INITIALIZER;      静态初始化。

2. 阻塞函数wait和唤醒函数signal

阻塞等待一个条件变量
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex)；
函数作用：
1. 阻塞等待条件变量 cond被唤醒，阻塞等待时mutex会解锁，被唤醒时mutex加锁；
2. 释放已掌握的互斥锁（解锁互斥量） 相当于pthread_mutex_unlock(&mutex)；
3. 当被唤醒，pthread_cond_wait 函数返回时，解除阻塞并重新申请获取互斥锁pthread_mutex_lock(&mutex)；

pthread_cond_signal 函数
       唤醒至少一个阻塞在条件变量上的线程
       int pthread_cond_signal(pthread_cond_t *cond);

pthread_cond_broadcast 函数
       唤醒全部阻塞在条件变量上的线程
       int pthread_cond_broadcast(pthread_cond_t *cond);

3. 条件变量的生产者消费者模型分析

        线程同步典型的案例即为生产者消费者模型，而借助条件变量来实现这一模型，是比较常见的一种方法。

        假定有两个线程，一个模拟生产者行为，一个模拟消费者行为。两个线程同时操作一个共享资源（一般称之为汇聚），生产向其中添加产品，消费者从中消费掉产品。

 4. 条件变量生产者消费者代码

/*借助条件变量模拟 生产者-消费者 问题*/  
#include   
#include   
#include   
#include   
  
/*链表作为公享数据,需被互斥量保护*/  
struct msg {  
    struct msg *next;  
	int num;  
};  
  
struct msg *head;  
  
/* 静态初始化 一个条件变量 和 一个互斥量*/  
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;  
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;  
  
void *consumer(void *p)  
{  
    struct msg *mp;  
  
    for (;;) {  
        pthread_mutex_lock(&lock);  
       while (head == NULL) {           //头指针为空,说明没有节点    可以为if吗  
            pthread_cond_wait(&has_product, &lock);   // 解锁，并阻塞等待  
        }  
        mp = head;        
        head = mp->next;                 //模拟消费掉一个产品  
        pthread_mutex_unlock(&lock);  
  
        printf("-Consume %lu---%d\n", pthread_self(), mp->num);  
        free(mp);  
        sleep(rand() % 5);  
    }  
}  
  
void *producer(void *p)  
{  
    struct msg *mp;  
  
    for (;;) {  
        mp = malloc(sizeof(struct msg));  
        mp->num = rand() % 1000 + 1;        //模拟生产一个产品  
        printf("-Produce ---------------------%d\n", mp->num);  
 
        pthread_mutex_lock(&lock);  
        mp->next = head;  
        head = mp;  
        pthread_mutex_unlock(&lock);  
  
        pthread_cond_signal(&has_product);  //将等待在该条件变量上的一个线程唤醒  
        sleep(rand() % 5);  
    }  
}  
  
int main(int argc, char *argv[])  
{  
    pthread_t pid, cid;  
    srand(time(NULL));  
  
    pthread_create(&pid, NULL, producer, NULL);  
    pthread_create(&cid, NULL, consumer, NULL); 
	
    pthread_join(pid, NULL);  
    pthread_join(cid, NULL);  
  
    return 0;  
}  

 编译运行，结果如下：