线程同步-信号量-互斥量-条件变量

这篇具有很好参考价值的文章主要介绍了线程同步-信号量-互斥量-条件变量。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

线程同步

  • 线程同步其实实现的是线程排队。
  • 防止线程同步访问共享资源造成冲突。
  • 多个线程访问共享资源的代码有可能是同一份代码,也有可能是不同的代码;无论是否执行同一份代码,只要这些线程的代码访问同一份可变的共享资源,这些线程之间就需要同步。

1. 问题

  • 同一个进程内的各个线程,共享该进程内的全局变量
  • 如果多个线程同时对某个全局变量进行访问时,有可能达不到预期效果。

2. 信号量和互斥量的选择。

  • 互斥量:为协调共同对一个共享资源的单独访问而设计的;因为进入内核模式,所以性能比临界区差;跨进程,可用于防止程序重复打开运行。
  • 信号量:为控制一个具有有限数量用户资源而设计,互斥锁可以理解为1个用户资源的信号量。
    • 使用时,选择更符合语义的手段:
      • 如果要求最多只允许一个线程进入临界区,则使用互斥量
      • 如果要求多个线程之间的执行顺序满足某个约束,则使用信号量

条件变量:条件变量是利用线程间共享的全局变量进行同步的一种机制,主要包括两个动作:一个线程等待"条件变量的条件成立"而挂起;另一个线程使"条件成立"(给出条件成立信号)。

信号量

1)什么是信号量

  • 此时所指的“信号量”是指用于同一个进程内多个线程之间的信号量。即POSIX信号量,而不是System V信号量(用于进程之间的同步)

  • 用于线程的信号量的原理,与用于进程之间的信号量的原理相同。都有P操作、V操作。

  • 信号量的表示:sem_t 类型

    2) 信号量的初始化

      原型:int  sem_init  (sem_t  *sem,int  pshared,  unsigned int value);
      功能:对信号量进行初始化
      参数:sem,  指向被初始化的信号量
           pshared,  0:表示该信号量是该进程内使用的“局部信号量”, 不再被其它进程共享。
           		   非0:该信号量可被其他进程共享,Linux不支持这种信号量
           		   
           value,  信号量的初值。>= 0
      返回值:成功,返回0   失败, 返回错误码
    

    3) 信号量的P操作

      原型:int   sem_wait (sem_t  *sem);
      返回值:成功,返回0  失败, 返回错误码
    

    4) 信号量的V操作

      原型:int sem_post (sem_t  *sem);
      返回值:成功,返回0  失败, 返回错误码
    

    5) 信号量的删除

     原型:int sem_destroy (sem_t  *sem);
     返回值:成功,返回0   失败, 返回错误码
    

    6) 实例
    主线程循环输入字符串,把字符串存放到一个全局缓存中。新线程从全局缓存中读取字符串,统计该字符串的长度。直到用户输入end

main.c

预期结果:主线程每接收终端输入的一个字符串,子线程就打印字符串和输出字符串长度

  • 信号量被初始化为0,主线程接受一个字符串的时候,执行V操作(信号量+1),此时信号量大于1,子线程执行P操作(-1),然后对字符串做出相应的操作
#include <pthread.h>
#include <semaphore.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#define BUFF_SIZE 80

// 全局变量可以让多个线程访问
char buff[BUFF_SIZE];
sem_t sem;

static void* str_thread_handle(void *arg) 
{
	while(1) {
		//P(sem) -1
		if (sem_wait(&sem) != 0) {
			printf("sem_wait failed!\n");
			exit(1);
		}
		
		printf("string is: %slen=%u\n", buff, (unsigned int)strlen(buff));
		if (strncmp(buff, "end", 3) == 0) {
			break;
		}
	}
}

int main(void)
{
	int ret;
	pthread_t  str_thread;
	void *thread_return;

	// 参数:被初始化信号量 0 给信号量的赋值
	ret = sem_init(&sem, 0, 0);
	if (ret != 0) {
		printf("sem_init failed!\n");
		exit(1);
	}

	// 创建线程
	ret = pthread_create(&str_thread, 0, str_thread_handle, 0);
	if (ret != 0) {
		printf("pthread_create failed!\n");
		exit(1);
	}

	while (1) {
	    // 从终端获取一行输入
		fgets(buff, sizeof(buff), stdin);

		//V(sem) +1
		// 0->1 那么线程就可以执行P操作 1->0
		if (sem_post(&sem) != 0) {
			printf("sem_post failed!\n");
			exit(1);
		}
		
		if (strncmp(buff, "end", 3) == 0) {
			break;
		}
	}

	ret = pthread_join(str_thread, &thread_return);
	if (ret != 0) {
		printf("pthread_join failed!\n");
		exit(1);
	}

	ret = sem_destroy(&sem);
	if (ret != 0) {
		printf("sem_destroy failed!\n");
		exit(1);
	}

	return 0;
}

线程同步-信号量-互斥量-条件变量
练习

    创建2个线程(共有主线程、线程1、线程2共3个线程)
    主线程阻塞式等待用户输入字符串
    主线程每接收到一个字符串之后, 线程1就马上对该字符串进行处理。
    线程1的处理逻辑为:统计该字符串的个数,并记录当时的时间。
    线程1把该字符串处理完后,线程2马上就把处理结果写入文件result.txt
    直到用户输入exit.
    multi_pthread.c

互斥量

1)什么是互斥量
     效果上等同于初值为1的信号量
     互斥量的使用:类型为 pthread_mutex_t
     
2)互斥量的初始化
     原型:int  pthread_mutex_init(pthread_mutex_t *mutex,
                                   pthread_mutexattr_t *attr);
     参数:mutex, 指向被初始化的互斥量
             attr,  指向互斥量的属性
                    一般取默认属性(当一个线程已获取互斥量后,该线程再次获取该信号量,将导致死锁!)

3) 互斥量的获取
    原型:int  pthread_mutex_lock (pthread_mutex_t *mutex);   

4)互斥量的释放
     原型:int  pthread_mutex_unlock (pthread_mutex_t  *mutex);         
     
5)互斥量的删除
     int  pthread_mutex_destroy (pthread_mutex_t *mutex);  
  1. 实例
    main3.c

预期实现效果:主线程和子线程依次把全局变量 -1 ,依次往终端输出结果

  • 当没有用互斥量的时候,同时运行主线程和子线程,对全局变量进行 - 1
#include <pthread.h>
#include <semaphore.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

#define BUFF_SIZE 80

// 全局
int global_value = 1000;
pthread_mutex_t  lock;

static void* str_thread_handle(void *arg) 
{
	int i = 0;

	for (i=0; i<10; i++) {
		//pthread_mutex_lock(&lock);

		if (global_value  > 0) {
			// work
			sleep(1);
			printf("soled ticket(%d) to ChildStation(%d)\n",
				global_value, i+1);
		}
		global_value--;
		
		//pthread_mutex_unlock(&lock);
		sleep(1);
	}
}

int main(void)
{
	int ret;
	pthread_t  str_thread;
	void *thread_return;
	int i;

	

	ret = pthread_mutex_init(&lock, 0);
	if (ret != 0) {
		printf("pthread_mutex_init failed!\n");
		exit(1);
	}

	ret = pthread_create(&str_thread, 0, str_thread_handle, 0);
	if (ret != 0) {
		printf("pthread_create failed!\n");
		exit(1);
	}

	for (i=0; i<10; i++) {
		//pthread_mutex_lock(&lock);
		
		if (global_value  > 0) {
			// work
			sleep(1);
			printf("soled ticket(%d) to MainStation(%d)\n",
				global_value, i+1);
		}
		global_value--;
		
		
		//pthread_mutex_unlock(&lock);
		sleep(1);
	}

	ret = pthread_join(str_thread, &thread_return);
	if (ret != 0) {
		printf("pthread_join failed!\n");
		exit(1);
	}

	ret = pthread_mutex_destroy(&lock);
	if (ret != 0) {
		printf("pthread_mutex_destroy failed!\n");
		exit(1);
	}

	return 0;
}
  • 主线程 -10 , 子线程 -10 最后应该是 981 所以不符合预期
  • 原因 主线程和子线程同时对全局变量进行了 -1
    线程同步-信号量-互斥量-条件变量
    使用信号量后
  • 上了两把锁
  • 给主线程和子线程对全局变量进行操作的部分分别上锁
#include <pthread.h>
#include <semaphore.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

#define BUFF_SIZE 80

// 全局
int global_value = 1000;
pthread_mutex_t  lock;

static void* str_thread_handle(void *arg) 
{
	int i = 0;

	for (i=0; i<10; i++) {

        /*****上锁*****/
		pthread_mutex_lock(&lock);

		if (global_value  > 0) {
			// work
			sleep(1);
			printf("soled ticket(%d) to ChildStation(%d)\n",
				global_value, i+1);
		}
		global_value--;
		
        /*****开锁*****/
		pthread_mutex_unlock(&lock);
		sleep(1);
	}
}

int main(void)
{
	int ret;
	pthread_t  str_thread;
	void *thread_return;
	int i;

	

	ret = pthread_mutex_init(&lock, 0);
	if (ret != 0) {
		printf("pthread_mutex_init failed!\n");
		exit(1);
	}

	ret = pthread_create(&str_thread, 0, str_thread_handle, 0);
	if (ret != 0) {
		printf("pthread_create failed!\n");
		exit(1);
	}

	for (i=0; i<10; i++) {

        /*****上锁*****/
		pthread_mutex_lock(&lock);
		
		if (global_value  > 0) {
			// work
			sleep(1);
			printf("soled ticket(%d) to MainStation(%d)\n",
				global_value, i+1);
		}
		global_value--;
		
		/*****开锁*****/
		pthread_mutex_unlock(&lock);
		sleep(1);
	}

	ret = pthread_join(str_thread, &thread_return);
	if (ret != 0) {
		printf("pthread_join failed!\n");
		exit(1);
	}

	ret = pthread_mutex_destroy(&lock);
	if (ret != 0) {
		printf("pthread_mutex_destroy failed!\n");
		exit(1);
	}

	return 0;
}
  • 结果分析:相比于上次,每一次输出全局变量就 -1 最后结果为 981
    线程同步-信号量-互斥量-条件变量

条件变量

1.什么是线程条件变量

与互斥锁不同,条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程,直到某特殊情况发生为止。通常条件变量和互斥锁同时使用。

条件变量使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制,主要包括两个动作:一个线程等待"条件变量的条件成立"而挂起;另一个线程使"条件成立"(给出条件成立信号)。

2. 条件变量初始化

  原型:int pthread_cond_init (pthread_cond_t *cond, const pthread_condattr_t *attr);
    参数:cond: 条件变量指针
         attr:条件变量高级属性

3. 唤醒一个等待线程

原型: int pthread_cond_signal (pthread_cond_t *cond);
参数:cond:条件变量指针

4.唤醒所有等待该条件变量的线程

原型: int pthread_cond_broadcast (pthread_cond_t *cond);
参数:cond,  条件变量指针

5.等待条件变量/超时被唤醒

原型: int pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mutex, 
									const struct timespec *abstime);
参数:cond,  条件变量指针
      pthread_mutex_t *mutex 互斥量
      const struct timespec *abstime 等待被唤醒的绝对超时时间

6.等待条件变量被唤醒(一般使用这个)

原型: int pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex);
参数:cond,  条件变量指针
      pthread_mutex_t *mutex 互斥量

常见错误码: [EINVAL] cond或mutex无效,
[EINVAL] 同时等待不同的互斥量
[EINVAL] 主调线程没有占有互斥量

7. 释放/销毁条件变量

pthread_cond_destroy  待销毁的条件变量 
原型: int pthread_cond_destroy (pthread_cond_t *cond);
参数:cond,  条件变量指针

main.c

效果:触发信号,子线程向终端打印数据

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

// 注意这里一定要定义为全局变量
pthread_mutex_t mutex;
pthread_cond_t cond;

void *thread1(void *arg)
{

	while (1) {

		printf("thread1 is running\n");
		
		// 加锁
		pthread_mutex_lock(&mutex);
		printf("thread1 lock..\n");

		// 解锁-阻塞等待信号-信号来了-加锁-执行任务
		pthread_cond_wait(&cond, &mutex);


		// 执行任务
		printf("thread1 applied the condition\n");


		// 解锁
		printf("thread1 unlock..\n");
		pthread_mutex_unlock(&mutex);

		sleep(4);

	}
}


void *thread2(void *arg)
{

	while (1) {

		printf("thread2 is running\n");

		pthread_mutex_lock(&mutex);
		printf("thread2 lock..\n");

		pthread_cond_wait(&cond, &mutex);

		printf("thread2 applied the condition\n");

		printf("thread2 unlock..\n");
		pthread_mutex_unlock(&mutex);

		sleep(2);

	}

}

int main()
{

	pthread_t thid1, thid2;

	printf("condition variable study!\n");

	// 初始化互斥锁  效果上等同于初值为1的信号量
	// 初始化条件变量
	pthread_mutex_init(&mutex, NULL);
	pthread_cond_init(&cond, NULL);

	// 创建两个线程
	pthread_create(&thid1, NULL, (void *)thread1, NULL);
	pthread_create(&thid2, NULL, (void *)thread2, NULL);

	// 不断发送信号,唤醒一个线程
	do {
		sleep(10);
		pthread_cond_signal(&cond);

	} while (1);


	return 0;

}

结果分析:为什么两个线程可以同时上锁?
因为 pthread_cond_wait(&cond, &mutex); 执行过程中有一个解锁的过程,所以是解锁后,另一个线程拿到锁。但是如果此线程被信号触发,那么也会立即上锁,执行任务。

线程同步-信号量-互斥量-条件变量文章来源地址https://www.toymoban.com/news/detail-415458.html

到了这里,关于线程同步-信号量-互斥量-条件变量的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【系统编程】线程安全(POSIX信号量、互斥锁、读写锁等)

    (꒪ꇴ꒪ ),Hello我是 祐言QAQ 我的博客主页:C/C++语言,数据结构,Linux基础,ARM开发板,网络编程等领域UP🌍 快上🚘,一起学习,让我们成为一个强大的攻城狮! 送给自己和读者的一句鸡汤🤔: 集中起来的意志可以击穿顽石! 作者水平很有限,如果发现错误,请在评论区指

    2024年02月10日
    浏览(62)
  • 二、操作系统进程管理(10)——用信号量机制实现进程互斥、同步、前驱关系

        (1)分析并发进程的关键活动,划定临界区。(如对临界区资源打印机的访问就应放在临界区)     (2)设置互斥信号量mutex,初值为1。     (3)在临界区之前执行P(mutex)。      //即使用资源前先申请(P操作)     (4)在临界区之后执行V(mutex)。     (5)对不

    2023年04月08日
    浏览(40)
  • 【Linux C | 多线程编程】线程同步 | 信号量(无名信号量) 及其使用例子

    😁博客主页😁:🚀https://blog.csdn.net/wkd_007🚀 🤑博客内容🤑:🍭嵌入式开发、Linux、C语言、C++、数据结构、音视频🍭 🤣本文内容🤣:🍭介绍 🍭 😎金句分享😎:🍭你不能选择最好的,但最好的会来选择你——泰戈尔🍭 ⏰发布时间⏰: 本文未经允许,不得转发!!!

    2024年04月26日
    浏览(37)
  • 并发编程 --- 信号量线程同步

    上文编码技巧 --- 同步锁对象的选定中,提到了在C#中,让线程同步有两种方式: 锁(lock、Monitor等) 信号量(EventWaitHandle、Semaphore、Mutex) 加锁是最常用的线程同步的方法,就不再讨论,本篇主要讨论使用信号量同步线程。 实际上,再C#中 EventWaitHandle 、 Semaphore 、 Mutex 都是

    2024年02月16日
    浏览(41)
  • 【Linux】详解进程通信中信号量的本质&&同步和互斥的概念&&临界资源和临界区的概念

             访问资源在安全的前提下,具有一定的顺序性,就叫做同步 。在多道程序系统中,由于资源有限,进程或线程之间可能产生冲突。同步机制就是为了解决这些冲突,保证进程或线程之间能够按照既定的顺序访问共享资源。同步机制有助于避免竞态条件和死锁(

    2024年04月25日
    浏览(38)
  • C多线程、锁、同步、信号量

    1.1 创建线程 thread 是线程变量地址 attr是线程属性,一般为NULL start_rount 是函数指针 arg 是函数指针指向函数的参数 1.2 线程退出 retval可以把退出值带回去,例子见线程回收 1.3 线程回收 1.4 线程分离: 某些情况下,程序的主线程有自己的其他业务,如果让主线程负责子线程的

    2024年02月02日
    浏览(72)
  • 线程同步、生产者消费模型和POSIX信号量

    gitee仓库: 1.阻塞队列代码:https://gitee.com/WangZihao64/linux/tree/master/BlockQueue 2.环形队列代码:https://gitee.com/WangZihao64/linux/tree/master/ringqueue 概念 : 利用线程间共享的全局变量进行同步的一种机制,主要包括两个动作:一个线程等待\\\"条件变量的条件成立\\\"而挂起;另一个线程使“

    2024年02月03日
    浏览(46)
  • 12.3用信号量进行线程同步——生产者与消费者问题

    1.shell程序设计 2.内存管理 3.链接库 4.文件操作

    2024年02月04日
    浏览(38)
  • FreeRTOS源码分析-9 互斥信号量

    目录 1 优先级翻转问题 2 互斥信号量概念及其应用 2.2FreeRTOS互斥信号量介绍 2.3FreeRTOS互斥信号量工作原理 3 互斥信号量函数应用 3.1功能分析 3.2API详解 3.3功能实现 4 递归互斥信号量函数应用 4.1死锁现象 ​编辑 4.2API详解 4.3解决死锁 5 互斥信号量实现原理 5.1互斥信号量创建

    2024年02月14日
    浏览(39)
  • FreeRTOS源码分析-10 互斥信号量

    目录   1 事件标志组概念及其应用 1.1 事件标志组定义 1.2 FreeRTOS事件标志组介绍 1.3 FreeRTOS事件标志组工作原理 2 事件标志组应用 2.1 功能需求 2.2 API  2.3 功能实现 3 事件标志组原理 3.1 事件标志组控制块 3.2 事件标志组获取标志位 3.3 等待事件标志触发 3.4 事件标志组设置标志

    2024年02月14日
    浏览(37)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包