高编：线程（2）——同步与互斥

一、互斥

概念：
    互斥 ===》在多线程中对 临界资源 的 排他性访问。

    互斥机制 ===》互斥锁  ===》保证临界资源的访问控制。

    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);
        功能：将指定的互斥锁解锁。
                   解锁之后代码不再排他访问，一般加锁解锁同时出现。（尽量上锁解锁的代码短一些，保护并发性）
        参数：mutex  用来解锁的互斥锁
        返回值：成功  0
                      失败  非零

     5、销毁         

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

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

int a = 0;
pthread_mutex_t mutex;
void* th(void* arg)
{
    // pthread_mutex_lock(&mutex);
    int i =5000;
    while(i--)
    {
        pthread_mutex_lock(&mutex);
        int tmp = a;
        printf("a is %d\n",tmp+1);
        a = tmp+1;
        pthread_mutex_unlock(&mutex); 
    }
    // pthread_mutex_unlock(&mutex); 
    return NULL;
}

int main(int argc, char *argv[])
{
    
    pthread_t tid1,tid2;
    pthread_mutex_init(&mutex,NULL);
    pthread_create(&tid1,NULL,th,NULL);
    pthread_create(&tid2,NULL,th,NULL);
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_mutex_destroy(&mutex);
    return 0;
}

6、trylock

        int pthread_mutex_trylock(pthread_mutex_t *mutex);
        功能：类似加锁函数效果，唯一区别就是不阻塞。
        参数：mutex 用来加锁的互斥锁
        返回值：成功  0
                      失败  非零
                       E_AGAIN

综合练习：10个人去三个窗口办业务，办完一个人才能开始办下一个人

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
pthread_mutex_t mutex;
int WIN = 3;
void* th(void* arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(WIN>0)
        {
            WIN--;
            pthread_mutex_unlock(&mutex);
            printf("get win\n");
            sleep(rand()%5);

            printf("relese win\n");
            pthread_mutex_lock(&mutex);
            WIN++;
            pthread_mutex_unlock(&mutex);

            break;
        }
        else 
        {
            pthread_mutex_unlock(&mutex);

        }
    }
    return NULL;
}

int main(int argc, char *argv[])
{
    pthread_t tid[10];
    int i = 0 ;
    pthread_mutex_init(&mutex,NULL);
    for(i = 0 ;i<10;i++)
    {
        pthread_create(&tid[i],NULL,th,NULL);
    }
    for(i = 0 ;i<10;i++)
    {
        pthread_join(tid[i],NULL);
    }
    pthread_mutex_destroy(&mutex);
    return 0;
}

 二、同步

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

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

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

    框架：
    信号量的定义 ===》信号量的初始化 ===》信号量的P（申请资源）V（释放资源）操作 

===》信号量的销毁。

    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；

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>
sem_t sem_C,sem_M;
void* th1(void* arg)
{
    int i = 5;
    while(i--)
    {
        sem_wait(&sem_C);
        printf("capper ");
        fflush(stdout);
        sem_post(&sem_M);
    }
    return NULL;
}
void* th2(void* arg)
{
    int i = 5;
    while(i--)
    {
        sem_wait(&sem_M);
        printf("made in future\n");
        sleep(1);
        sem_post(&sem_C);
    }
    return NULL;
}

int main(int argc, char *argv[])
{
    pthread_t tid1,tid2;

    sem_init(&sem_C,0,1);
    sem_init(&sem_M,0,0);

    pthread_create(&tid1,NULL,th1,NULL);
    pthread_create(&tid2,NULL,th2,NULL);

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

    sem_destroy(&sem_C);
    sem_destroy(&sem_M);
    return 0;
}

三、互斥锁和信号量的异同

同

同一时刻只有一个在走

异

1. 运行顺序--->互斥锁没有顺序；信号量有顺序
2. 锁的个数--->互斥锁只有1个锁；信号量一般大于2个锁（几个同步变量就几个锁）
3. 加锁解锁操作--->互斥锁同一个线程：同一个锁上锁解锁；信号量同一个线程不同锁：锁自己，释放下一个锁

四、死锁

1.产生死锁的原因

（1） 因为系统资源不足。
（2） 进程运行推进的顺序不合适。
（3） 资源分配不当等。
如果系统资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则
就会因争夺有限的资源而陷入死锁。其次，进程运行推进顺序与速度不同，也可能产生死锁。

2.产生死锁的四个必要条件（同时满足 产生死锁）

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