线程学习（三）：线程的互斥

生产者与消费者模型

在讲同步和互斥之前，首先了解一下消费者模型

什么是消费者模型？

消费者模型是一个描述消费者和生产者之间的关系的一个模型，生产者和消费者模型指的是在一个场所中，两个角色，三种关系

1. 消费者和消费者之间——互斥
   消费者之间是竞争关系，比如有一个鸡腿，两个人A和B去买，A买了，那么B就不能买了，B得买下一个才行，反之B买了这个，A就要排队等下一个。
2. 生产者和消费者之间——同步+互斥
   生产者和消费者之间讲究一个时序性，同步其实也就是时序性，当超市没有鸡腿，消费者没法买啊，只能等待生产者放上去才能买。同时，当生产者在放的时候你不能买，我都还没放上去你就拿那不是抢劫吗，所以需要互斥保护生产者放鸡腿的这个操作。
3. 生产者和生产者之间——互斥
   放鸡腿的时候，有两厂商，但是你不能一起放啊，一起放我就记不住，你放一只我放一只，乱光了，就很难受，所以生产者一个在放你另一个别放，我好计数

为什么需要线程同步和互斥

线程之间共享了进程之间的虚拟地址空间，因此缺乏数据访问的控制，容易造成数据的混乱，为了保证数据的安全访问，维持上面说的生产者和消费者模型的关系，因此提出了线程同步与互斥。

这里指的数据一般是所有线程都能访问到的数据才需要同步与互斥，其他线程内的局部变量只属于线程自身，其他线程无法访问到，也就不存在数据安全问题了。

线程互斥

线程互斥解决的是数据的唯一访问性，假设有一个进线程1访问一个全局数据，那么什么线程2、线程3或者线程0都靠边站，等线程1访问完了，其他线程再来竞争这个数据的访问权，那么数据就能够保证安全访问。

没有线程互斥会怎么样

首先我们来看一个黄牛买票的例子

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

int ticket_left = 100;

void* ticket_scalper(void* id)
{
    int ticket_scalper_id = (int)id;
    while (1)
    {
        usleep(100);
        if (ticket_left > 0)
        {
            ticket_left--;
            usleep(100);
            printf("No.%d ticket scalper buy a ticket, ticket left %d\n", ticket_scalper_id, ticket_left);
        }
        else
        {
            printf("no ticket left!!\n");
            break;
        }
    }
    return NULL;
}

int main()
{
    pthread_t tid[4] = {-1};
    int i = 0;
    printf("%d tickets left.\n", ticket_left);
    for (i = 0; i < 4; i++)
    {
        printf("No.%d ticket scalper come to buy tickets~\n", i + 1);
        int ret = pthread_create(&tid[i], NULL, ticket_scalper, (void*)(i + 1));
        if (ret < 0)
        {
            perror("pthread_create error");
            return -1;
        }
    }
    for (i = 0; i < 4; i++)
    {
        pthread_join(tid[i], NULL);
    }
    return 0;
}

运行结果

可以看到没有互斥保护的话，有些黄牛买完票剩余的票居然是一样的，显然是不可能的，所以我们需要一个互斥锁来保护这个卖票的过程，一人买另一人不能买，一人买完另一人才能进去买。

mutex(互斥量)

保护变量在访问时仅被单一线程访问，做到变量的访问安全，防止出现上面的情况，我们需要一个互斥量来完成下图的做法

互斥量接口

int pthread_mutex_init(pthread_mutex_t* restrict mutex, const pthread_mutexattr_t* restrict attr);
//初始化互斥量
//参数：
//	mutex：要初始化的互斥量
//	attr：NULL
int pthread_mutex_destroy(pthread_mutex_t* mutex);
//	mutex：需要销毁的互斥量
int pthread_mutex_lock(pthread_mutex_t *mutex);//加锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);//解锁

互斥量初始化有两种方式

1. 直接分配

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

2. 动态分配

使用pthread_mutex_init(mutex);分配

互斥量销毁

1. 使用PTHREAD_MUTEX_INITIALIAZER初始化的互斥量不需要销毁
2. 不要销毁一个正处于加锁状态的互斥锁
3. 已经销毁的互斥量，要确保后面不会有线程使用该锁

互斥量的加锁和解锁

一般我们用lock(阻塞加锁)和unlock加锁和解锁，当然加锁还有其他接口，trylock非阻塞加锁，timelock限时阻塞加锁，可以根据需要选择使用
使用lock加锁的时候，可能会遇到以下情况：

1. 互斥量处于未加锁状态，那么会被调用lock的线程加锁，返回成功
2. 当互斥量已经处于加锁状态，或者在申请获取加锁和别的线程竞争失败时，会陷入阻塞等待，等待解锁才会加锁

死锁

死锁条件

1. 互斥条件——我拿了你不能拿
2. 不可剥夺——我拿了你不能解锁
3. 请求与保持——拿了锁1去获取锁2，没有锁2不释放锁1
4. 环路等待——A拿了锁1去请求锁2，B拿了锁2去请求锁1

如何预防死锁？
在死锁条件中1、2是互斥量的正常使用，我们需要避免的是3、4情况，如何避免这两种情况有艾兹格·迪杰斯特拉提出了著名的银行家算法来解决该问题。
在银行中，客户申请贷款的数量是有限的，每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量，在满足所有贷款要求时，客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时，都应尽量满足客户的需要。在这样的描述中，银行家就好比操作系统，资金就是资源，客户就相当于要申请资源的进程。
如果需要详细了解，请看维基百科：银行家算法

互斥锁使用步骤

1. 定义一个互斥锁
2. 初始化互斥锁
3. 对临界操作进行加锁
4. 解锁
5. 重复3、4
6. 当不再需要互斥锁，销毁互斥锁

互斥量使用代码演示

Github地址

//黄牛买票互斥锁版本
//用互斥锁实现同步，当一个黄牛（线程）买票时，其他黄牛（线程）不能挤进来
//一个黄牛开始买票，互斥锁上锁，其他黄牛无法获得锁，等待
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>

int ticket = 100;
pthread_mutex_t mutex;
//互斥锁的初始化有两种方式：
//  1. 定义时直接赋值初始化，最后不需要手动释放
//  2. 函数接口初始化，最后需要手动释放
//  pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* sell_ticket(void* arg)
{
    int id = (int)arg;
    while (1)
    {
        usleep(100);
        pthread_mutex_lock(&mutex);
		//  int pthread_mutex_lock(pthread_mutex_t *mutex);
        //      阻塞加锁，如果获取不到锁则阻塞等待锁被解开
        //  int pthread_mutex_trylock(pthread_mutex_t *mutex);
        //      非阻塞加锁，如果获取不到锁则立即报错返回EBUSY
        //  int pthread_mutex_timedlock (pthread_mutex_t *mutex, struct timespec *t);
        //      限时阻塞加锁，如果获取不到锁则等待指定时间，在这段
        //      时间内如果一直获取不到，则报错返回，否则加锁
        if (ticket > 0)
        {
            ticket--;
            usleep(100);
            printf("Ticket scalper %d buy a ticket, tickets left %d\n", id, ticket);
        }
        else
        {
			//如果票卖完了也需要解锁
			//如果不解锁，那线程退出，锁未解锁，造成死锁
			//后面线程无法获取锁状态卡死
            printf("Ticket scalper %d want to buy a ticket, but no ticket left! -> %d\n", id, ticket);
            pthread_mutex_unlock(&mutex);
			//int pthread_mutex_unlock(pthread_mutex_t *mutex);
			//	解锁
            pthread_exit(NULL);
        }
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main()
{
    pthread_t tid[4];
    int i, ret;
	pthread_mutex_init(&mutex, NULL);
	//int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
    //      mutex： 互斥锁变量
    //      attr：互斥锁的属性，NULL；
    //  	返回值：0-成功      errno-失败
    printf("Train station has %d tickets left, start selling tickets\n", ticket);
    for (i = 0; i < 4; i++)
    {
        ret = pthread_create(&tid[i], NULL, sell_ticket, (void*)(i + 1));
        if (ret < 0)
        {
            perror("pthread_create failed\n");
            return -1;
        }
    }
    for (i = 0; i < 4; i++)
    {
        pthread_join(tid[i], NULL);
    }
    pthread_mutex_destroy(&mutex);
    return 0;
}