线程控制：互斥与同步

    问题：
    多个线程在操作临界资源时存在资源竞争问题；
    
    临界资源：多个线程可以同时访问到的资源，如：共享变量，全局变量，共享内存等
    
    解决方法：
    互斥机制：
    在多线程中对临界资源的排他性访问。

    互斥机制 ===》互斥锁  ===》解决多线程操作共享空间引发的资源竞争问题。

    pthread_mutex_t   mutex;
    互斥锁类型        互斥锁变量 内核对象

    框架：
     定义互斥锁 ==》初始化锁 ==》加锁 ==》解锁 ==》销毁
    

     1、定义：
        pthread_mutex_t   mutex;

     2、初始化锁
        int pthread_mutex_init(
            pthread_mutex_t *mutex,
            const pthread_mutexattr_t *attr);
        功能：将已经定义好的互斥锁初始化。
        参数：mutex 要初始化的互斥锁
              atrr  初始化的值，一般是NULL表示默认锁
        返回值：成功 0
                失败 非零
     3、加锁：
        int pthread_mutex_lock(pthread_mutex_t *mutex);
        功能：用指定的互斥锁开始加锁代码
              加锁后的代码到解锁部分的代码属于原子操作，
              在加锁期间其他进程/线程都不能操作该部分代码
              如果该函数在执行的时候，mutex已经被其他部分
              使用则代码阻塞。

        参数： mutex 用来给代码加锁的互斥锁
        返回值：成功 0
                失败 非零

     4、解锁
        int pthread_mutex_unlock(pthread_mutex_t *mutex);
        功能：将指定的互斥锁解锁。
              解锁之后代码不再排他访问，一般加锁解锁同时出现。
        参数：用来解锁的互斥锁
        返回值：成功 0
                失败 非零

     5、销毁
         int pthread_mutex_destroy(pthread_mutex_t *mutex);
         功能：使用互斥锁完毕后需要销毁互斥锁
         参数：mutex 要销毁的互斥锁
         返回值：成功  0
                 失败  非零
        

    
    线程的同步 ===》同步 
  ===》有一定先后顺序的对资源的排他性访问。

    原因：互斥锁可以控制排他访问但没有次序。

    linux下的线程同步  ===》信号量机制 ===》semaphore.h   posix 
    sem_open();
    信号量的分类：
    1、无名信号量 ==》线程间通信
    2、有名信号量 ==》进程间通信

    框架：
    信号量的定义 ===》信号量的初始化 ==》信号量的PV操作===》信号量的销毁。

    semaphore 
    1、信号量的定义 ：
       sem_t            sem;
       信号量的类型     信号量的变量

    2、信号量的初始化：
        int sem_init(sem_t *sem, int pshared, unsigned int value);
        功能：将已经定义好的信号量赋值。
        参数：sem 要初始化的信号量
              pshared = 0 ;表示线程间使用信号量
                      !=0 ;表示进程间使用信号量
              value 信号量的初始值，一般无名信号量
              都是二值信号量，0 1 （同步用二值信号量， 计数信号量）
              
              0 表示红灯，进程暂停阻塞
              1 表示绿灯，进程可以通过执行
        返回值：成功  0
                失败  -1；
    3、信号量的PV 操作
       P ===》申请资源===》申请一个信号量 
       V ===》释放资源===》释放一个信号量

       P操作对应函数 ==》sem_wait();
       V操作对应函数 ==》sem_post();

    int sem_wait(sem_t *sem);
    功能：判断当前sem信号量是否有资源可用。
          如果sem有资源(==1)，则申请该资源，程序继续运行
          如果sem没有资源(==0)，则线程阻塞等待，一旦有资源
          则自动申请资源并继续运行程序。

          注意：sem 申请资源后会自动执行 sem = sem - 1;
    参数：sem 要判断的信号量资源
    返回值：成功 0 
            失败 -1
        
    int sem_post(sem_t *sem);
    功能：函数可以将指定的sem信号量资源释放
          并默认执行，sem = sem+1;
          线程在该函数上不会阻塞。
    参数：sem 要释放资源的信号量
    返回值：成功 0
            失败 -1；

    4、信号量的销毁
       int sem_destroy(sem_t *sem);
       功能：使用完毕将指定的信号量销毁
       参数：sem要销毁的信号量
       返回值：成功 0
                失败  -1；
    
           
    
        死锁：    死锁指的是在多线程环境中，每个执行流（线程）都有未释放的资源，且互相请求对方未释放资源，从而导致陷入永久等待状态的情况。
        现象：
        现象1：忘记释放锁
        现象2：重复加锁
        现象3：多线程多锁，抢占锁资源不当
        如：线程A获取了1锁，线程B获取了2锁，同时线程A还想获取2锁，线程B还想获取1锁
        

        产生死锁的四个必要条件：
        （1） 互斥条件：一个资源每次只能被一个进程使用（一个执行流获取锁后，其它执行流不能再获取该锁）。
        （2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放（执行流本身使用着一把锁并不释放，还在请求别的锁）。
        （3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺（A执行流拿着锁，其它执行流不能释放）。
        （4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系（多个执行流拿着对方想要的锁，并且各执行流还去请求对方的锁）。
    
        解决方法：
        1.锁一定要成对出现
        2.使线程的加锁顺序一致
        3.破坏环路等待条件
          使用非阻塞锁，一旦线程发现请求的锁被使用，就去释放自己拥有的锁