线程互斥

概念：
互斥 ===》在多线程中对临界资源的排他性访问。
互斥机制 ===》互斥锁  ===》保证临界资源的访问控制。
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
                       失败  非零

例一：互斥锁的基本使用。

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

int a = 0;
//1.定义互斥锁
pthread_mutex_t mutex;
void* th(void* arg){

    int i = 5000;
    while (i--)
    {
        //申请锁，申请不到则阻塞
        pthread_mutex_lock(&mutex);
        int temp = a;
        printf("a = %d\n",temp+1);
        a = temp+1;
        //释放锁
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int	main(int argc, char **argv)
{
    pthread_t tid1,tid2;
    // 2 .互斥锁的初始化
    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);
    // 5 .互斥锁的释放
    pthread_mutex_destroy(&mutex);

    return 0;
}

例二：实现十个人到三个柜台办理业务。

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

            pthread_mutex_lock(&mutex);
            WIN++;
            printf("relese win...\n");
            pthread_mutex_unlock(&mutex);
            break;
        }
        else
        {
           pthread_mutex_unlock(&mutex);
        }
    }

    return NULL;
}

int main(int argc, char** argv)
{
    pthread_t tid[10] = {0};
    srand(time(NULL));
    pthread_mutex_init(&mutex,NULL);
    int i = 0;
    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;
}

在main函数中开启十个线程模拟十个人，定义窗口数为全局变量WIN=3，由于操作WIN需要互斥排他访问，所以当需要操作WIN时要进行加锁解锁操作。

---------------------------------------------------------------------------------------------------------------------------------

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

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

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；

例一：按顺序打印hello和world。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
// 1. 定义同步的信号量
sem_t sem_H,sem_W;

void* th1(void* arg){

    int i = 10;
    while (i--) {
        // 4.申请信号量 ，如果申请不到，就阻塞
        sem_wait(&sem_H);
        printf("hello ");
        fflush(stdout);
        // 5.释放信号量 (下一步运行线程的信号量)
        sem_post(&sem_W);
    }
    return NULL;
}
void* th2(void* arg){

    int i = 10;
    while (i--) {
        sem_wait(&sem_W);
        printf("world\n");
        sleep(1);
        sem_post(&sem_H);
        
    }
    return NULL;
}

int	main(int argc, char **argv)
{
    
    pthread_t tid1,tid2;
    // 2 .信号量初始化
    /**
        此时，由于给sem_H的信号量初始化为1，sem_W的信号量初始化为0
        执行顺序为先hello再world
    */
    sem_init(&sem_H, 0, 1);
    sem_init(&sem_W, 0, 0);

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

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    // 5. 信号量的销毁
    sem_destroy(&sem_H);
    sem_destroy(&sem_W);

    return 0;
}

例二：信号量机制实现互斥操作。

当sem_init(sem_t *sem, int pshared, unsigned int value)函数中value大于1，即非二值信号量时，此时可以将信号量当作临界资源使用，即进行互斥操作。

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

//定义窗口信号量
sem_t sem_WIN;

void* th(void* arg)
{
    //判断是否有资源，如果没有资源，就一直等待
    sem_wait(&sem_WIN);

    printf("get win...\n");
    sleep(rand() % 5 + 1);
    printf("relese win...\n");

    //释放信号量
    sem_post(&sem_WIN);

    return NULL;
}

int main(int argc, char** argv)
{
    pthread_t tid[10] = {0};
    srand(time(NULL));
    // 计数信号量，表示资源数 3个
    sem_init(&sem_WIN, 0, 3);
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        pthread_create(&tid[i], NULL, th, NULL);
    }
    for (i = 0; i < 10; i++)
    {
        pthread_join(tid[i], NULL);
    }
    sem_destroy(&sem_WIN);

    return 0;
}

这段代码同样实现了互斥操作，当信号量为0时，调用sem_wait()函数时，由于没有资源，请求的线程进行等待，直到其他线程执行sem_post()释放信号量。
       

线程死锁

产生死锁的原因主要是：
（1） 因为系统资源不足。
（2） 进程运行推进的顺序不合适。
（3） 资源分配不当等。
如果系统资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则
就会因争夺有限的资源而陷入死锁。其次，进程运行推进顺序与速度不同，也可能产生死锁。
产生死锁的四个必要条件：
（1） 互斥条件：一个资源每次只能被一个进程使用。
（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。