• 【线程】线程同步

    目录

    一、信号量

    1.函数

    2.使用

    二、读写锁

    1.函数

    2.使用

    三、互斥锁

    1.函数

    2.使用

    四、条件变量

    1.函数

    2.使用

    前言

    线程同步的实现方法：信号量、互斥锁、条件变量、读写锁。（考点）

    下面就对着四种方法进行展开描述

    一、信号量

    与进程间通信的信号量类似，参考链接：【Linux】进程间通信——信号量

    1.函数

    头文件

    #include

     sem_init()

    int sem_init(sem_t *sem,int pshared,unsigned int value);
    • 作用：初始化由sem指向的信号量对象
    • 参数：pshared控制信号量类型，如果为0表示这个信号量是当前进程的局部信号量，否则，这个信号量就可以在多个进程之间共享。参数value提供信号量的初值
    • 返回值：成功返回0

    sem_post()

    int sem_post(sem_t *sem);
    • 作用：原子操作的方式给信号量的值+1。所谓原子操作是指，如果两个线程企图同时给一个信号量加1，他们之间不会互相干扰，而不像如果两个程序同时对同一个文件进行读取、增加、写入操作时可能会引起冲突。信号量的值总是被正确地加2，因为有两个线程企图改变它。  
    • 参数：指针作为参数，指向对象是由sem_init调用的初始化信号量。
    • 返回值：成功返回0

    sem_wait()

    int sem_wait(sem_t *sem);
    • 作用：原子操作的方式给信号量的值-1。但他会等待直到信号量有个非零值才会开始减法操作。因此，如果对值为2的信号量调用sem_wait，线程将继续执行，但信号量的值会减到1.如果对值为0的信号量进行操作，sem_wait函数就会进行等待，直到有其他线程增加了该信号量的值使其不再是0为止。如果两个线程同时在sem_wait调用上等待同一个信号量变为非0值，那么该信号量被第三个线程增加1时，只有其中一个等待线程将开始对信号量-1，然后继续执行，另一个线程还将继续等待。
    • 参数：指针作为参数，指向对象是由sem_init调用的初始化信号量
    • 返回值：成功返回0

    sem_destroy()

    int sem_destroy(sem_t *sem);
    •  作用：用完信号量之后对它进行清理。
    • 指针作为参数，指向对象是由sem_init调用的初始化信号量，并清理该信号量拥有的所有资源。
    • 返回值：如果企图清理的信号量正在被一些线程等待，就会收到一个错误。成功返回0。

    2.使用

    用代码实现打印机对ABC顺序打印的操作，如下图所示，使用信号量完成代码：

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7.  
    8. sem_t sema;
    9. sem_t semb;
    10. sem_t semc;
    11.  
    12. void* funa(void* arg)
    13. {
    14. 	for(int i=0;i<5;i++)
    15. 	{
    16. 		sem_wait(&sema);//ps1
    17. 		printf("A");
    18. 		fflush(stdout);
    19. 		sem_post(&semb);//vs2
    20. 	}
    21. }
    22. void* funb(void* arg)
    23. {
    24. 	for(int i=0;i<5;i++)
    25. 	{
    26. 		sem_wait(&semb);
    27. 		printf("B");
    28. 		fflush(stdout);
    29. 		sem_post(&semc);
    30. 	}
    31. }
    32. void* func(void* arg)
    33. {
    34. 	for(int i=0;i<5;i++)
    35. 	{
    36. 		sem_wait(&semc);
    37. 		printf("C");
    38. 		fflush(stdout);
    39. 		sem_post(&sema);
    40. 	}
    41. }
    42.  
    43. int main()
    44. {
    45. 	//初始化信号量
    46. 	sem_init(&sema,0,1);
    47. 	sem_init(&semb,0,0);
    48. 	sem_init(&semc,0,0);
    49. 	
    50. 	//创建线程
    51. 	pthread_t id1,id2,id3;
    52. 	pthread_create(&id1,NULL,funa,NULL);	
    53. 	pthread_create(&id2,NULL,funb,NULL);
    54. 	pthread_create(&id3,NULL,func,NULL);
    55.  
    56. 	pthread_join(id1,NULL);
    57. 	pthread_join(id2,NULL);
    58. 	pthread_join(id3,NULL);
    59.  
    60. 	sem_destroy(&sema);
    61. 	sem_destroy(&semb);
    62. 	sem_destroy(&semc);
    63. 	exit(0);
    64. }

    二、读写锁

    由上面的程序可知，信号量的使用是A在读取时，阻止B，C的读取，这样拉低程序性能，读取的时候其实可以三个一起读，而在写操作的时候不能读，因此引入读写锁进行优化

    1.函数

    1. pthread_rwlock_init();//初始化
    2.  
    3. pthread_rwlock_destroy();//销毁
    4.  
    5. pthread_rwlock_rdlock();//读
    6.  
    7. pthread_rwlock_wrlock();//读写
    8.  
    9. pthread_rwlock_unlock();//解锁

    要求：

    • 在写时，不能读
    • 在读时，不能读
    • 读的话都可以读

    2.使用

    代码实现读锁阻止写锁，写锁阻止读锁和写锁。其中fun1和fun2是对文件的读取，fun3是对文件写操作。

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7.  
    8. pthread_rwlock_t lock;
    9.  
    10. void* fun1(void* arg)
    11. {
    12. 	for(int i=0;i<5;i++)
    13. 	{
    14. 		pthread_rwlock_rdlock(&lock);
    15. 		printf("fun1 read start----\n");
    16. 		sleep(1);
    17. 		printf("fun1 over\n");
    18. 		pthread_rwlock_unlock(&lock);
    19. 		sleep(1);
    20. 	}
    21. }
    22. void* fun2(void* arg)
    23. {
    24. 	for(int i=0;i<5;i++)
    25. 	{
    26. 		pthread_rwlock_rdlock(&lock);
    27. 		printf("fun2 read start----\n");
    28. 		sleep(2);
    29. 		printf("fun2 over\n");
    30. 		pthread_rwlock_unlock(&lock);
    31. 	}
    32. }
    33. void* fun3(void* arg)//写
    34. {
    35. 	for(int i=0;i<5;i++)
    36. 	{
    37. 		pthread_rwlock_wrlock(&lock);
    38. 		printf("fun3 read start----\n");
    39. 		sleep(3);
    40. 		printf("fun3 over\n");
    41. 		pthread_rwlock_unlock(&lock);
    42. 	}
    43. }
    44. int main()
    45. {
    46. 	pthread_rwlock_init(&lock,NULL);
    47. 	pthread_t id1,id2,id3;
    48. 	pthread_create(&id1,NULL,fun1,NULL);	
    49. 	pthread_create(&id2,NULL,fun2,NULL);
    50. 	pthread_create(&id3,NULL,fun3,NULL);
    51. 	pthread_join(id1,NULL);
    52. 	pthread_join(id2,NULL);
    53. 	pthread_join(id3,NULL);
    54. 	pthread_rwlock_destroy(&lock);
    55. 	exit(0);
    56. }

    三、互斥锁

    用的时候加锁，如果已经被别的进程加锁，那么该进程就只能被阻塞着。

    互斥锁可以理解为信号量的子集

    1.函数

    头文件

    #include

    返回值：成功返回0，失败返回错误码 

    参数：与信号量类似，都是一个提前声明过的对象指针。对互斥锁来说，这个对象的类型为pthread_mutex_t。

    pthread_mutex_init——初始化

    int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t *mutexattr);

    用于设置互斥量的属性，控制互斥量的行为

    pthread_mutex_lock——加锁

    int pthread_mutex_lock(pthread_mutex_t *mutex);

    pthread_mutex_unlock——解锁

    int pthread_mutex_unlock(pthread_mutex_t *mutex);

    pthread_mutex_destroy——销毁

    int pthread_mutex_destroy(pthread_mutex_t *mutex);

    2.使用

    用代码实现互斥锁的使用，在打印机内A使用前加锁，使用后解锁，B在A使用的时候阻塞，如下图·所示：

    代码：

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6.  
    7. pthread_mutex_t mutex;
    8.  
    9. void* fun1(void* arg)
    10. {
    11. 	for(int i=0;i<5;i++)
    12. 	{
    13. 		pthread_mutex_lock(&mutex);
    14. 		printf("A");
    15. 		fflush(stdout);
    16. 		int n=rand()%3;
    17. 		sleep(n);
    18. 		printf("A");
    19. 		fflush(stdout);
    20. 		pthread_mutex_unlock(&mutex);
    21. 		n=rand()%3;
    22. 		sleep(n);
    23. 	}
    24. }
    25.  
    26. void* fun2(void* arg)
    27. {
    28. 	for(int i=0;i<5;i++)
    29. 	{
    30. 		pthread_mutex_lock(&mutex);
    31. 		printf("B");
    32. 		fflush(stdout);
    33. 		int n=rand()%3;
    34. 		sleep(n);
    35. 		printf("B");
    36. 		fflush(stdout);
    37. 		pthread_mutex_unlock(&mutex);
    38. 		n=rand()%3;
    39. 		sleep(n);
    40. 	}
    41. }
    42.  
    43. int main()
    44. {
    45. 	pthread_mutex_init(&mutex,NULL);//初始化
    46. 	pthread_t id1,id2;
    47.  	pthread_create(&id1,NULL,fun1,NULL);
    48.  	pthread_create(&id2,NULL,fun2,NULL);
    49. 	pthread_join(id1,NULL);
    50. 	pthread_join(id2,NULL);	
    51. 	pthread_mutex_destroy(&mutex);//销毁
    52. 	exit(0);
    53. }

    运行结果：

    四、条件变量

    条件变量提供了一种线程间的通知机制：当某个共享数据达到某个值的时候，唤醒等待 这个共享数据的线程。

    唤醒时，如果线程不在等待队列中的（条件变量为空），此时唤醒就无意义

    1.函数

    头文件

    #include
    1. int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *attr); 
    2. int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
    3. int pthread_cond_signal(pthread_cond_t *cond); //唤醒单个线程 
    4. int pthread_cond_broadcast(pthread_cond_t *cond); //唤醒所有等待的线程
    5. int pthread_cond_destroy(pthread_cond_t *cond);

    2.使用

    下面代码举例说明funa使用时加锁，用完解锁。funb使用时加锁，用完解锁。键盘输入数据唤醒funa,funb其中一个进行读取。如果键盘输入为end，funa,funb同时被唤醒，退出进程。

    加锁的目的防止被他人唤醒被他人加入等待队列

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7.  
    8. pthread_mutex_t mutex;
    9. pthread_cond_t cond;
    10.  
    11. void* funa(void* arg)
    12. {
    13. 	char*s=(char*)arg;//退化为指向数组首地址指针
    14. 	while(1)//先阻塞，直到被唤醒
    15. 	{
    16. 		pthread_mutex_lock(&mutex);//加锁 用互斥锁保护
    17. 		pthread_cond_wait(&cond,&mutex);//加锁，解锁
    18. 		pthread_mutex_unlock(&mutex);//解锁
    19.  
    20. 		if(strncmp(s,"end",3)==0)
    21. 		{
    22. 			break;
    23. 		}
    24. 		printf("funa: %s",s);
    25. 	}
    26. }
    27. void* funb(void* arg)
    28. {
    29.         char*s=(char*)arg;//退化为指向数组首地址指针
    30.         while(1)//先阻塞，直到被唤醒
    31.         {
    32.                 pthread_mutex_lock(&mutex);//加锁 用互斥锁保护
    33.                 pthread_cond_wait(&cond,&mutex);//加锁，解锁
    34.                 pthread_mutex_unlock(&mutex);//解锁
    35.  
    36.                 if(strncmp(s,"end",3)==0)
    37.                 {
    38.                         break;
    39.                 }
    40.                 printf("funb: %s",s);
    41.         }
    42. }
    43.  
    44. int main()
    45. {
    46. 	pthread_mutex_init(&mutex,NULL);
    47. 	pthread_cond_init(&cond,NULL);
    48. 	char buff[128]={0};
    49. 	pthread_t id1,id2;
    50. 	pthread_create(&id1,NULL,funa,(void*)buff);
    51. 	pthread_create(&id2,NULL,funb,(void*)buff);
    52. 	while(1)
    53. 	{
    54. 		fgets(buff,128,stdin);
    55. 		if(strncmp(buff,"end",3)==0)
    56. 		{
    57. 			//唤醒所有线程
    58. 			pthread_cond_broadcast(&cond);
    59. 			break;
    60. 		}
    61. 		else
    62. 		{
    63. 			//唤醒一个线程
    64. 			pthread_cond_signal(&cond);
    65. 		}
    66.  
    67. 	}
    68. 	pthread_join(id1,NULL);
    69. 	pthread_join(id2,NULL);
    70. 	pthread_mutex_destroy(&mutex);
    71. 	pthread_cond_destroy(&cond);
    72. }

  • 相关阅读:
    rpm命令应用
    SSH协议简介与使用
    靠着腾讯的「操作系统笔记」，成功帮我拿下了 3 个大厂的 offer
    月光宝盒（vivo流量录制回放平台）正式对外开源
    MySQL索引结构B+树
    Ai绘画描述词 关键词大全 真人美女 二次元卡通美女 国漫动漫效果
    Proxy代理配置解析
    用递归实现字符串逆序（不使用库函数）
    java使用RestHighLevelClient操作elasticsearch客户端异常Content-Type: text/html
    OpenAI发布ChatGPT：程序员瞬间不淡定了
  • 原文地址：https://blog.csdn.net/qq_53830608/article/details/127909775