前言
1. 线程通信 只需要操作 共享的进程数据段 即可,虽然很容易,但也有其弊端,正因为并发的线程访问了相同的资源,所以造成了数据的不确定性。因此,线程的通信需要结合一些同步互斥机制一起使用
2. 假如没有一些同步互斥机制,一个线程在读一个全局变量时,刚好另外一个线程在写这个全局变量,就容易造成数据的混乱
1. 什么是互斥锁
1. 互斥锁是用以保护对共享资源的操作,即保护线程对共享资源的操作代码可以完整执行,而不会在访问的中途被其他线程介入对共享资源访问。
2 .互斥量也称为互斥锁,对共享资源进行锁定,保证同一时刻只能有一个线程去操作。
注意: 互斥锁是多个线程一起去抢,抢到锁的线程先执行,没有抢到锁的线程需要等待,等互斥锁使用完释放后,其它等待的线程再去抢这个锁。
2、互斥锁的使用
1. 使用之前需要先初始化一个互斥锁
2 .如果线程加锁成功,则可以访问共享资源,期间不会被打断,在访问结束之后解锁
3. 线程在进行上锁时,其锁资源被其他线程持有,那么该线程则会执行阻塞等待,等待锁资源被解除之后,才可以进行加锁
4. 互斥锁并不能保证线程的执行先后,但却可以保证对共享资源操作的完整性
3、什么是共享资源
通常把对共享资源操作的代码段,称之为临界区,其共享资源也可以称为 临界资源 。于是这种机制—— 互斥锁的工作原理就是对临界区进行加锁 ,保证处于临界区的线程不被其他线程打断,确保其临界区运行完整。
4、与互斥锁相关的API
(1)创建互斥锁
pthread_mutex_t mutex; //此创建的互斥锁为全局变量
(2)pthread_mutex_init()____初始化互斥锁
#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
pthread_mutex_t *restrict mutex: 锁的地址
const pthread_mutexattr_t *restrict attr: 锁的属性,默认写NULL
// 返回:若成功返回0,否则返回错误编号
(3)pthread_mutex_destroy()___销毁互斥锁
#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);
pthread_mutex_t *mutex: 锁的地址,是一个指针
// 返回:若成功返回0,否则返回错误编号
(4)pthread_mutex_lock()___加锁
#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
pthread_mutex_t *mutex: 锁的地址,是一个指针
// 返回:若成功返回0,否则返回错误编号
(5)pthread_mutex_unlock()___解锁
#include <pthread.h>
int pthread_mutex_unlock(pthread_mutex_t *mutex);
pthread_mutex_t *mutex: 锁的地址,是一个指针
// 返回:若成功返回0,否则返回错误编号
举例:如何创建一个互斥锁代码实现:
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
int g_data = 0;
pthread_mutex_t mutex; //创建一个互斥锁
void *func1(void *arg){
int i;
pthread_mutex_lock(&mutex); //加锁
for(i=0;i<5;i++){
printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
printf("t1:param is %d\n",*((int *)arg));
sleep(1);
}
pthread_mutex_unlock(&mutex); //解锁
}
void *func2(void *arg){
pthread_mutex_lock(&mutex); //加锁
printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
printf("t2:param is %d\n",*((int *)arg));
pthread_mutex_unlock(&mutex); //解锁
}
int main(){
int ret;
int param = 100;
pthread_t t1;
pthread_t t2;
pthread_mutex_init(&mutex,NULL); //初始化互斥锁
ret = pthread_create(&t1,NULL,func1,(void *)¶m);
if(ret == 0){
printf("main:pthread_create success\n");
}
ret = pthread_create(&t2,NULL,func2,(void *)¶m);
if(ret == 0){
printf("main:pthread_create success\n");
}
printf("mian:%ld\n",(unsigned long)pthread_self());
pthread_join(t1,NULL);
pthread_join(t2,NULL);
pthread_mutex_destroy(&mutex); //销毁互斥锁
return 0;
}
执行结果:
举例:互斥锁限制共享资源的访问:
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
int g_data = 0;
pthread_mutex_t mutex;
void *func1(void *arg){
printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
printf("t1:param is %d\n",*((int *)arg));
pthread_mutex_lock(&mutex);
while(1){
printf("t1:%d\n",g_data++);
sleep(1);
if(g_data == 3){
pthread_mutex_unlock(&mutex);
printf("t1 quit =============================\n");
exit(0);
}
}
}
void *func2(void *arg){
printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
printf("t2:param is %d\n",*((int *)arg));
while(1){
printf("t2:%d\n",g_data);
pthread_mutex_lock(&mutex);
g_data++;
pthread_mutex_unlock(&mutex);
sleep(1);
}
}
int main(){
int ret;
int param = 100;
pthread_t t1;
pthread_t t2;
pthread_mutex_init(&mutex,NULL);
ret = pthread_create(&t1,NULL,func1,(void *)¶m);
if(ret == 0){
printf("main:pthread_create success\n");
}
ret = pthread_create(&t2,NULL,func2,(void *)¶m);
if(ret == 0){
printf("main:pthread_create success\n");
}
printf("mian:%ld\n",(unsigned long)pthread_self());
while(1){
printf("main:%d\n",g_data);
sleep(1);
}
pthread_join(t1,NULL);
pthread_join(t2,NULL);
pthread_mutex_destroy(&mutex);
return 0;
}
执行结果:
5什么情况会造成死锁
死锁定义
1. 首先要有两把锁A和B,当线程1先获得A锁后,想要再去获得B锁,这时线程2手里已经获得B锁后,想要再去获得A锁,这样线程1和线程2都想要拿到对方手里的那把锁,而且谁也不让着谁,谁都不肯去解锁。
2 .死锁是指在一组进程中的各个进程均占有不会释放的资源,但因互相申请被其他进程所站用不会释放的资源而处于的一种 永久等待状态
3 . 多个线程对多个互斥锁交叉使用,每一个线程都试图对其他线程所持有的互斥锁进行加锁。
死锁的四个必要条件
互斥: 一个资源每次只能被一个执行流使用
请求与保持: 一个执行流申请对方资源但对方不给资源
不剥夺 :一个执行流已获得的资源,在末使用完之前,不能强行剥夺
循环等待: 若干执行流之间形成一种头尾相接的循环等待资源的关系
避免死锁
破坏死锁的四个必要条件
加锁顺序一致
避免锁未释放的场景
资源一次性分配
银行家算法
当线程向系统申请资源时,系统必须判断如果分配了资源,会不会导致资源不安全的状态;会,就不分配;否则就分配
死锁代码示例:
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
int g_data = 0;
pthread_mutex_t mutex;
pthread_mutex_t mutex2;
void *func1(void *arg){
int i;
pthread_mutex_lock(&mutex);
sleep(1);
pthread_mutex_lock(&mutex2);
for(i=0;i<5;i++){
printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
printf("t1:param is %d\n",*((int *)arg));
sleep(1);
}
pthread_mutex_unlock(&mutex);
}
void *func2(void *arg){
pthread_mutex_lock(&mutex2);
sleep(1);
pthread_mutex_lock(&mutex);
printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
printf("t2:param is %d\n",*((int *)arg));
pthread_mutex_unlock(&mutex);
}
int main(){
int ret;
int param = 100;
pthread_t t1;
pthread_t t2;
pthread_mutex_init(&mutex,NULL);
pthread_mutex_init(&mutex2,NULL);
ret = pthread_create(&t1,NULL,func1,(void *)¶m);
if(ret == 0){
printf("main:pthread_create success\n");
}
ret = pthread_create(&t2,NULL,func2,(void *)¶m);
if(ret == 0){
printf("main:pthread_create success\n");
}
printf("mian:%ld\n",(unsigned long)pthread_self());
pthread_join(t1,NULL);
pthread_join(t2,NULL);
pthread_mutex_destroy(&mutex);
pthread_mutex_destroy(&mutex2);
return 0;
}
执行结果: