线程的同步和互斥

学习线程的同步和互斥，我们首先需要明白的就是同步和互斥，它们是为了什么。同步是为了在安全的条件下，使线程具有顺序性，而互斥是为了保证数据的安全性。

线程互斥（mutex）

为神马需要线程互斥？

• 大多数情况，线程使用的数据都是局部变量，变量的地址空间实在线程栈空间中，这种情况下，变量归属单个进程，其他线程无法获取该变量。
• 但有时，很多变量都需要线程共享，这些共享的变量称为共享变量，可以通过数据的共享，完成线程之间的互斥。
• 多个线程并发的操作共享变量，这就会发生一些神奇的事情
  如下代码：

  #include <stdio.h>                                                                                                                                                                           
  #include <pthread.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <string.h>

  int ticket = 10;
  //自动忽略注释部分。。。。。。 
  //pthread_mutex_t mutex;
  void* thread_run(void* arg){
      char* tid = (char*)arg;
      while(1){
  //        pthread_mutex_lock(&mutex);
          if(ticket > 0){ 
          sleep(1);
          printf("%s sells ticket:%d \n", tid, ticket);
          ticket--;
  //        pthread_mutex_unlock(&mutex);
          }else{
  //            pthread_mutex_unlock(&mutex);
              break;
          }   
      }   
      return 0;
  }

  int main(void){

  //    pthread_mutex_init(&mutex, NULL);
      pthread_t tid1, tid2, tid3, tid4;
      pthread_create(&tid1, NULL, thread_run,"thread 1");    
      pthread_create(&tid2, NULL, thread_run,"thread 2");
      pthread_create(&tid3, NULL, thread_run,"thread 3");
      pthread_create(&tid4, NULL, thread_run,"thread 4");

      pthread_join(tid1, NULL);
      pthread_join(tid2, NULL);
      pthread_join(tid3, NULL);

运行该程序你就会发现如下结果：

最后竟然出现了负数，这就是多个进程同时访问变量所造成的结果，因此为了解决这个问题，需要做到以下三点：

1. 代码必须要有互斥行为，当代码进入临界去的时候，不允许其他线程进入该临界区
2. 多个线程访问临界区的时候，并且临界区没有线程在执行，那就只允许一个线程进入该临界区。
3. 如果线程不在临界区内，那么该线程不能阻止其他线程进入临界区

通俗点来说，也就是需要做到原子性，且要公平公正。
为了实现上面的三点，就引进了一把牛逼的锁，在Linux上被称为互斥量，即mutex。

互斥量的使用

初始化互斥量：
1. 静态分配（一般用的少）

pthread_mutex_t = PTHREAD_MUTEX_INITIALIZER

2.动态分配（重点）

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
//参数：mutex：要初始化的互斥量
//     att：NULL

创建了互斥量，就要记得销毁互斥量，否则就会发生。。。的事了
销毁互斥量
注意事项：

1. 静态分配的互斥量不需要销毁
2. 不能销毁一个已经加锁了的互斥量
3. 已经销毁的互斥量，要保证后面没有线程在尝试加锁

int pthread_mutex_destroy(pthread_mutex_t *mutex);

互斥量的使用（加锁和解锁）

int pthread_mutex_lock(pthraed_mutex_t *mutex);//加锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);//解锁
//返回值：成功返回0，失败返回错误码

调用上面函数的时候，需要注意：

1. 互斥量处于未锁状态，该函数就会被互斥量锁定，同时返回成功
2. 发起函数调用的时候，其他线程已经锁定互斥量，或者存在其他线程同时申请互斥量，但是没抢到，那么加锁函数就会陷入阻塞，等待互斥量解锁。

改进后的代码：

  #include <stdio.h>                                                                                                                                                                           
  #include <pthread.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <string.h>

  int ticket = 10;
  pthread_mutex_t mutex;
  void* thread_run(void* arg){
      char* tid = (char*)arg;
      while(1){
          pthread_mutex_lock(&mutex);
          if(ticket > 0){ 
          sleep(1);
          printf("%s sells ticket:%d \n", tid, ticket);
          ticket--;
          pthread_mutex_unlock(&mutex);
          }else{
              pthread_mutex_unlock(&mutex);
              break;
          }   
      }   
      return 0;
  }

  int main(void){

      pthread_mutex_init(&mutex, NULL);
      pthread_t tid1, tid2, tid3, tid4;
      pthread_create(&tid1, NULL, thread_run,"thread 1");    
      pthread_create(&tid2, NULL, thread_run,"thread 2");
      pthread_create(&tid3, NULL, thread_run,"thread 3");
      pthread_create(&tid4, NULL, thread_run,"thread 4");

      pthread_join(tid1, NULL);
      pthread_join(tid2, NULL);
      pthread_join(tid3, NULL);

此时再一运行，当ticket为0，sell也就停止了。

线程的同步（cond）

同样为神马？

• 当一个线程互斥的访问一个变量的时候，它可能会发现在其他线程改变状态之前，它什么都做不了。
• 例如一个线程访问队列的时候，发现队列为空，他就只能等待，等其他线程将一个节点添加到队列才能访问。这样就需要条件变量来解决这个问题。

为了解决上面的问题，我们就引进了条件变量，来很好的解决线程的同步

条件变量的使用

初始化

int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
//参数：cond ：要初始化的条件变量
//     attr ：NULL

销毁

int pthread_cond_destroy（pthread_cond_t *cond）;

等待条件满足

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
//参数： cond：要在这个条件变量上等待，并且在等待期间释放锁，唤醒是要获得锁，并在等待出继续执行
//      mutex：互斥量

唤醒等待

int pthread_cond_broadcast(pthread_cond_t *cond);//有竞争时，会唤醒多个线程
int pthread_cond_signal(pthread_cond_t *cond);//么有竞争，就只唤醒一个线程

在等待条件满足函数里面，发现还有一个互斥量，为神马线程同步还需要互斥量呢？

1. 条件等待是线程同步的一种手段，当只有一个线程的时候，条件一直不满足，一直等下去就永远不会满足，所以我们就需要有一个线程通过某种操作，改变共享变量，是原先不满足的变成满足，并且通知等待在条件变量的线程
2. 条件不会要变得满足，就需要牵扯到共享变量的变化，所以我们就需要互斥锁来保护共享变量，来确保安全的获取和修改共享数据。
3. 当一个线程自己已经有锁了，有要重新申请自己的锁，这样就会造成死锁问题，为了解决这个问题，我们就需要使解锁和等待是一个原子操作。

条件变量的使用规范

等待条件代码：

pthread_mutex_lock(&mutex);
while(条件为真）
    pthread_cond_wait(cond, mutex);
修改条件
pthread_mutex_unlocm(&mutex);

给条件变量法信号代码：

pthread_mutex_lock(&mutex);
设置条件为真
pthread_cond_signal(cond);
pthread_mutex_unlock(&mutex);

实现线程同步还有一种方法POSIX信号量

POSIX的使用

初始化

#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
//参数：
//      pshared:0表示线程间共享，非零表示进程共享
//      value:信号量初始值

销毁信号量

int sem_destroy(sem_t *sem);

等待信号量
会将信号量的值-1

int sem_wait(sem_t *sem);

发布信号量
表示资源使用完毕，可以归还资源了，将信号量+1

int sem_post(sem_t *sem);

POSIX信号量适合解决环形队列问题，每次生产一个放进环形队列里，信号量就+1，当环形队列满了，也就是当环形队列里的东西取的没有拿的快的时候，就等待取，每取走一个，信号量-1。