devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

嵌入式学习第二十二天！（线程间通信）

作者：IT小白 | 2024-03-01 01:01:59

赞

踩

嵌入式学习第二十二天！（线程间通信）

线程间通信：

        线程间通信，通过利用全局变量，来实现通信，但是在通信过程中使用这些变量可能会导致资源竞争，那么就需要使用到互斥锁和信息量，辅助我们实现线程的通信。

1. 线程分离属性：

    线程结束后，自动回收线程空间

    1. pthread_attr_init：

int pthread_attr_init(pthread_attr_t *attr);

        功能：线程属性初始化

    2. pthread_attr_destroy：

int pthread_attr_destroy(pthread_attr_t *attr);

        功能：线程属性销毁

    3. pthread_attr_setdetachstate：

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);

        功能：设置分离属性

            PTHREAD_CREATE_DETACHED   分离属性
            PTHREAD_CREATE_JOINABLE   加入属性（默认）

    练习：

       1. 利用线程的分离属性创建三个线程，打印线程id

  1. #include "head.h"
  2.  
  3. void *thread1(void *arg)
  4. {
  5. 	printf("stat to thread1(tid:%#x)\n", (unsigned int)pthread_self());
  6. 	return NULL;
  7. }
  8.  
  9. void *thread2(void *arg)
  10. {
  11. 	printf("stat to thread2(tid:%#x)\n", (unsigned int)pthread_self());
  12. 	return NULL;
  13. }
  14.  
  15. void *thread3(void *arg)
  16. {
  17. 	printf("stat to thread2(tid:%#x)\n", (unsigned int)pthread_self());
  18. 	return NULL;
  19. }
  20.  
  21. int main(void)
  22. {
  23. 	int i = 0;
  24. 	pthread_t thread[3];
  25. 	void *(*p[3])(void *) = {thread1, thread2, thread3};
  26. 	pthread_attr_t attr;
  27.  
  28. 	pthread_attr_init(&attr);
  29. 	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
  30.  
  31. 	for(i = 0; i < 3; i++)
  32. 	{
  33. 		pthread_create(&thread[i], &attr, p[i], NULL);
  34. 	}
  35. 	pthread_attr_destroy(&attr);
  36.  
  37. 	while(1)
  38. 	{
  39.  
  40. 	}
  41.  
  42. }

        2. 首先定义一个学生结构体，包含姓名、性别、年龄、分数。再创建两个两个线程，线程1负责从终端接收学生信息，线程2负责将学生信息打印在终端。

  1. #include "head.h"
  2.  
  3. struct studet
  4. {
  5. 	char name[100];
  6. 	char sex;
  7. 	int age;
  8. 	int score;
  9. };
  10.  
  11. void *InputInfo(void *arg)
  12. {
  13. 	struct studet *stu = arg;
  14. 	char *ptmp = stu->name;
  15.  
  16. 	fgets(stu->name, 100, stdin);
  17. 	ptmp[strlen(ptmp)-1] = '\0';
  18.  
  19. 	scanf("%c", &stu->sex);
  20. 	scanf("%d", &stu->age);
  21. 	scanf("%d", &stu->score);
  22.  
  23. 	return NULL;
  24. }
  25.  
  26. void *OutputInfo(void *arg)
  27. {
  28. 	struct studet *stu = arg;
  29. 	
  30.     sleep(5);
  31. 	printf("%s\n", stu->name);
  32. 	printf("%c\n", stu->sex);
  33. 	printf("%d\n", stu->age);
  34. 	printf("%d\n", stu->score);
  35. 	
  36. 	return NULL;
  37. }
  38.  
  39. int main(void)
  40. {
  41. 	struct studet t;
  42. 	pthread_t input;
  43. 	pthread_t output;
  44. 	
  45. 	pthread_create(&input, NULL, InputInfo, &t);
  46. 	pthread_create(&output, NULL, OutputInfo, &t);
  47.  
  48. 	pthread_join(input, NULL);
  49.     pthread_join(output, NULL);
  50.  
  51. 	return 0;
  52. }

2. 线程互斥：

    1. 互斥锁：

        防止资源竞争

    2. 函数接口：

        1. pthread_mutex_init：
  1. int pthread_mutex_init(pthread_mutex_t *restrict mutex,
  2.            const pthread_mutexattr_t *restrict attr);

            功能：互斥锁初始化

            参数：

                mutex：互斥锁空间首地址
                attr：互斥锁的属性(默认为NULL)

            返回值：

                成功返回0 
                失败返回错误码

        2. pthread_mutex_destroy：
int pthread_mutex_destroy(pthread_mutex_t *mutex);

            功能：互斥锁销毁

            参数：

                mutex：互斥锁空间首地址

            返回值：

                成功返回0 
                失败返回错误码

        3. pthread_mutex_lock：
int pthread_mutex_lock(pthread_mutex_t *mutex);

            功能：上锁

        4. pthread_mutex_unlock：
int pthread_mutex_unlock(pthread_mutex_t *mutex);

            功能：解锁

    3. 临界资源、临界区：

        加锁解锁中间的代码称为临界资源、临界区

        同一时刻临界资源不能同时执行，只能执行其中一个临界资源代码

    4. 原子操作：

        CPU最小的一次不能被任务调度打断的操作称为原子操作

    5. 注意：

        互斥锁只能解决资源竞争的问题，无法同步代码（没有先后执行的顺序关系）

    练习：

        定义三个整型的全局变量Num1, Num2，val，创建两个线程，一个线程循环令Num1=val，Num2=val，val自加；另一个线程，循环判断：当Num1不等于Num2的时候，输出Num1和Num2的值。利用互斥锁，让Num1始终等于Num2，使终端没有输出。

  1. #include "head.h"
  2.  
  3. int val = 0;
  4. int Num1 = 0;
  5. int Num2 = 0;
  6. pthread_mutex_t lock;
  7.  
  8. void *thread1(void *arg)
  9. {
  10. 	while(1)
  11. 	{
  12. 		pthread_mutex_lock(&lock);
  13. 		Num1 = val;
  14. 		Num2 = val;
  15. 		pthread_mutex_unlock(&lock);
  16. 		val++;
  17. 	}
  18. 	return NULL;
  19. }
  20. void *thread2(void *arg)
  21. {
  22. 	while(1)
  23. 	{
  24. 		pthread_mutex_lock(&lock);
  25. 		if(Num1 != Num2)
  26. 		{
  27. 			printf("Num1 = %d, Num2 = %d\n", Num1, Num2);
  28. 		}
  29. 		pthread_mutex_unlock(&lock);
  30. 	}
  31. 	return NULL;
  32. }
  33.  
  34.  
  35. int main(void)
  36. {
  37. 	pthread_t tid1;
  38. 	pthread_t tid2;
  39. 	
  40. 	pthread_mutex_init(&lock, NULL);
  41.  
  42. 	pthread_create(&tid1, NULL, thread1, NULL);
  43. 	pthread_create(&tid2, NULL, thread2, NULL);
  44.  
  45. 	pthread_join(tid1, NULL);
  46. 	pthread_join(tid2, NULL);
  47.  
  48. 	pthread_mutex_destroy(&lock);
  49. 	
  50. 	return 0;
  51. }

3. 死锁：

    多线程操作互斥锁，导致多个线程均违法向下执行的状态称为死锁状态，简称为死锁

    1. 死锁产生的四个必要条件：

        1. 互斥条件

        2. 不可剥夺条件

        3. 请求保持

        4. 循环等待

    2. 如何避免产生死锁：

        1. pthread_mutex_trylock 替代 pthread_mutex_lock

        2. 加锁顺序保持一致

4. 信号量：

    信号量是一种资源，可以被初始化、申请、释放、销毁

    P操作：申请资源

    V操作：释放资源

    1. sem_init：

int sem_init(sem_t *sem, int pshared, unsigned int value);

        功能：初始化信号量

        参数：

            sem：信号量空间首地址

            pshared：为0的话，是一个进程中的所有线程间共享；非0的话，则是进程间共享

            value：初始化的值

        返回值：

           成功返回0 
           失败返回-1 

    2. sem_destory：

int sem_destroy(sem_t *sem);

        功能：信号量的销毁

        参数：

            sem：信号量空间首地址

        返回值：

            成功返回0 
            失败返回-1

    3. sem_wait：

int sem_wait(sem_t *sem);

        功能：申请信号量

    4. sem_post：

int sem_post(sem_t *sem);

        功能：释放信号量

作业：

        1. 创建三个线程分别循环打印 A B C，要求打印出来的顺序总是 A -> B -> C

  1. #include "head.h"
  2.  
  3. sem_t sem_a;
  4. sem_t sem_b;
  5. sem_t sem_c;
  6.  
  7. void *thread1(void* arg)
  8. {
  9. 	while(1)
  10. 	{
  11. 		sem_wait(&sem_a);
  12. 		printf("A\n");
  13. 		sem_post(&sem_b);
  14. 	}
  15.  
  16. 	return NULL;
  17. }
  18. void *thread2(void* arg)
  19. {
  20. 	while(1)
  21. 	{
  22. 		sem_wait(&sem_b);
  23. 		printf("B\n");
  24. 		sem_post(&sem_c);
  25. 	}
  26.  
  27. 	return NULL;
  28. }
  29. void *thread3(void* arg)
  30. {
  31. 	while(1)
  32. 	{
  33. 		sem_wait(&sem_c);
  34. 		printf("C\n");
  35. 		sem_post(&sem_a);
  36. 	}
  37.  
  38. 	return NULL;
  39. }
  40.  
  41. int main(void)
  42. {
  43. 	int i = 0;
  44. 	pthread_t tid[3];
  45. 	void *(*p[3])(void *) = {thread1, thread2, thread3};
  46. 	
  47. 	sem_init(&sem_a, 0, 1);
  48. 	sem_init(&sem_b, 0, 0);
  49. 	sem_init(&sem_c, 0, 0);
  50.  
  51. 	for(i = 0; i < 3; i++)
  52. 	{
  53. 		pthread_create(&tid[i], NULL, p[i], NULL);
  54. 	}
  55.  
  56. 	for(i = 0; i < 3; i++)
  57. 	{
  58. 		pthread_join(tid[i], NULL);
  59. 	}
  60.  
  61. 	sem_destroy(&sem_a);
  62. 	sem_destroy(&sem_b);
  63. 	sem_destroy(&sem_c);
  64.  
  65. 	return 0;
  66.  
  67. }

        2. PTA | 程序设计类实验辅助教学平台

  1. #include <stdio.h>
  2.  
  3. struct student
  4. {
  5. 	char number[20];
  6. 	int testbit;
  7. 	int exambit;
  8. };
  9.  
  10. int GetStudentBit(struct student *pstu, int maxlen)
  11. {
  12. 	int n = 0;
  13. 	int i = 0;
  14.  
  15. 	scanf("%d", &n);
  16.  
  17. 	if(n > maxlen)
  18. 	{
  19. 		perror("Over to limit");
  20. 		return -1;
  21. 	}
  22.  
  23. 	for(i = 0; i < n; i++)
  24. 	{
  25. 		scanf("%s %d %d", pstu[i].number, &pstu[i].testbit, &pstu[i].exambit);
  26. 	}
  27.  
  28. 	return n;
  29. }
  30. int GetFoundBit(int *pbit, int maxlen)
  31. {
  32. 	int m = 0;
  33. 	int i = 0;
  34.  
  35. 	scanf("%d", &m);
  36.  
  37. 	if(m > maxlen)
  38. 	{
  39. 		perror("Over to limit");
  40. 		return -1;
  41. 	}
  42.  
  43. 	for(i = 0; i < m; i++)
  44. 	{
  45. 		scanf("%d", &pbit[i]);
  46.  
  47. 	}
  48. 	return m;
  49. }
  50.  
  51. int PrintStudentBit(struct student *pstu, int curlen, int *pfound, int m)
  52. {
  53. 	int i = 0;
  54. 	int j = 0;
  55.  
  56. 	for(i = 0; i < m; i++)
  57. 	{
  58. 		for(j = 0; j < curlen; j++)
  59. 		{
  60. 			if(pstu[j].testbit == pfound[i])
  61. 			{
  62. 				printf("%s %d\n", pstu[j].number, pstu[j].exambit);
  63. 			}
  64. 		}
  65. 	}
  66. 	
  67. 	return 0;
  68.  
  69. }
  70.  
  71. int main(void)
  72. {
  73. 	struct student stu[1000];
  74. 	int curlen = 0;
  75. 	int bitinfo[1000];
  76. 	int foundnum = 0;
  77. 	
  78. 	curlen = GetStudentBit(stu, 1000);
  79. 	foundnum = GetFoundBit(bitinfo, 1000);
  80. 	
  81. 	PrintStudentBit(stu, curlen, bitinfo, foundnum);
  82.  
  83. 	return 0;
  84. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/169821
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号