Linux中线程的同步与互斥（互斥锁、条件变量、POSIX信号量）

最新推荐文章于 2025-02-19 10:26:13 发布
最新推荐文章于 2025-02-19 10:26:13 发布
阅读量316 收藏 2
点赞数 2
分类专栏： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/YIUECHEN/article/details/103323992
版权

线程安全与重入

线程安全

定义：多个执行流对同一个临界资源进行争抢访问，但不会造成数据二义或逻辑混乱。
临界区：每个线程内部，访问临界资源的代码。
临界资源：多线程执行流共享的资源就叫做临界资源。

实现：同步与互斥
同步：通过同一时间只有一个线程能够访问临界资源来保证操作安全性
互斥 ：通过条件判断实现对临界资源访问的时序合理性

  • 大部分情况下，线程使用数据的都是局部变量，变量的地址空间在线程栈空间内，这种情况下，变量归属于单个线程，其他线程无法获得这个变量。
  • 但有时，很多变量需要在线程间共享，这种变量叫做共享变量，通过数据的共享，完成线程之间的交互。而多个线程并发操作共享变量会带来一些问题。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#define MAX_THR 4
int ticket=100;//全局变量
void *thr_start(void *argv){
	while(1){
		if(ticket>0){
			printf("%p get a ticket:%d\n",pthread_self(),ticket);
			usleep(1000);		
			ticket--;
		}
		else{
			printf("%pdon't have ticket\n",pthread_self());
			pthread_exit(NULL);
		}
	}
	return NULL;
}
int main(){
	pthread_t tid[MAX_THR];
	int i;
	for(i=0;i<MAX_THR;i++){
		int ret=pthread_create(&tid[i],NULL,thr_start,NULL);
		if(ret!=0){
			perror("pthread create error\n");
			return -1;	
		}
	}
	for(i=0;i<MAX_THR;i++){
		pthread_join(tid[i],NULL);
	}
	return 0;
}

在这里插入图片描述

这个例子中造成的数据二义说明了线程安全的重要性！

可重入

线程互斥

互斥锁
实现原理：

相当于一个只有0/1的计数器，用于标记当前临界资源的访问状态；在对临界资源进行访问之前都需要先加锁访问这个状态计数，若可以进行访问的话则修改计数（这个操作本身是原子操作）。

接口
创建锁：pthread_mutex_t mutex;
初始化锁：pthread_mutex_init ( pthread_mutex_t *mutex , const pthread_mutexattr_t *attr（锁属性，常NULL） );
加锁：pthread_mutex_lock ( pthread_mutex_t *mutex );(加锁后需要在任意地方可能退出线程的地方解锁)
解锁：pthread_mutex_unlock ( pthread_mutex_t *mutex );
加锁、解锁的返回值：成功返回0；失败返回错误号
销毁锁：pthread_mutex_destory ( pthread_mutex_t *mutex );(不要销毁没有解锁的锁)

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#define MAX_THR 4
int ticket=100;
pthread_mutex_t mutex;
void *thr_start(void *argv){
	while(1){
		pthread_mutex_lock(&mutex);
		if(ticket>0){
			printf("%p get a ticket:%d\n",pthread_self(),ticket);
			usleep(1000);		
			ticket--;
			pthread_mutex_unlock(&mutex);	
		}
		else{
			printf("%pdon't have ticket\n",pthread_self());
			pthread_mutex_unlock(&mutex);			
			pthread_exit(NULL);
		}
	}
	return NULL;
}
int main(){
	pthread_t tid[MAX_THR];
	pthread_mutex_init(&mutex,NULL);
	int i;
	for(i=0;i<MAX_THR;i++){
		int ret=pthread_create(&tid[i],NULL,thr_start,NULL);
		if(ret!=0){
			perror("pthread create error\n");
			return -1;	
		}
	}
	for(i=0;i<MAX_THR;i++){
		pthread_join(tid[i],NULL);
	}
	pthread_mutex_destroy(&mutex);
	return 0;
}
死锁
产生原因

多个线程对所资源进行争抢访问，因为推进顺序不当而导致互相等待，造成程序流程无法推进。

死锁的四个必要条件
  • 互斥条件
  • 不可剥脱条件
  • 请求与保持条件
  • 循环等待条件
避免

破坏条件（非阻塞加锁）

银行家算法

线程同步

条件变量
实现原理：

向外提供了一个线程等待（等待队列）（将PCB状态更改为可中断休眠） 以及 唤醒（（将PCB状态更改为运行状态）的功能接口。

接口
创建条件变量：pthread_cond_t cond；
初始化条件变量：pthread_cond_init ( pthread_cond_t *cond , const pthread_condattr_t attr(条件变量的属性，常置NULL) );
等待：int pthread_cond_wait( pthread_cond_t *cond , pthread_mutex_t *mutex );
唤醒：int pthread_cond_signal( pthread_cond_t *cond ); (至少唤醒一个等待队列上的等待的线程)
     int pthread_cond_broadcast( pthread_cond_t *cond );(广播唤醒所有等待队列上的线程)
销毁条件变量：int pthread_cond_destory( pthread_cond_t *cond );

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#define MAX_THR 4
int noodle=0;
pthread_mutex_t mutex;
pthread_cond_t cond_foodie;
pthread_cond_t cond_chef;
void *foodie(void *argv){
	while(1){
		pthread_mutex_lock(&mutex);
		while(noodle==0){
		//pthread_mutex_unlock(&mutex);
		//pause()
		//pthread_mutex_lock(&mutex);//这三步用pthread_cond_wait替换，形成原子操作，避免时间片切换带来的问题
			pthread_cond_wait(&cond_foodie,&mutex);
		}
		printf("%p:the noodles are delicious~\n",pthread_self());
		noodle--;

		pthread_mutex_unlock(&mutex);
		pthread_cond_signal(&cond_chef);
	}
	return NULL;
}

void *chef(void *argv){
	while(1){
		pthread_mutex_lock(&mutex);
		while(noodle==1){
			pthread_cond_wait(&cond_chef,&mutex);
		}
		printf("make a bowl of noodle~\n");
		noodle++;
		pthread_mutex_unlock(&mutex);
		pthread_cond_signal(&cond_foodie);
		sleep(1);
	}
	return NULL;
}

int main(){
	pthread_t foodietid[MAX_THR],cheftid;
	int ret,i;
	pthread_mutex_init(&mutex,NULL);
	pthread_cond_init(&cond_foodie,NULL);
	pthread_cond_init(&cond_chef,NULL);
	for(i=0;i<MAX_THR;i++){
		ret=pthread_create(&foodietid[i],NULL,foodie,NULL);
		if(ret!=0){
			perror("pthread create error");
		}
	}
	ret=pthread_create(&cheftid,NULL,chef,NULL);
	if(ret!=0){
		perror("pthread create error");
	}
	for(i=0;i<MAX_THR;i++){
		pthread_join(foodietid[i],NULL);
	}
	pthread_join(cheftid,NULL);
	pthread_mutex_destroy(&mutex);
	pthread_cond_destroy(&cond_foodie);
	pthread_cond_destroy(&cond_chef);
	return 0;
}
注意事项
  1. 条件变量需要搭配互斥锁一起使用
  2. 对条件判断要使用while循环语句
  3. 不同的角色要使用不同的条件变量进行等待与唤醒，不同的角色不能等待在同一个人队列

POSIX信号量

用于实现线程间的同步
本质：是一个计数器，并向用户提供使线程等待与唤醒的接口。
同步与互斥的实现：

  • 同步：通过自身计数器进行资源计数，对临界资源访问之前先访问信号量，通过计数判断是否有资源可以访问。计数<=0则表示不能访问，计数-1后开始等待；计数>0则表示可以访问，计数-1后直接访问。其他促使条件满足的线程访问临界资源之前也先访问信号量，若计数>0,访问后计数+1；若计数<0，则唤醒一个的等待队列上的线程并计数+1。
  • 互斥：只需要将计数器维护在0/1之间就可以实现互斥。
    接口：
//初始化信号量
#include<semaphore>
int sem_init(sem_t *sem , int pshared , unsigned int value);
参数：
pshared:0表示用于线程间共享，非零表示用于进程间共享
value:信号量初始值

//等待信号量，会将信号量的值-1
int sem_wait(sem_t *sem);//条件判断+等待功能，若计数<=0，则阻塞；否则-1后立即返回

//发布信号量，表示资源使用完毕，可以归还资源，将信号量值+1
int sem_t post(sem_t *sem);

//销毁信号量
int sem_destroy(sem_t *sem);

//信号量实现同步
#include<stdio.h>
#include<stdlib.h>
#include<semaphore.h>
#include<unistd.h>
#include<pthread.h>
sem_t sem;
void *eat(void *arv){
	while(1){
		sem_wait(&sem);
		printf("**eat a bool of noodle\n");
	}
	return NULL;
}
void *cook(void *arv){
	while(1){
		printf("$$cook a bool of noodle\n");
		sleep(1);	
		sem_post(&sem);
	}
	return NULL;
}
int main(){
	int ret,i;
	pthread_t tid1,tid2;
	sem_init(&sem,0,0);
	ret=pthread_create(&tid1,NULL,eat,NULL);
	if(ret!=0){
		perror("pthead create error");
		return -1;
	}
	ret=pthread_create(&tid2,NULL,cook,NULL);
	if(ret!=0){
		perror("pthead create error");
		return -1;
	}
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	sem_destroy(&sem);
	return 0;
}


//信号量实现互斥
#include<stdio.h>
#include<stdlib.h>
#include<semaphore.h>
#include<unistd.h>
#include<pthread.h>

sem_t sem;
int t=100;
void *cattle(void *arv){
	while(1){
		sem_wait(&sem);
		if(t>0){
			sleep(1);
			printf("%pi get a ticket:%d\n",pthread_self(),t--);
			sem_post(&sem);
		}
		else{
			sem_post(&sem);
			pthread_exit(NULL);

		}
	}
	return NULL;
}
int main(){
	int ret;
	pthread_t tid1,tid2;
	sem_init(&sem,0,1);
	ret=pthread_create(&tid1,NULL,cattle,NULL);
	if(ret!=0){
		perror("pthead create error");
		return -1;
	}

	ret=pthread_create(&tid2,NULL,cattle,NULL);
	if(ret!=0){
		perror("pthead create error");
		return -1;
	}
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	sem_destroy(&sem);
	return 0;
}
linux线程同步
longlong068的博客
07-21 394
Linux线程线程框架一、线程概念**线程的概念**：线程和进程的区别：二、线程共享资源和非共享资源线程共享资源：线程非共享资源：三、线程的优缺点优点：缺点：四、线程控制函数获取线程ID pthread_self创建线程pthread_create线程退出函数pthread_exit线程回收pthread_join线程分离pthread_detach杀死进程pthread_cancelpthread_equal五、线程属性梗概线程属性初始化设置属性分离态线程使用注意事项线程同步框架一、线程同步的一些概念1.
Linux-线程同步（条件变量、POSIX信号量）
m0_74910646的博客
07-12 1131
初始化信号量参数：pshared:0 表示线程间共享，非零表示进程间共享value：信号量初始值，共享资源个数销毁信号量等待信号量//P()功能：等待信号量，会将信号量的值减 1发布信号量//V()功能：发布信号量，表示资源使用完毕，可以归还资源了。将信号量值加 1。张得帅c/Linux基于BlockQueue的生产消费模型基于环形队列的生产消费模型。
【正点原子Linux连载】第十二章 线程同步-摘自【正点原子】I.MX6U嵌入式Linux C应用编程指南V1.1
weixin_55796564的博客
08-14 532
1）实验平台：正点原子阿尔法Linux开发板 2）平台购买地址：https://item.taobao.com/item.htm?id=603672744434 2）全套实验源码+手册+视频下载地址：http://www.openedv.com/thread-300792-1-1.html 3）对正点原子Linux感兴趣的同学可以加群讨论：935446741 4）关注正点原子公众号，获取最新资料更新 第十二章 线程同步 本章来聊一聊线程同步这个话题，对于一个单线程进程来说，它不需要处理线程同步的问题，所以
【Linux系统】线程：线程同步
最新发布
从不依靠，从不寻找，非常沉默，非常骄傲。 你必须非常努力，才能看起来毫不费力。
02-19 716
讲解线程同步的概念和原理，用例子引入，如何使用条件变量保证线程同步，生产者消费者模型：基于阻塞队列BlockQueue / 基于环形队列
Linux-线程同步
wengmq的博客
05-16 3311
线程同步 一、概述 线程的最大特点是资源的共享性，但资源共享中的同步问题是多线程编程的难点。 linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量和信号量。 二、互斥锁(mutex) 2.1 - 互斥锁常用函数 在编程中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。每个对象都对应于一个可称为" 互斥锁" 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。 ...
linux-线程同步
qq_43605009的博客
07-24 924
linux-线程同步学习目标：1 互斥锁1.1互斥锁的使用步骤1.2 练习1.3 死锁2 读写锁2.1 读写锁场景练习2.2 读写锁总结2.3 读写锁主要操作函数2.4 练习：3个线程不定时写同一全局资源，5个线程不定时读同一全局资源。3 条件变量3.1 条件变量相关函数3.1.1 pthread_cond_init()函数3.1.2 pthread_cond_destroy()函数3.1.2 pthread_cond_wait()函数3.1.3 pthread_cond_signal()函数3.2 使用条
Linux 线程同步
weixin_45004203的博客
03-21 1597
介绍总结 linux 下线程同步的知识
多线程同步机制与生产者消费者问题的C语言实现-互斥锁、条件变量及Posix信号量的应用
01-11
首先介绍了线程的基础概念及其创建方法，解释了线程间共享资源管理的关键——线程同步机制，尤其是通过使用互斥锁、条件变量和Posix信号量确保不同线程能正确访问临界区而不发生冲突。接下来详细展示了两种编程实现...
Linux系统编程9(线程同步，互斥锁，读写锁，条件变量和信号量)
Haffuman_Tree的博客
09-27 605
本主要介绍线程同步的问题，包括互斥锁，条件变量和pv信号操作
C语言中的信号量、进程同步与互斥、线程同步与互斥详解
weixin_65477256的博客
09-13 2425
在C语言中，信号量是一种用于多线程或进程同步的机制，主要用于解决并发问题，确保多个线程或进程对共享资源的正确访问。它在多进程和多线程编程中扮演重要角色，能有效防止竞态条件和数据不一致。此外，多线程和多进程编程中的同步与互斥问题也是并发编程中必须面对的核心挑战。本文将详细介绍信号量及其应用，并展示如何通过信号量、互斥锁、条件变量等机制进行线程和进程间的同步与互斥。
linux学习：线程安全（信号量+互斥锁读写锁+条件变量+可重入函数）
weixin_59669309的博客
04-29 1092
这样的信号量其实是一个特殊的文件，创建成功之后将会被放置在系统的一个特殊的 虚拟文件系统/dev/shm 之中，不同的进程间只要约定好一个相同的名字，他们就可以通 过这种有名信号量来相互协调，在进程退出之后 他们并不会自动消失，而需要手工删除并释放资源。信号量分为两种，分别是无名信号量和有名信号量， 这两种信号量比之前介绍的 system-V 的信号量机制要简洁，虽然没有后者的应用范围那么广泛，但是 POSIX 良好的设计使得他们更具吸引力。使用条件变量，来实现前面所述的小楠和她的兄弟姐妹取钱的逻辑。
Linux线程同步
weixin_41446512的博客
05-27 192
一、线程同步 同步：保证数据安全的条件下，让多执行流访问资源具有一定的顺序性，从而高效地使用临界资源 1.条件变量 定义：当一个线程互斥访问某个变量时，它可能发现在其它线程改变状态之前，什么也做不了 pthread_cond_t 条件变量用来描述某种临界资源是否就绪的一种数据化描述 2. 二、生产者消费者模型 1.模型 生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消
Linux POSIX信号量同步与互斥实现
总结，本知识点详细解析了POSIX标准、Linux中的POSIX信号量、互斥与同步机制的实现、以及它们在实际编程中的应用。通过学习本知识点，可以更好地理解如何在Linux环境下使用POSIX信号量来解决多线程或多进程编程中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值