AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

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

2024-06-21 66
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 本文介绍了C++中使用C语言的pthread库实现多线程编程。`pthread_create`用于创建新线程，`pthread_self`返回当前线程ID。示例展示了如何创建线程并打印线程ID，强调了线程同步的重要性，如使用`sleep`防止主线程提前结束导致子线程未执行完。`pthread_exit`用于线程退出，`pthread_join`用来等待并回收子线程，`pthread_detach`则分离线程。文中还提到了线程取消功能，通过`pthread_cancel`实现。这些基本操作是理解和使用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: demo1

demo1: Create_Thread.c

    gcc -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. 使用子线程栈
    在我们接收子线程数据的时候可以通过子线程栈来回收子线程数据，示例代码如下:
    ```cpp

    include

    include

    include

    include

    include

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;
}

我们编译运行后结果如下：
```cpp
主线程id:139934351951680
子线程id:139934351947520id=0
id=1
id=2
id=3
id=4
id=5
id=6
id=0
name=
age=22476544
子线程数据成功接收

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

  1. 使用全局变量
    ```cpp

    include

    include

    include

    include

    include

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;
}

输出结果为:
```text
主线程id:140702000142144
子线程id:140702000137984id=0
id=1
id=2
id=3
id=4
id=5
id=6
id=1
name=张三
age=20
子线程数据成功接收
  1. 使用主线程栈
    虽然线程之间有自己的栈空间，但是它们彼此之间也可以互相访问，而一般主线程都是最后退出的，所以我们可以尝试把子线程返回的数据保存到了主线程的栈区内存中。
    ```cpp

    include

    include

    include

    include

    include

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`就接收不到子线程资源了，线程分离函数定义如下:
```cpp
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语言
Linux
存储
关键词：
C++线程
C++多线程
多线程线程
线程多线程
C++多线程线程
落雨便归尘
目录
相关文章
最好zzz
|
15天前
|
缓存 安全 C++
C++无锁队列：解锁多线程编程新境界
【10月更文挑战第27天】
最好zzz
30 7
潇洒洒
|
15天前
|
消息中间件 存储 安全
深入探索C++无锁队列：多线程编程的高效利器
【10月更文挑战第19天】
潇洒洒
63 6
小王老师呀
|
22天前
|
存储 并行计算 安全
C++多线程应用
【10月更文挑战第29天】C++ 中的多线程应用广泛，常见场景包括并行计算、网络编程中的并发服务器和图形用户界面（GUI）应用。通过多线程可以显著提升计算速度和响应能力。示例代码展示了如何使用 `pthread` 库创建和管理线程。注意事项包括数据同步与互斥、线程间通信和线程安全的类设计，以确保程序的正确性和稳定性。
小王老师呀
23 5
龙大吉
|
23天前
|
Java 开发者
在Java多线程编程中，创建线程的方法有两种：继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中，创建线程的方法有两种：继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱，帮助你更好地理解和选择适合项目需求的线程创建方式。
龙大吉
17 3
东方睿赢
|
23天前
|
Java 开发者
在Java多线程编程中，选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中，选择合适的线程创建方法至关重要。本文通过案例分析，探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景，帮助开发者做出明智的选择。
东方睿赢
16 2
东方睿赢
|
23天前
|
Java
Java中多线程编程的基本概念和创建线程的两种主要方式：继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析：线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式：继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景，帮助读者更好地理解和掌握多线程编程技术，为复杂任务的高效处理奠定基础。
东方睿赢
28 2
龙大吉
|
23天前
|
Java 开发者
Java多线程初学者指南：介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点
【10月更文挑战第20天】Java多线程初学者指南：介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点，重点解析为何实现Runnable接口更具灵活性、资源共享及易于管理的优势。
龙大吉
28 1
众所周知
|
23天前
|
安全 Java 开发者
Java多线程中的`wait()`、`notify()`和`notifyAll()`方法，探讨了它们在实现线程间通信和同步中的关键作用
本文深入解析了Java多线程中的`wait()`、`notify()`和`notifyAll()`方法，探讨了它们在实现线程间通信和同步中的关键作用。通过示例代码展示了如何正确使用这些方法，并分享了最佳实践，帮助开发者避免常见陷阱，提高多线程程序的稳定性和效率。
众所周知
33 1
众所周知
|
23天前
|
Java
在Java多线程编程中，`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。
在Java多线程编程中，`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。它们通过基于锁的方式，使线程在条件不满足时进入休眠状态，并在条件成立时被唤醒，从而有效解决数据一致性和同步问题。本文通过对比其他通信机制，展示了 `wait()` 和 `notify()` 的优势，并通过生产者-消费者模型的示例代码，详细说明了其使用方法和重要性。
众所周知
24 1
蓝易云
|
1月前
|
存储 运维 NoSQL
Redis为什么最开始被设计成单线程而不是多线程
总之，Redis采用单线程设计是基于对系统特性的深刻洞察和权衡的结果。这种设计不仅保持了Redis的高性能，还确保了其代码的简洁性、可维护性以及部署的便捷性，使之成为众多应用场景下的首选数据存储解决方案。
蓝易云
40 1

热门文章

最新文章

  • 1
    2015级C++第10、11周补充实践项目 继承和派生
  • 2
    读书笔记 effective c++ Item 53 关注编译器发出的警告
  • 3
    C++11中的tuple应用：让函数返回多个值
  • 4
    C++中消息自动派发之一 About JSON
  • 5
    C++智能指针(auto_ptr)详解
  • 6
    C++第1周项目2——日期结构体
  • 7
    《Effective C++》item25：考虑写出一个不抛异常的swap函数
  • 8
    Visual C++ 时尚编程百例002(MFC窗口)
  • 9
    C/C++中#define的探究
  • 10
    2013级C++第1周(春)项目——枚举类型与结构体初步
  • 1
    C语言8 数组与字符串
    32
  • 2
    C语言7 控制语句
    23
  • 3
    C语言4 运算符
    47
  • 4
    C语言3 变量
    32
  • 5
    C语言2 常量
    19
  • 6
    C语言1 数据类型
    22
  • 7
    C语言5 字符输出函数和格式输出函数
    91
  • 8
    C语言6 字符串输入和格式输入函数
    59
  • 9
    C语言宏IS_REACHABLE
    40
  • 10
    基于SpringBoot+Vue+uniapp的C语言在线评测系统的详细设计和实现(源码+lw+部署文档+讲解等)
    52

    • 相关课程

    更多
  • C++ 入门教程开发文档
  • 你的第一门C语言课
  • C语言学习教程
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • Python语言基础 - 函数、面向对象、异常处理
  • Java面向对象编程

    • 相关电子书

    更多
  • 使用C++11开发PHP7扩展
  • GPON Class C++ SFP O;T Transce
  • GPON Class C++ SFP OLT Transce

    • 相关实验场景

    更多
  • 语言入门-2：基本类型
  • 语言入门-1：环境构建
  • 使用Java面向对象编写网络通信程序应用
  • Python网络通信程序典型应用
    • 下一篇
    阿里云OSS设置跨域访问