c++进阶篇——初窥多线程(二) 基于C语言实现的多线程编写

2024-06-22 08:28
文章标签 语言 c++ 实现 编写 多线程 进阶篇

本文主要是介绍c++进阶篇——初窥多线程(二) 基于C语言实现的多线程编写，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

前言

在上一篇文章中我们介绍了在计算机底层视角下的虚拟内存和操作系统在用户层所进行的各个分层，在这篇文章我们就要开始尝试书写多线程代码了,其实在c++11后c++就提供供了线程类给我们使用,c++线程类其实主要是对c操作多线程的函数进行了封装，本质上其实是一致的，所以在讲解我们cpp的多线程编写之前，我觉得先来了解一下C语言是如何实现多线程的编写的，这样可以让我们更好的去理解cpp线程类的工作原理，话不多说，发车发车！

线程的创建

在之前我们讲解Linux下的进程控制时说过我们在创建进程时进程都会有自己的进程编号pid,而线程和它们一样，每一个线程都有唯一的线程编号,它的类型为pthread_t,它是一个无符号长整形数,我们可以调用下面这个函数来获取当前线程的线程编号:

pthread_t ptread_self(void);  //返回当前线程的线程编号

如果我们希望在一个进程中创建子线程,就要调用线程创建函数,但是和进程不同,我们必须要给每一个线程指定一个线程处理函数，否则线程将无法正常工作,处理函数的定义如下:

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);
  • 参数:
    • thread: 传出参数，是无符号长整形数，线程创建成功, 会将线程ID写入到这个指针指向的内存中
    • attr: 线程的属性, 一般情况下使用默认属性即可, 写NULL
    • start_routine: 函数指针，创建出的子线程的处理动作，也就是该函数在子线程中执行。
    • arg: 作为实参传递到 start_routine 指针指向的函数内部
  • 返回值：线程创建成功返回0，创建失败返回对应的错误号

下面我们来看一个线程创建的实例:

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include <pthread.h>// 线程的处理函数
void* work(void* arg)
{printf("子线程id=%ld\n",pthread_self());for(int i=0;i<9;i++){printf("child id=%d\n",i);}return NULL;
}int main(int argc,char* argv[])
{pthread_t tid;pthread_create(&tid,NULL,work,NULL);printf("主线程id=%ld\n",pthread_self());for(int i=0;i<3;i++){printf("main id=%d\n",i);}sleep(10);return 0;
}

注意：
我们在Linux下编译该代码要导入线程库。编译命令如下:

all: demo1demo1: Create_Thread.cgcc -pthread -o demo1 Create_Thread.c clean:rm -f demo1

运行结果如下：

root@iZuf6ckztbjhtavfplgp0dZ:~/mylib/cppdemo/Linux系统编程/多线程/threads(c)# ./demo1
主线程id=139930484275008
main id=0
main id=1
main id=2
子线程id=139930484270848
child id=0
child id=1
child id=2
child id=3
child id=4
child id=5
child id=6
child id=7
child id=8

如果我们去除sleep函数的使用我们会发现结果是这样的:

主线程id=140150867830592
main id=0
main id=1
main id=2

这是因为虚拟地址生存周期是和主线程保持一致的，与子线程无关，主线程提前结束，导致哪怕子线程还没有开始运行，程序也自动停止运行了，这里的sleep函数所起到的作用主要就是线程同步。

线程的退出

在我们编写多线程代码时，如果我们希望让线程退出，但是不希望因此导致虚拟地址空间的释放(主线程突出时会释放)，这时候我们可以调用线程退出函数，这样线程的退出就不会影响其他线程的正常使用了，函数定义如下:

void pthread_exit(void* retval)

- retval：线程退出的时候携带的数据，当前子线程的主线程会得到该数据。如果不需要使用，指定为NULL

下面我们来看一个简单的示例:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>void* work(void* arg)
{sleep(5);printf("子线程运行中,子线程id:%ld\n",pthread_self());\for(int i=1;i<9;i++){printf("id=:%d\n",i);if (i==6){pthread_exit(NULL);}}return NULL;
}int main(int argc,int *argv[])
{pthread_t tid;pthread_create(&tid,NULL,work,NULL);printf("主线程运行中,主线程id:%ld\n",pthread_self());for(int i=0;i<3;i++){printf("id=:%d\n",i);}pthread_exit(NULL);//主线程退出return 0;
}

输出结果为:

主线程运行中,主线程id:140161600366400
id=:0
id=:1
id=:2
子线程运行中,子线程id:140161600362240
id=:1
id=:2
id=:3
id=:4
id=:5
id=:6

我们可以看到虽然主线程提前推出了，但是却并没有影响到子线程的运行。

线程回收

线程回收函数

进程和线程一样，子线程退出的时候它的内核资源是由主线程来回收,线程回收的函数是pthread_join(),该函数是阻塞函数，当有子线程正在运行,调用该函数会阻塞,直到所有子线程都退出后才能进行子线程资源的回收，一次只能回收一个子线程的资源，如果我们有多个子线程资源需要回收，需要借助循环来完成,函数原型如下:

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

参数说明：

  • pid:要被回收的线程编号
  • retval:二级指针,指向一级指针,是一个传出参数 ,一级指针里面储存的是pthread_exit()函数传出的数据，如果不需要该数据可以设为NULL
  • 返回值：线程回收成功返回0，回收失败返回错误号。

回收子线程数据的实现方式

在子线程退出的时候可以通过pthread_join函数来将数据传出,我们在回收子线程的同时也可以接收子线程的数据这样的实现方法有很多种，下面我们来看下面几种:
备注：
导致实现方法多样性的原因： 通过上面的介绍，我们知道子线程在被回收的时候会将数据写入到一块内存中,然后采纳数传出该内存的地址而非是存储数据本身，而传出的参数类型是void*,这个万能指针可以指向任意一块内存，也导致了我们可以通过不同的形式来接收子线程数据。

  1. 使用子线程栈
    在我们接收子线程数据的时候可以通过子线程栈来回收子线程数据，示例代码如下:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>typedef struct Person
{int id;char* name;int age;
}Person;void* work(void* arg)
{printf("子线程id:%ld",pthread_self());for(int i=0;i<9;i++){printf("id=%d\n",i);if (i==6){Person p;p.id=1;p.name="张三";p.age=20;pthread_exit((void*)&p);}}return NULL;
}int main(int argc,char* argv[])
{pthread_t tid;if (pthread_create(&tid,NULL,work,NULL)!=0){printf("线程创建失败");return -1;}printf("主线程id:%ld\n",pthread_self());void *ptr;pthread_join(tid,&ptr);struct Person* p=(struct Person*)ptr;printf("id=%d\n",p->id);printf("name=%s\n",p->name);printf("age=%d\n",p->age);printf("子线程数据成功接收\n");return 0;
}

我们编译运行后结果如下：

主线程id:139934351951680
子线程id:139934351947520id=0
id=1
id=2
id=3
id=4
id=5
id=6
id=0
name=
age=22476544
子线程数据成功接收

我们可以发现在主线程中并没有子线程的数据，这是因为当子线程退出时，子线程所占据的栈区就会被回收，进而导致了子线程想要传递的数据被释放掉了，所以说我们一般不会采取子线程栈来接收数据，而是使用其他方式来接收数据。
2. 使用全局变量

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>typedef struct Person
{int id;char* name;int age;
}Person;Person p;void* work(void* arg)
{printf("子线程id:%ld",pthread_self());for(int i=0;i<9;i++){printf("id=%d\n",i);if (i==6){p.id=1;p.name="张三";p.age=20;pthread_exit((void*)&p);}}return NULL;
}int main(int argc,char* argv[])
{pthread_t tid;if (pthread_create(&tid,NULL,work,NULL)!=0){printf("线程创建失败");return -1;}printf("主线程id:%ld\n",pthread_self());void *ptr;pthread_join(tid,&ptr);struct Person* p=(struct Person*)ptr;printf("id=%d\n",p->id);printf("name=%s\n",p->name);printf("age=%d\n",p->age);printf("子线程数据成功接收\n");return 0;
}

输出结果为:

主线程id:140702000142144
子线程id:140702000137984id=0
id=1
id=2
id=3
id=4
id=5
id=6
id=1
name=张三
age=20
子线程数据成功接收
  1. 使用主线程栈
    虽然线程之间有自己的栈空间，但是它们彼此之间也可以互相访问，而一般主线程都是最后退出的，所以我们可以尝试把子线程返回的数据保存到了主线程的栈区内存中。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>typedef struct Person
{int id;char* name;int age;
}Person;void* work(void* arg)
{Person *p=(Person*)arg;printf("子线程id:%ld",pthread_self());for(int i=0;i<9;i++){printf("id=%d\n",i);if (i==6){p->id=1;p->name="张三";p->age=20;pthread_exit((void*)&p);}}return NULL;
}int main(int argc,char* argv[])
{Person p;pthread_t tid;if (pthread_create(&tid,NULL,work,&p)!=0){printf("线程创建失败");return -1;}printf("主线程id:%ld\n",pthread_self());void *ptr;pthread_join(tid,&ptr);printf("id=%d\n",p.id);printf("name=%s\n",p.name);printf("age=%d\n",p.age);printf("子线程数据成功接收\n");return 0;
}

线程分离

在一些情况下，程序中的主线程会拥有自己的业务处理流程，如果让主线程负责子线程的资源回收，那么调用pthread_join函数在子线程全部结束前主线程会一直阻塞，这时候我们可使用线程分离函数来将该线程剥离出来，调用该函数后子线程会与主线程分离，但是这样pthread_join就接收不到子线程资源了，线程分离函数定义如下:

int pthread_detach(pthread_t id);

示例如下:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>// 子线程的处理代码
void* working(void* arg)
{printf("我是子线程, 线程ID: %ld\n", pthread_self());for(int i=0; i<9; ++i){printf("child == i: = %d\n", i);}return NULL;
}int main()
{//创建一个子线程pthread_t tid;pthread_create(&tid, NULL, working, NULL);printf("子线程创建成功, 线程ID: %ld\n", tid);// 2. 子线程不会执行下边的代码, 主线程执行printf("我是主线程, 线程ID: %ld\n", pthread_self());for(int i=0; i<3; ++i){printf("i = %d\n", i);}// 设置子线程和主线程分离pthread_detach(tid);// 让主线程自己退出即可pthread_exit(NULL);return 0;
}

一些其他的线程函数

线程取消

线程取消指的是我们可以在一个线程中调用它来取消另一个线程，函数定义如下:

int pthread_cancel(pthread_t pid);

代码示例如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>// 子线程的处理代码
void* work(void* arg)
{printf("我是子线程, 线程ID: %ld\n", pthread_self());for(int i=0; i<9; ++i){sleep(1);printf("child == i: = %d\n", i);}return NULL;
}int main()
{//创建一个子线程pthread_t tid;pthread_create(&tid, NULL, work, NULL);printf("子线程创建成功, 线程ID: %ld\n", tid);// 2. 子线程不会执行下边的代码, 主线程执行printf("我是主线程, 线程ID: %ld\n", pthread_self());for(int i=0; i<3; ++i){sleep(1);printf("i = %d\n", i);}// 设置子线程和主线程分离pthread_cancel(tid);// 让主线程自己退出即可pthread_exit(NULL);return 0;
}

输出如下:

我是主线程, 线程ID: 139763539765056
我是子线程, 线程ID: 139763539760896
i = 0
child == i: = 0
i = 1
child == i: = 1
i = 2
child == i: = 2

注意：线程的取消分两步：

  • 主线程基于线程取消函数发送请求
  • 当子线程再次进行系统调用时，线程会被取消(没有这一步，线程就还存在)

结语

关于C语言库中关于线程的函数介绍到此就告一段落了，下一篇文章我们就要开始介绍cpp中一些关于线程的知识了，下篇见!

这篇关于c++进阶篇——初窥多线程(二) 基于C语言实现的多线程编写的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1083766。

相关文章

Spring Boot整合Redis注解实现增删改查功能(Redis注解使用)

Spring Boot整合Redis注解实现增删改查功能(Redis注解使用)

《SpringBoot整合Redis注解实现增删改查功能(Redis注解使用)》文章介绍了如何使用SpringBoot整合Redis注解实现增删改查功能,包括配置、实体类、Repository、Se... 目录配置Redis连接定义实体类创建Repository接口增删改查操作示例插入数据查询数据删除数据更
阅读更多...
Java Lettuce 客户端入门到生产的实现步骤

Java Lettuce 客户端入门到生产的实现步骤

《JavaLettuce客户端入门到生产的实现步骤》本文主要介绍了JavaLettuce客户端入门到生产的实现步骤,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要... 目录1 安装依赖MavenGradle2 最小化连接示例3 核心特性速览4 生产环境配置建议5 常见问题
阅读更多...
linux ssh如何实现增加访问端口

linux ssh如何实现增加访问端口

《linuxssh如何实现增加访问端口》Linux中SSH默认使用22端口,为了增强安全性或满足特定需求,可以通过修改SSH配置来增加或更改SSH访问端口,具体步骤包括修改SSH配置文件、增加或修改... 目录1. 修改 SSH 配置文件2. 增加或修改端口3. 保存并退出编辑器4. 更新防火墙规则使用uf
阅读更多...
Java 的ArrayList集合底层实现与最佳实践

Java 的ArrayList集合底层实现与最佳实践

《Java的ArrayList集合底层实现与最佳实践》本文主要介绍了Java的ArrayList集合类的核心概念、底层实现、关键成员变量、初始化机制、容量演变、扩容机制、性能分析、核心方法源码解析、... 目录1. 核心概念与底层实现1.1 ArrayList 的本质1.1.1 底层数据结构JDK 1.7
阅读更多...
C++中unordered_set哈希集合的实现

C++中unordered_set哈希集合的实现

《C++中unordered_set哈希集合的实现》std::unordered_set是C++标准库中的无序关联容器,基于哈希表实现,具有元素唯一性和无序性特点,本文就来详细的介绍一下unorder... 目录一、概述二、头文件与命名空间三、常用方法与示例1. 构造与析构2. 迭代器与遍历3. 容量相关4
阅读更多...
C++中悬垂引用(Dangling Reference) 的实现

C++中悬垂引用(Dangling Reference) 的实现

《C++中悬垂引用(DanglingReference)的实现》C++中的悬垂引用指引用绑定的对象被销毁后引用仍存在的情况,会导致访问无效内存,下面就来详细的介绍一下产生的原因以及如何避免,感兴趣... 目录悬垂引用的产生原因1. 引用绑定到局部变量，变量超出作用域后销毁2. 引用绑定到动态分配的对象，对象
阅读更多...
SpringBoot基于注解实现数据库字段回填的完整方案

SpringBoot基于注解实现数据库字段回填的完整方案

《SpringBoot基于注解实现数据库字段回填的完整方案》这篇文章主要为大家详细介绍了SpringBoot如何基于注解实现数据库字段回填的相关方法,文中的示例代码讲解详细,感兴趣的小伙伴可以了解... 目录数据库表pom.XMLRelationFieldRelationFieldMapping基础的一些代
阅读更多...
Java HashMap的底层实现原理深度解析

Java HashMap的底层实现原理深度解析

《JavaHashMap的底层实现原理深度解析》HashMap基于数组+链表+红黑树结构,通过哈希算法和扩容机制优化性能,负载因子与树化阈值平衡效率,是Java开发必备的高效数据结构,本文给大家介绍... 目录一、概述：HashMap的宏观结构二、核心数据结构解析1. 数组（桶数组）2. 链表节点（Node
阅读更多...
Java AOP面向切面编程的概念和实现方式

Java AOP面向切面编程的概念和实现方式

《JavaAOP面向切面编程的概念和实现方式》AOP是面向切面编程,通过动态代理将横切关注点（如日志、事务）与核心业务逻辑分离,提升代码复用性和可维护性,本文给大家介绍JavaAOP面向切面编程的概... 目录一、AOP 是什么？二、AOP 的核心概念与实现方式核心概念实现方式三、Spring AOP 的关
阅读更多...
从基础到高级详解Go语言中错误处理的实践指南

从基础到高级详解Go语言中错误处理的实践指南

《从基础到高级详解Go语言中错误处理的实践指南》Go语言采用了一种独特而明确的错误处理哲学,与其他主流编程语言形成鲜明对比,本文将为大家详细介绍Go语言中错误处理详细方法,希望对大家有所帮助... 目录1 Go 错误处理哲学与核心机制1.1 错误接口设计1.2 错误与异常的区别2 错误创建与检查2.1 基础
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2