【Linux】线程操作

已于 2024-05-28 09:21:58 修改
阅读量1.1k 收藏 28
点赞数 10
分类专栏： Linux 文章标签： linux
于 2024-05-27 19:05:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62714628/article/details/139217818
版权

文章目录

前言

在 Linux 中并不存在真正意义上的线程, 而是通过复用进程的结构来实现的, 叫做轻量级进程. 线程是一个进程内部的一个执行流, 而一个进程最少都有一个线程, 就是该进程本身, 线程在进程内部运行，本质是在进程地址空间内运行, 透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流.

进程是资源分配的基本单位, 线程是调度的基本单位.

一、线程相关操作函数

1. pthread_create

头文件: #include <pthread.h>
函数声明: int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);

  • 返回值: 成功返回 0, 失败返回 errno.
  • thread: 输出型参数, 返回线程 id.
  • attr: 设置线程的属性, attr 为 NULL 表示使用默认属性.
  • start_routine: 函数指针, 该线程执行的函数.
  • arg: 传递给 start_routine 的参数.

功能: 创建一个线程, 该线程会执行 start_routine 函数.

示例代码(入口函数不传参):

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;

void* ThreadRoutine(void* arg)
{
    for(int i = 0; i < 5; ++i)
    {
        cout << "Hello World" << endl;
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, ThreadRoutine, nullptr);
    pthread_join(tid, nullptr);
    return 0;
}

运行结果:
在编译时会出现如下问题:
在这里插入图片描述
提示我们使用的函数是未定义的, 原因就在于使用了线程库提供的函数没有链接该库, 在 makefile 文件中指明库名即可, 如下:
在这里插入图片描述
此时再编译就没问题了, 运行结果如下:
在这里插入图片描述
程序运行后, 该线程执行流就会去执行其入口函数了, 通过监控脚本观察此时确实有两个线程:
在这里插入图片描述
可以看到监控显示的信息中, 有一个熟悉的字段 PID, 这个 PID 也就是我们跑起来的一个进程, 而字段 LWP(Light Weight Process) 表示轻量级进程, 可以得知在该进程中存在两个执行流, 也就是两个线程, 而其中一个线程的 LWP 和 PID 是一致的, 该线程就是我们的主线程, 此前我们认为的一个进程在 Linux 中其实就是一个只有一个执行流的进程, 所以说在 Linux 中并不存在真正意义上的线程, 在一个进程的内部可以存在多个线程, 并且每个线程都共享所处进程的部分数据, 大致如下图所示:
在这里插入图片描述
整个图表示一个进程, 里面的各个 task_struct 表示一个线程.

示例代码(入口函数传递内置类型):

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;

void* ThreadRoutine(void* arg)
{
    const char* buf = static_cast<const char*>(arg);
    for(int i = 0; i < 5; ++i)
    {
        cout << buf << "Hello World" << endl;
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t tid;
    char buf[] = "[wcm]:";
    pthread_create(&tid, nullptr, ThreadRoutine, buf);
    pthread_join(tid, nullptr);
    return 0;
}

运行结果:
在这里插入图片描述
入口函数的参数类型为 void*, 表示我们可以传递任意类型的参数, 在入口函数中使用时, 只需要进行类型转换即可, 返回值也是一样的.

2. pthread_join

头文件: #include <pthread.h>
函数声明: int pthread_join(pthread_t thread, void **retval);

  • 返回值: 成功返回 0, 失败返回 errno.
  • thread: 等待的线程 id.
  • retval: 被等待线程的返回值.

功能: 主线程阻塞式的等待回收一个线程.

实例代码:

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;

void* ThreadRoutine(void* arg)
{
    for(int i = 0; i < 5; ++i)
    {
        cout << "Hello World" << endl;
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, ThreadRoutine, nullptr);
    pthread_join(tid, nullptr);
    return 0;
}

如果 pthread_join 的第二个参数设置为空, 表示不接收等待线程的返回值, 要想接收返回值, 代码如下:

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;

void* ThreadRoutine(void* arg)
{
    const char* buf = static_cast<const char*>(arg);
    for(int i = 0; i < 5; ++i)
    {
        cout << buf << "Hello World" << endl;
        sleep(1);
    }
    return (void*)111;
}

int main()
{
    pthread_t tid;
    char buf[] = "[wcm]:";
    pthread_create(&tid, nullptr, ThreadRoutine, buf);
    void* ret;
    pthread_join(tid, &ret);
    int res = reinterpret_cast<uint64_t>(ret);
    sleep(1);
    cout << "exit code: " << res << endl;
    return 0;
}

运行结果:
在这里插入图片描述

3. pthread_exit

头文件: #include <pthread.h>
函数声明: void pthread_exit(void *retval);

  • retval: 线程的返回值.

功能: 如果在一个线程内使用 exit 来终止该线程, 那么该进程所属的整个进程也会被终止, pthread_exit 只会终止当前线程, 并不会影响进程乃至其他任何线程执行流.

示例代码:

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;

void* ThreadRoutine(void* arg)
{
    const char* buf = static_cast<const char*>(arg);
    for(int i = 0; i < 5; ++i)
    {
        if(i == 3)
        {
            exit(1);
        }
        cout << buf << "Hello World" << endl;
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t tid;
    char buf[] = "[wcm]:";
    pthread_create(&tid, nullptr, ThreadRoutine, buf);
    pthread_join(tid, nullptr);
    sleep(10);
    cout << "main() quit" << endl;
    return 0;
}

先看看线程通过 exit 终止会怎样:
在这里插入图片描述
可以看到, 通过 exit 终止的线程不止本身被终止了, 连带着整个进程都被终止了, 原因也很简单, exit 本身就是终止一个进程的, 而多个线程同属一个进程中, 如果该线程的入口函数中通过 exit 终止了, 那么理所应当的整个进程都会被终止, 而 pthread_exit 只会终止调用线程, 并且还可以携带返回值:

#include <iostream>
#include <cstdio>
#include <pthread.h>
#include <unistd.h>
using namespace std;

void* ThreadRoutine(void* arg)
{
    const char* buf = static_cast<const char*>(arg);
    for(int i = 0; i < 5; ++i)
    {
        if(i == 3)
        {
            char* buf = new char[64];
            snprintf(buf, 64, "i am return val");
            pthread_exit(buf);
        }
        cout << buf << "Hello World" << endl;
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t tid;
    char buf[] = "[wcm]:";
    pthread_create(&tid, nullptr, ThreadRoutine, buf);
    void* ret;
    pthread_join(tid, &ret);
    const char* res = static_cast<const char*>(ret);
    cout << res << endl;
    return 0;
}

运行结果:
在这里插入图片描述
成功收到线程终止后的返回值, 并且该线程的终止不会影响其他线程.

4. pthread_cancel

头文件: #include <pthread.h>
函数声明: int pthread_cancel(pthread_t thread);

  • 成功返回 0, 失败返回 errno.
  • thread: 被取消的线程 id.

功能: 取消一个线程的执行.

示例代码:

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;

void* ThreadRoutine(void* arg)
{
    for(int i = 0; i < 10; ++i)
    {
        printf("[%d]Hello World\n", i + 1);
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, ThreadRoutine, nullptr);
    for(int i = 0; i < 5; ++i)
    {
        sleep(1);
    }
    pthread_cancel(tid);
    pthread_join(tid, nullptr);
    cout << "main thread done" << endl;
    return 0;
}

运行结果:
在这里插入图片描述
在主线程取消该线程后, 该线程直接结束了.

5. pthread_detach

头文件: #include <pthread.h>
函数声明: int pthread_detach(pthread_t thread);

  • 成功返回 0, 失败返回 errno.
  • thread: 被分离的线程 id.

功能: 分离一个线程, 该线程不需要被等待(join)了.

示例代码:

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;

void* ThreadRoutine(void* arg)
{
    for(int i = 0; i < 10; ++i)
    {
        printf("[%d]Hello World\n", i + 1);
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, ThreadRoutine, nullptr);
    pthread_detach(tid);
    cout << "main thread done" << endl;
    return 0;
}

6. pthread_self

头文件: #include <pthread.h>
函数声明: pthread_t pthread_self(void);

  • 返回值: 该函数总是成功, 返回调用线程的 id.

功能: 返回调用线程的 id.

示例代码:

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;

void* ThreadRoutine(void* arg)
{
    cout << "tid: " << pthread_self() << endl;
    return nullptr;
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, ThreadRoutine, nullptr);
    cout << "tid: " << tid << endl;
    pthread_join(tid, nullptr);
    cout << "main thread done" << endl;
    return 0;
}

运行结果:
在这里插入图片描述

7. 示例代码

场景描述: 创建 10 个线程, 每个线程分别执行各自的累加任务, 执行完任务后结束, 最后主线程回收各线程, 程序结束.

代码:

#include <iostream>
#include <cstdio>
#include <pthread.h>
#include <unistd.h>
using namespace std;

//枚举退出状态
enum exit_code
{
    OK,
    ERROR
};


class thread_info
{
public:
    thread_info(string name, int top, int res = 0, int status = OK)
        :_name(name), _top(top)
    {}
public:
    //输入型参数
    string _name; //线程名
    int _top; //该线程要累加到的值

    //输出型参数
    int _res; //累加结果
    int _status; //退出码
};

//线程入口函数
void* Routine(void* arg)
{
    thread_info* ti = static_cast<thread_info*>(arg);
    cout << "线程" << pthread_self() << "计算中..." << endl;
    sleep(1);
    for(int i = 1; i <= ti->_top; ++i)
    {
        ti->_res += i;
    }
    cout << "线程" << pthread_self() << "计算完毕" << endl;
    sleep(1);
    pthread_exit(ti);
}

int main()
{
    pthread_t threads[10]; //各线程id
    for(int i = 0; i < 10; ++i)
    {   
        char buf[64];
        snprintf(buf, sizeof(buf), "thread-%d", i);
        thread_info* ti = new thread_info(buf, 100 + i * 5);
        pthread_create(threads + i, NULL, Routine, ti);
    }

    void* arg;
    //回收线程
    for(int i = 0; i < 10; ++i)
    {
        pthread_join(threads[i], &arg);
        thread_info* res = static_cast<thread_info*>(arg);
        printf("线程%lld已回收,其累加范围是[1,%d],累加结果:%d,退出码:%d\n", threads[i], res->_top, res->_res, res->_status);
        delete res;
    }

    cout << "线程回收完毕" << endl; 
    return 0;
}

运行结果:
在这里插入图片描述

程序运行起来同时运行的监控脚本:
在这里插入图片描述

从结果可以看出, 确实创建了 10 个线程来执行累加结果, 而最后也成功回收了各线程, 在创建线程时, 给入口函数传参不仅可以传递基础类型, 也可以传递复杂的结构类型, 代码中也是传递了一个自定义的类当作参数, 而从执行顺序可以得知, 线程的执行顺序是不确定的, 在监控脚本中可以看到运行的线程, 其中 PID 是整个进程的 PID, 因为一个进程内可以存在很多个执行流, 所以这些线程执行流的 PID 都是一样的, 而 LWP 则是每个线程都不同的.

d4uu
关注
  • 10
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux线程的实质
01-27
【Linux线程的实质】 线程是操作系统调度和执行的基本单位，它比进程更为轻量级，具有更高的并发性。在Linux系统中，线程是进程内的一个执行流，它们共享进程的地址空间和其他资源，但每个线程都有自己的栈空间，...
Linux多线程
GG_Bruse的博客
02-13 7819
之前提到每个线程都有独占的栈，其中主线程采用的栈是进程地址空间中原生的栈，而其余线程采用的栈就是在共享区中开辟的。在Linux看来，描述线程的控制块和描述进程的控制块是类似的，因此Linux并没有重新为线程设计管理模块，而是直接复用了进程控制块，即Linux中的所有执行流都是轻量级进程。Linux系统中不提供真正的线程ID，只提供LWP，即操作系统只需通过LWP对轻量级进程进行管理，而供用户使用的线程接口等其他数据，由线程库来管理，因此管理线程时的"先描述，再组织"就应该在线程库中完成。
linux 线程 基础例程
07-23
通过这个基础例程，学习者可以了解Linux线程的基本操作，并逐步深入到多线程编程的复杂场景，如死锁预防、资源管理等。实际应用中，理解线程同步和通信的重要性，能够有效地避免竞态条件，提高程序的稳定性和效率。
浅谈linux线程切换问题
09-15
本文将详细探讨Linux线程切换的相关知识点。 首先，理解处理器的运行状态至关重要。处理器总是在内核态和用户态之间切换。在内核态下，处理器可以执行特权指令，既可以运行于进程上下文，代表某个进程执行，也可以...
Linux中的线程
01-27
同样多线程也可以实现并发操作，每个请求分配一个线程来处理。1.线程有独立的堆栈段，共享地址空间，开销较小，切换速度较快。2.线程间的通信机制比较方便。3.因为操作系统会保证当线程数不大于CPU数目时，不同的...
pthreadexample_linux线程_
09-29
在Linux操作系统中，线程是进程内的执行单元，与进程相比，线程具有更低的开销，更快的上下文切换，使得多任务处理更为高效。本示例集合着重于使用`pthread`库进行线程编程，这是一个在POSIX标准中定义的C语言接口，...
【Linux】进程间通信——匿名管道
2201_76024104的博客
07-08 1115
1.：一个进程需要将它的数据发送给另一个进程，比如我们有两个进程，一个负责获取数据，另一个负责处理数据，这时第一个进程就要将获取到的数据交给第二个进程2.：多个进程间共享同样的资源3.：一个进程需要给其他进程发送消息，通知他们发生了某种事件4.：有些事件需要完全控制另一个进程，比如我们在使用gdb调试时，gdb就是一个进程，它控制了我们要调试的进程进程之前是有互相传递信息的需求，但是，一个进程不可能去另一个进程的地址空间中取信息，所以这就要求操作系统去提供一块交换数据的空间来供进程之间使用。
建立共享linux第三方软件仓库
Znj1421304181的博客
07-08 200
【代码】建立共享linux第三方软件仓库。
【linux/shell】linux如何去除字符串中空格
qq_35902025的博客
07-06 429
linux如何去除字符串中空格 tr命令可以用来替换或删除字符 sed是一个流编辑器，可以用来处理文本
Linux 系统安全加固：深入 SELinux 与 AppArmor
weixin_39372311的博客
07-08 845
SELinux 和 AppArmor 是两款强大的 Linux 安全模块，它们可以帮助你加固 Linux 系统安全，防止未经授权的访问和恶意行为。通过学习它们的原理、配置和使用方法，你可以更好地保护 Linux 系统安全，确保其稳定运行。
【Linux系列2】Cmake安装记录
kewaqi618的博客
07-08 1029
主要介绍Cmake的安装方法，及自己安装的过程
nginx安装（win和linux）
f552126506的博客
07-07 564
nginx安装（win和linux）
RedHat运维-LinuxSELinux基础4-端口绑定SELinux上下文
a15735748145a的博客
07-06 650
12. 将60001/tcp端口上的SELinux上下文由http_port_t调整为gopher_port_t的方法是______________________；13. 将60002/tcp端口上的SELinux上下文由gopher_port_t调整为ssh_port_t的方法是______________________；14. 将60003/tcp端口上的SELinux上下文由ssh_port_t调整为http_port_t的方法是_______________________；
Linux —— 进程间通信
最新发布
学习C++的小陈同学
07-11 636
本篇整理了关于进程间通信的内容，以及详解的介绍了两种进程间通信的方式，以及相关的接口和代码演练
【Linux】：程序替换
Yikefore的博客
07-09 1058
程序替换的详细介绍以及各种程序替换接口介绍以及使用！
Linux_实现简易日志系统
安权_code的博客
07-07 1011
在Linux下实现一个日志系统，该日志系统主要用于打印和记录程序的格式化信息，还可以对信息做分析处理，比如把信息分为五种类型：正常运行信息、测试信息，警告信息，错误信息、致命信息，当然还可以显示信息产生的具体时间，并且能够对这些信息进行存档归类。
Linux workqueue介绍
l00102795的博客
07-08 890
不是所有的驱动程序都必须有自己的工作队列。驱动程序可以使用内核提供的缺省工作队列。由于这个工作队列由很多驱动程序共享，任务可能会需要比较长一段时间才能开始执行。为了解决这一问题，工作函数中的延迟应该保持最小或者不要延时。
Linux内核编译与调试menuos-linux-3.18.6-在ubuntu20.04环境
SIML
07-07 802
可能会遇到无compiler-gcc9.h文件的问题,可以在/include/linux目录直接复制一份文件。
Linux线程安全的操作
07-08
Linux提供了一些机制来确保线程安全的操作。下面是一些常见的线程安全操作： 1. 原子操作：原子操作是不可中断的操作，可以在多线程环境中保证数据的一致性。Linux提供了一些原子操作的函数，如atomic_add()、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值