线程间的同步与互斥

同步：依照某种次序而进行的资源访问。（时序的可控性）
互斥：在同一时间内资源访问的唯一性。

产生死锁的必要条件：
(1） 互斥条件：一个资源每次只能被一个进程使用。
（2） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（3） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

为了解决死锁问题，而提出的银行家算法

在系统分配资源之前，先提前计算该进程所需要的最大资源量，若现存的资源可以满足要求，则进行分配；否则推迟分配；

生产者与消费者模型：两个对象竞争关系的处理方法

3种关系：
    生产者与生产者之间的关系：互斥
    生产者与消费者之间的关系：同步+互斥
    消费者与消费者之间的关系：互斥
2个角色：生产者、消费者
1个场所：交易场所

一、互斥量：
1.初始化互斥量（mutex）

1)pthread_mutex_init(pthread_mutex_t *restrict mutex,
                     const pthread_mutexattr_t *restrict attr);
----初始化
2）pthread_mutex_destory(pthread_mutex_t *mutex);--销毁

3)pthread_mutex_lock(pthread_mutex_t *mutex)----阻塞的加锁操作,临界资源的操作


对互斥量进行加锁操作，需要用到pthread_mutex_lock();如果互斥量已经上锁，调用该线程是会发生阻塞，直到互斥量被解锁。
4)pthread_mutex_unlock(pthread_mutex_t *mutex)----解锁操作
对互斥量进行解锁操作，需要用到pthread_mutex_unlock();

5)pthread_mutex_trylock(pthread_mutex_t *mutex);---尝试加锁操作
其中，若不想线程一直被阻塞；则可以使用pthread_mutex_trylock尝试对互斥量进行加锁。该函数：若调用时互斥量未加锁，则进行加锁操作，并返回0；若互斥量已经加锁，则会失败返回EBUSY；

部分代码实现：

#include
   #include

   struct foo {
       int f_count;
       pthread_mutex_t f_lock;
   };

   struct foo *foo_alloc(void)
 {
     struct foo *fp;

     if((fp = malloc(sizeof(struct foo))) != NULL) {
         fp->f_count = 1;
         if(pthread_mutex_init(&fp->f_lock,NULL) != 0) {
             free(fp);
             return NULL;
         }
     }
     return (fp);
 }

 void foo_hold(struct foo *fp)
 {
     pthread_mutex_lock(&fp->f_lock);
     fp->f_count++;
     pthread_mutex_unlock(&fp->f_lock)'
 }

 void foo_rele(struct foo *fp)
 {
     pthread_mutex_lock(&fp->f_lock);
     if(--fp->f_count == 0) {
         pthread_mutex_unlock(&fp->f_lock);
         pthread_mutex_destory(&fp->lock);
         free(fp);
     }
     else {
         pthread_mutex_unlock(&fp->f_lock);
     }
 }

二、条件变量
条件变量：

int pthread_cond_init(pthread_cond_t *restrict cond
                  pthread_condattr_t *restrict attr);//可以设为NULL int pthread_cond_destroy(pthread_cond_t *cond);

两者都是：成功返回0；否则返回错误编码

开始等待：

pthread_cond_wait(pthread_cond_t *restrict cond//等待该条件cond变为真；
                  pthread_mutex_t *restrict mutex);并且对互斥量进行保护；
pthread_cond_timewait();

唤醒等待：

int pthread_cond_signal(pthread_cond_t *cond);//唤醒等待该条件的某个线程
int pthread_cond_broadcast(pthread_cond_t *cond);唤醒等待该条件的所有进程