线程互斥
生产者与消费者模型
在讲同步和互斥之前,首先了解一下消费者模型
什么是消费者模型?
消费者模型是一个描述消费者和生产者之间的关系的一个模型,生产者和消费者模型指的是在一个场所中,两个角色,三种关系
- 消费者和消费者之间——互斥
消费者之间是竞争关系,比如有一个鸡腿,两个人A和B去买,A买了,那么B就不能买了,B得买下一个才行,反之B买了这个,A就要排队等下一个。 - 生产者和消费者之间——同步+互斥
生产者和消费者之间讲究一个时序性,同步其实也就是时序性,当超市没有鸡腿,消费者没法买啊,只能等待生产者放上去才能买。同时,当生产者在放的时候你不能买,我都还没放上去你就拿那不是抢劫吗,所以需要互斥保护生产者放鸡腿的这个操作。 - 生产者和生产者之间——互斥
放鸡腿的时候,有两厂商,但是你不能一起放啊,一起放我就记不住,你放一只我放一只,乱光了,就很难受,所以生产者一个在放你另一个别放,我好计数
为什么需要线程同步和互斥
线程之间共享了进程之间的虚拟地址空间,因此缺乏数据访问的控制,容易造成数据的混乱,为了保证数据的安全访问,维持上面说的生产者和消费者模型的关系,因此提出了线程同步与互斥。
这里指的数据一般是所有线程都能访问到的数据才需要同步与互斥,其他线程内的局部变量只属于线程自身,其他线程无法访问到,也就不存在数据安全问题了。
线程互斥
线程互斥解决的是数据的唯一访问性,假设有一个进线程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);//解锁
互斥量初始化有两种方式
- 直接分配
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER
- 动态分配
使用pthread_mutex_init(mutex);分配
互斥量销毁
- 使用PTHREAD_MUTEX_INITIALIAZER初始化的互斥量不需要销毁
- 不要销毁一个正处于加锁状态的互斥锁
- 已经销毁的互斥量,要确保后面不会有线程使用该锁
互斥量的加锁和解锁
一般我们用lock
(阻塞加锁)和unlock
加锁和解锁,当然加锁还有其他接口,trylock
非阻塞加锁,timelock
限时阻塞加锁,可以根据需要选择使用
使用lock加锁的时候,可能会遇到以下情况:
- 互斥量处于未加锁状态,那么会被调用lock的线程加锁,返回成功
- 当互斥量已经处于加锁状态,或者在申请获取加锁和别的线程竞争失败时,会陷入阻塞等待,等待解锁才会加锁
死锁
死锁条件
- 互斥条件——我拿了你不能拿
- 不可剥夺——我拿了你不能解锁
- 请求与保持——拿了锁1去获取锁2,没有锁2不释放锁1
- 环路等待——A拿了锁1去请求锁2,B拿了锁2去请求锁1
如何预防死锁?
在死锁条件中1、2是互斥量的正常使用,我们需要避免的是3、4情况,如何避免这两种情况有艾兹格·迪杰斯特拉提出了著名的银行家算法来解决该问题。
在银行中,客户申请贷款的数量是有限的,每个客户在第一次申请贷款时要声明完成该项目所需的最大资金量,在满足所有贷款要求时,客户应及时归还。银行家在客户申请的贷款数量不超过自己拥有的最大值时,都应尽量满足客户的需要。在这样的描述中,银行家就好比操作系统,资金就是资源,客户就相当于要申请资源的进程。
如果需要详细了解,请看维基百科:银行家算法
互斥锁使用步骤
- 定义一个互斥锁
- 初始化互斥锁
- 对临界操作进行加锁
- 解锁
- 重复3、4
- 当不再需要互斥锁,销毁互斥锁
互斥量使用代码演示
//黄牛买票互斥锁版本
//用互斥锁实现同步,当一个黄牛(线程)买票时,其他黄牛(线程)不能挤进来
//一个黄牛开始买票,互斥锁上锁,其他黄牛无法获得锁,等待
#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;
}