• Linux 多线程编程详解

    目录

    为什么要使用多线程

    线程概念

    线程的标识 pthread_t

    线程的创建

    向线程传入参数

    线程的退出与回收

    线程主动退出

    线程被动退出

    线程资源回收(阻塞方式)

    线程资源回收(非阻塞方式)

    为什么要使用多线程

    在编写代码时，是否会遇到以下的场景会感觉到难以下手？

    要做 2 件事，一件需要阻塞等待，另一件需要实时进行。例如播放器：一边 在屏幕上播放视频，一边在等待用户的按键操作。如果使用单线程的话，程序必 须一会查询有无按键，一会播放视频。查询按键太久，就会导致视频播放卡顿； 视频播放太久，就无法及时响应用户的操作。并且查询按键和播放视频的代码混杂在一起，代码丑陋。

    如果使用多线程，线程 1 单独处理按键，线程 2 单独处理播放，可以完美解决上述问题

    线程概念

    所谓线程，就是操作系统所能调度的最小单位。

    普通的进程，只有一个线程在执行对应的逻辑。我们可以通过多线程编程，使一个进程可以去执行多个不同的任务。相比多进程编程而言，线程享有共享资源，即在进程中出现的全局变量， 每个线程都可以去访问它，与进程共享“4G”内存空间，使得系统资源消耗减少。 本章节来讨论 Linux 下 POSIX 线程。

    线程的标识 pthread_t

    对于进程而言，每一个进程都有一个唯一对应的 PID 号来表示该进程

    而对于线程而言，也有一个“类似于进程的 PID 号”，名为 tid，其本质是一个 pthread_t 类型的变量。线程号与进程号是表示线程和进程的唯一标识，但是对于线程号而言，其仅仅在其所属的进程上下文中才有意义。

    获取线程号

    #include

    pthread_t pthread_self(void);

    成功：返回线程号

    在程序中，可以通过函数 pthread_self，来返回当前线程的线程号，例程 1 给出了打印线程 tid 号。

    测试例程 1：（Phtread_txex1.c）

    1. #include 
    2. #include 
    3.  
    4. int main()
    5. {
    6. 	pthread_t tid = pthread_self();
    7. 	printf("tid = %lu\n",(unsigned long)tid);
    8. 	return 0;
    9. }

    因采用 POSIX 线程接口，故在要编译的时候包含 pthread 库

    使用 gcc 编译应 gcc xxx.c -lpthread 方可编译多线程程序

    编译结果：

    线程的创建

    怎么创建线程呢？

    使用 pthread_create 函数：

    创建线程

    #include

    int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);

    • 第一个参数为 pthread_t 指针，用来保存新建线程的线程号；
    • 第二个参数表示了线程的属性，一般传入 NULL 表示默认属性；
    • 第三个参数是一个函数指针，就是线程执行的函数。这个函数返回值为 void*， 形参为 void*。
    • 第四个参数则表示为向线程处理函数传入的参数，若不传入，可用 NULL 填充， 有关线程传参后续小节会有详细的说明，接下来通过一个简单例程来使用该函数创建出一个线程。

    测试例程 2：（Phtread_txex2.c）

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. void *fun(void *arg)
    7. {
    8. 	printf("pthread_New = %lu\n",(unsigned long)pthread_self());
    9. }
    10.  
    11. int main()
    12. {
    13.  
    14. 	pthread_t tid1;
    15. 	int ret = pthread_create(&tid1,NULL,fun,NULL);
    16. 	if(ret != 0){
    17. 		perror("pthread_create");
    18. 		return -1;
    19. 	}
    20.  
    21. 	/*tid_main 为通过pthread_self获取的线程ID，tid_new通过执行pthread_create成功后tid指向的空间*/
    22. 	printf("tid_main = %lu tid_new = %lu \n",(unsigned long)pthread_self(),(unsigned long)tid1);
    23. 	
    24. 	/*因线程执行顺序随机，不加sleep可能导致猪线程先执行，导致进程结束，无法执行到子线程*/
    25. 	sleep(1);
    26.  
    27. 	return 0;
    28. }

    运行结果：

    通过 pthread_create 确 实 可 以 创 建 出 来 线 程 ， 主 线 程 中 执 行 pthread_create 后 的 tid 指向了线程号空间，与子线程通过函数 pthread_self 打印出来的线程号一致。

    特别说明的是，当主线程伴随进程结束时，所创建出来的线程也会立即结束， 不会继续执行。并且创建出来的线程的执行顺序是随机竞争的，并不能保证哪一 个线程会先运行。可以将上述代码中 sleep 函数进行注释，观察实验现象。

    上述运行代码 3 次，其中有 2 次被进程结束，无法执行到子线程的逻辑，最后一 次则执行到了子线程逻辑后结束的进程。如此可以说明，线程的执行顺序不受控制，且整个进程结束后所产生的线程也随之被释放，在后续内容中将会描述如何 控制线程执行。

    向线程传入参数

    pthread_create()的最后一个参数的为 void*类型的数据，表示可以向线 程传递一个 void*数据类型的参数，线程的回调函数中可以获取该参数，例程 3 举例了如何向线程传入变量地址与变量值。

    测试例程 3：（Phtread_txex3.c）

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. void *fun1(void *arg)
    7. {
    8. 	printf("%s:arg = %d Addr = %p\n",__FUNCTION__,*(int *)arg,arg);
    9. }
    10.  
    11. void *fun2(void *arg)
    12. {
    13. 	printf("%s:arg = %d Addr = %p\n",__FUNCTION__,(int)(long)arg,arg);
    14. }
    15.  
    16. int main()
    17. {
    18.  
    19. 	pthread_t tid1,tid2;
    20. 	int a = 50;
    21. 	int ret = pthread_create(&tid1,NULL,fun1,(void *)&a); // 21 创建线程传入变量 a 的地址
    22. 	if(ret != 0){
    23. 		perror("pthread_create");
    24. 		return -1;
    25. 	}
    26. 	ret = pthread_create(&tid2,NULL,fun2,(void *)(long)a); // 27 创建线程传入变量 a 的值
    27. 	if(ret != 0){
    28. 		perror("pthread_create");
    29. 		return -1;
    30. 	}
    31. 	sleep(1);
    32. 	printf("%s:a = %d Add = %p \n",__FUNCTION__,a,&a);
    33. 	return 0;
    34. }

    运行结果：

    例程展示了如何利用线程创建函数的第四个参数向线程传入数据，举例了如何以地址的方式传入值、以变量的方式传入值，

    例程代码的 21 行，是将变量 a 先行取地址后，再次强制类型转化为 void*后传入线程，线程处理的回调函数 中，先将万能指针 void*转化为 int*，再次取地址就可以获得该地址变量的值， 其本质在于地址的传递。

    例程代码的 27 行，直接将 int 类型的变量强制转化为 void*进行传递（针对不同位数机器，指针对其字数不同，需要 int 转化为 long 在转指针，否则可能会发生警告），在线程处理回调函数中，直接将 void*数据转 248 / 566 化为 int 类型即可，本质上是在传递变量 a 的值。 上述两种方法均可得到所要的值，但是要注意其本质，一个为地址传递，一 个为值的传递。当变量发生改变时候，传递地址后，该地址所对应的变量也会发 生改变，但传入变量值的时候，即使地址指针所指的变量发生变化，但传入的为 变量值，不会受到指针的指向的影响，实际项目中切记两者之间的区别。具体说明见例程 4。

    测试例程 4：（Phtread_txex4.c）

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. void *fun1(void *arg)
    7. {
    8. 	while(1){
    9. 	
    10. 		printf("%s:arg = %d Addr = %p\n",__FUNCTION__,*(int *)arg,arg);
    11. 		sleep(1);
    12. 	}
    13. }
    14.  
    15. void *fun2(void *arg)
    16. {
    17. 	while(1){
    18. 	
    19. 		printf("%s:arg = %d Addr = %p\n",__FUNCTION__,(int)(long)arg,arg);
    20. 		sleep(1);
    21. 	}
    22. }
    23.  
    24. int main()
    25. {
    26.  
    27. 	pthread_t tid1,tid2;
    28. 	int a = 50;
    29. 	int ret = pthread_create(&tid1,NULL,fun1,(void *)&a);
    30. 	if(ret != 0){
    31. 		perror("pthread_create");
    32. 		return -1;
    33. 	}
    34. 	sleep(1);
    35. 	ret = pthread_create(&tid2,NULL,fun2,(void *)(long)a);
    36. 	if(ret != 0){
    37. 		perror("pthread_create");
    38. 		return -1;
    39. 	}
    40. 	while(1){
    41. 		a++;
    42. 		sleep(1);
    43. 		printf("%s:a = %d Add = %p \n",__FUNCTION__,a,&a);
    44. 	}
    45. 	return 0;
    46. }

    运行结果：

    上述例程讲述了如何向线程传递一个参数，在处理实际项目中，往往会遇到 传递多个参数的问题，我们可以通过结构体来进行传递，解决此问题。

    测试例程 5：（Phtread_txex5.c）

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. struct Stu{
    8. 	int Id;
    9. 	char Name[32];
    10. 	float Mark;
    11. };
    12.  
    13. void *fun1(void *arg)
    14. {
    15. 	struct Stu *tmp = (struct Stu *)arg;
    16. 	printf("%s:Id = %d Name = %s Mark = %.2f\n",__FUNCTION__,tmp->Id,tmp->Name,tmp->Mark);
    17. 	
    18. }
    19.  
    20. int main()
    21. {
    22.  
    23. 	pthread_t tid1,tid2;
    24. 	struct Stu stu;
    25. 	stu.Id = 10000;
    26. 	strcpy(stu.Name,"ZhangSan");
    27. 	stu.Mark = 94.6;
    28.  
    29. 	int ret = pthread_create(&tid1,NULL,fun1,(void *)&stu);
    30. 	if(ret != 0){
    31. 		perror("pthread_create");
    32. 		return -1;
    33. 	}
    34. 	printf("%s:Id = %d Name = %s Mark = %.2f\n",__FUNCTION__,stu.Id,stu.Name,stu.Mark);
    35. 	sleep(1);
    36. 	return 0;
    37. }

    运行结果：

    线程的退出与回收

    线程的退出情况有三种：第一种是进程结束，进程中所有的线程也会随之结束。

    第二种是通过函数 pthread_exit 来主动的退出线程。

    第三种被其他线程调用 pthread_cancel 来被动退出。

    当线程结束后，主线程可以通过函数 pthread_join/pthread_tryjoin_np 来回收线程的资源，并且获得线程结束后需要返回的数据。

    线程主动退出

    pthread_exit 函数原型如下：

    线程主动退出

    #include

    void pthread_exit(void *retval);

    pthread_exit 函数为线程退出函数，在退出时候可以传递一个 void*类型的数据带给主线程，若选择不传出数据，可将参数填充为 NULL。

    线程被动退出

    pthread_cancel 函数原型如下：

    线程被动退出，其他线程使用该函数让另一个线程退出

    #include  

    int pthread_cancel(pthread_t thread);

    成功：返回 0

    该函数传入一个 tid 号，会强制退出该 tid 所指向的线程，若成功执行会返回 0。

    线程资源回收(阻塞方式)

    thread_join 函数原型如下：

    线程资源回收（阻塞）

    #include  

    int pthread_join(pthread_t thread, void **retval);

    该函数为线程回收函数，默认状态为阻塞状态，直到成功回收线程后才返回。第一个参数为要回收线程的 tid 号，第二个参数为线程回收后接受线程传出的数据。

    线程资源回收(非阻塞方式)

    pthread_tryjoin_np 函数原型如下：

    线程资源回收（非阻塞）

    #define _GNU_SOURCE

    #include  

    int pthread_tryjoin_np(pthread_t thread, void **retval);

    该函数为非阻塞模式回收函数，通过返回值判断是否回收掉线程，成功回 收则返回 0，其余参数与 pthread_join 一致。

    测试例程 6：（Phtread_txex6.c）

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. void *fun1(void *arg)
    7. {
    8. 	static int tmp = 0; // 8 必须要static修饰，否则pthread_join无法获取到正确值
    9. 	//int tmp = 0;
    10. 	tmp = *(int *)arg;
    11. 	tmp+=100;
    12. 	printf("%s:Addr = %p tmp = %d\n",__FUNCTION__,&tmp,tmp);
    13. 	pthread_exit((void *)&tmp);
    14. }
    15.  
    16.  
    17. int main()
    18. {
    19.  
    20. 	pthread_t tid1;
    21. 	int a = 50;
    22. 	void *Tmp = NULL;
    23. 	int ret = pthread_create(&tid1,NULL,fun1,(void *)&a); // 23
    24. 	if(ret != 0){
    25. 		perror("pthread_create");
    26. 		return -1;
    27. 	}
    28. 	pthread_join(tid1,&Tmp);
    29. 	printf("%s:Addr = %p Val = %d\n",__FUNCTION__,Tmp,*(int *)Tmp);
    30. 	return 0;
    31. }

    运行结果：

    上述例程先通过 23 行将变量以地址的形式传入线程，在线程中做出了自加 100 的操作，当线程退出的时候通过线程传参，用 void*类型的数据通过 pthread_join 接 受 。 此 例 程 去 掉 了 之 前 加 入 的 sleep 函 数 ， 原 因 是 pthread_join 函数具备阻塞的特性，直至成功收回掉线程后才会冲破阻塞，因 此不需要靠考虑主线程会执行到 30 行结束进程的情况。

    特别要说明的是例程第 8 行，当变量从线程传出的时候，需要加 static 修饰，对生命周期做出延续， 否则无法传出正确的变量值。

    测试例程 7：（Phtread_txex7.c）

    1. #define _GNU_SOURCE 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. void *fun(void *arg)
    8. {
    9. 	printf("Pthread:%d Come !\n",(int )(long)arg+1);
    10. 	pthread_exit(arg);
    11. }
    12.  
    13.  
    14. int main()
    15. {
    16. 	int ret,i,flag = 0;
    17. 	void *Tmp = NULL;
    18. 	pthread_t tid[3];
    19. 	for(i = 0;i < 3;i++){
    20. 		ret = pthread_create(&tid[i],NULL,fun,(void *)(long)i);
    21. 		if(ret != 0){
    22. 			perror("pthread_create");
    23. 			return -1;
    24. 		}
    25. 	}
    26. 	while(1){
    27. 		for(i = 0;i <3;i++){
    28. 			if(pthread_tryjoin_np(tid[i],&Tmp) == 0){
    29. 				printf("Pthread : %d exit !\n",(int )(long )Tmp+1);
    30. 				flag++;	
    31. 			}
    32. 		}
    33. 		if(flag >= 3) break;
    34. 	}
    35. 	return 0;
    36. }

    运行结果：

    例程 7 展示了如何使用非阻塞方式来回收线程，此外也展示了多个线程可 以指向同一个回调函数的情况。

    例程 6 通过阻塞方式回收线程几乎规定了线程回收的顺序，若最先回收的线程未退出，则一直会被阻塞，导致后续先退出的 线程无法及时的回收。

    通过函数 pthread_tryjoin_np，使用非阻塞回收，线程可以根据退出先 后顺序自由的进行资源的回收。

    测试例程 8：（Phtread_txex8.c）

    1. #define _GNU_SOURCE 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. void *fun1(void *arg)
    8. {
    9. 	printf("Pthread:1 come!\n");
    10. 	while(1){
    11. 		sleep(1);
    12. 	}
    13. }
    14.  
    15. void *fun2(void *arg)
    16. {
    17. 	printf("Pthread:2 come!\n");
    18. 	pthread_cancel((pthread_t )(long)arg); // 杀死线程 1，使之强制退出
    19. 	pthread_exit(NULL);
    20. }
    21.  
    22. int main()
    23. {
    24. 	int ret,i,flag = 0;
    25. 	void *Tmp = NULL;
    26. 	pthread_t tid[2];
    27. 	ret = pthread_create(&tid[0],NULL,fun1,NULL); // 27
    28. 	if(ret != 0){
    29. 		perror("pthread_create");
    30. 		return -1;
    31. 	}
    32. 	sleep(1);
    33. 	ret = pthread_create(&tid[1],NULL,fun2,(void *)tid[0]); // 33 传输线程 1 的线程号
    34.  
    35. 	if(ret != 0){
    36. 		perror("pthread_create");
    37. 		return -1;
    38. 	}
    39. 	while(1){ //通过非阻塞方式收回线程，每次成功回收一个线程变量自增，直至 2 个线程全数回收
    40. 		for(i = 0;i <2;i++){
    41. 			if(pthread_tryjoin_np(tid[i],NULL) == 0){
    42. 				printf("Pthread : %d exit !\n",i+1);
    43. 				flag++;	
    44. 			}
    45. 		}
    46. 		if(flag >= 2) break;
    47. 	}
    48. 	return 0;
    49. }

    运行结果：

    例程 8 展示了如何利用 pthread_cancel 函数主动的将某个线程结束。

    27 行与 33 行创建了线程，将第一个线程的线程号传参形式传入了第二个线程。第一个的线程执行死循环睡眠逻辑，理论上除非进程结束，其永远不会结束，但在第二个线程中调用了 pthread_cancel 函数，相当于向该线程发送一个退出的指令，导致线程被退出，最终资源被非阻塞回收掉。

    此例程要注意第 32 行的 sleep 函数，一定要确保线程 1 先执行，因线程是无序执行，故加入该睡眠函数控制顺序

  • 相关阅读:
    面试题：Redis和MySQL的事务区别是什么？
    FPGA工程师面试试题集锦51~60
    电脑怎么设置定时关机，2个简单的操作
    比较一个5点的结构对平面的分割
    GoLand 2023：为Go开发者打造的智能IDE mac/win版
    MATLAB求解夏普利值
    ES: export 的用法
    微信小程序 实现CBC 加密/解密
    如何实习focus模块——python以及c++的实现方法
    智安网络|提升企业网络安全：避免成为勒索软件攻击的目标
  • 原文地址：https://blog.csdn.net/m0_74712453/article/details/134282116