【LInux】线程thread从内核原理到C++封装

已于 2025-03-14 15:11:00 修改
阅读量1.1k 收藏 44
点赞数 55
分类专栏： Linux操作系统 文章标签： linux c++
于 2025-03-14 14:55:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_77954967/article/details/146255580
版权

📢博客主页：https://blog.youkuaiyun.com/2301_779549673
📢博客仓库：https://gitee.com/JohnKingW/linux_test/tree/master/lesson
📢欢迎点赞 👍 收藏 ⭐留言 📝 如有错误敬请指正！
📢本文由 JohnKi 原创，首发于 优快云🙉
📢未来很长，值得我们全力奔赴更美好的生活✨

在这里插入图片描述

在这里插入图片描述

文章目录

📢前言

笔者最近在学习Linux，打算对线程到网络部分的学习做一份较为全面的总结，笔者将把这段时间的博客代码都放在gittee仓库中，有需要可以自取

本篇博客所用代码位于

🏳️‍🌈一、线程的本质探秘

1.1 进程 vs 线程的"办公室哲学"

假设进程是一个公司：

  • ​进程：独立办公楼（独立虚拟地址空间）
  • ​线程：共享办公的员工（共享代码段/堆/打开文件）
// 进程fork示例
pid_t pid = fork(); // 创建新办公楼
// 线程创建示例
pthread_create(&tid, NULL, func, arg); // 招聘新员工

1.2 Linux线程实现原理

通过ps -eLf命令观察线程

UID        PID  PPID   LWP  C NLWP STIME TTY      TIME CMD
root         1     0     1  0    1 Aug29 ?    00:00:01 /sbin/init
root       123     1   123  0    3 Aug29 ?    00:00:00 /usr/sbin/sshd
root       456   123   456  0    1 Aug29 ?    00:00:00 sshd: root@pts/0

​LWP：轻量级进程ID（线程本质是轻量级进程）
​NLWP：线程数量

1.3 线程的"人生阶段"

	[*] --> NEW: 创建线程对象
    NEW --> READY: Start()
    READY --> RUNNING: 被调度
    RUNNING --> BLOCKED: 等待I/O
    BLOCKED --> READY: 资源就绪
    RUNNING --> TERMINATED: 执行完成
    RUNNING --> STOPPED: Stop()

🏳️‍🌈二、线程的控制手段

下图为整个线程以及进程的逻辑过程，我将借助此图进行分析和说明线程的4个主要控制手段 - 创建、停止、等待、分离
在这里插入图片描述

控制逻辑链：

创建线程 → 分配task_struct → 绑定执行函数 → 加入调度队列
   │
   ├─ 停止：设置终止标志 → 释放资源 → 更新状态
   ├─ 等待：阻塞主线程 → 监听状态变化 → 资源回收
   └─ 分离：解除关联 → 自动回收资源

2.1 线程创建逻辑

  1. 内核视角（对应图中task_struct）
// 内核创建线程的简化逻辑
int kernel_thread(void (*fn)(void*), void* arg) {
    struct task_struct *tsk = alloc_task_struct(); // 分配task_struct
    tsk->mm = current->mm;       		// 共享父进程mm_struct（关键！）
    copy_files(tsk);             		// 共享文件描述符表
    tsk->stack = alloc_stack();  		// 分配独立内核栈
    setup_thread_stack(tsk, fn, arg); 	// 设置入口函数
    add_to_runqueue(tsk);        		// 加入调度队列
    return tsk->pid;
}

共享地址空间：tsk->mm = current->mm（区别于进程的mm = copy_mm()）
独立资源：内核栈、寄存器值、调度优先级

  1. 用户态API（对应图中"Linux下的线程"）
// 使用pthread_create创建线程
pthread_t tid;
pthread_create(&tid, NULL, thread_func, arg);

在这里插入图片描述

2.2 线程停止逻辑

内核处理流程：
	1. 设置tsk->flags |= PF_EXITING
	2. 触发取消点（系统调用处）
	3. 调用清理函数栈（pthread_cleanup_push注册的）
	4. 释放线程资源
  1. 协作式停止（推荐方式）
// 线程函数内检查终止标志
void* thread_func(void* arg) {
    ThreadContext* ctx = (ThreadContext*)arg;
    while(!ctx->should_stop) {  // 主动检查停止标志
        // 执行任务...
    }
    return NULL;
}

优势：安全释放资源，避免状态不一致

  1. 强制停止（对应图中"停止"标签）
pthread_cancel(tid);  // 发送取消请求

2.3 线程等待逻辑

为什么需要线程等待？

  • 已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。
  • 创建新的线程不会复⽤刚才退出线程的地址空间
int pthread_join(pthread_t thread, void **value_ptr);

thread：线程ID
value_ptr：它指向⼀个指针，后者指向线程的返回值

内核实现

// 内核源码片段（简化）
int do_join_thread(struct task_struct *tsk) {
    while (tsk->state != TASK_DEAD) {
        set_current_state(TASK_INTERRUPTIBLE);
        schedule_timeout(WAIT_TIME);  // 让出CPU
    }
    unlink_thread(tsk);  // 从进程线程列表中移除
    free_task_struct(tsk);
}

状态转移图示

stateDiagram
    [*] --> RUNNING : 创建
    RUNNING --> TERMINATED : 执行完成
    RUNNING --> ZOMBIE : 终止但未Join
    ZOMBIE --> [*] : 被Join

调用该函数的线程将挂起等待,直到id为thread的线程终止。thread线程以不同的方法终止,通过pthread join得到的终止状态是不同的，总结如下:

  1. 如果thread线程通过return返回,value_ptr所指向的单元里存放的是thread线程函数的返回值。
  2. 如果thread线程被别的线程调用pthread_cancel异常终掉,value_ptr所指向的单元里存放的是常数PTHREAD CANCELED。
  3. 如果thread线程是自己调用pthread_exit终止的,value_ptr所指向的单元存放的是传给pthread exit的参数。
  4. 如果对thread线程的终止状态不感兴趣,可以传NULL给value_ptr参数。

2.4 线程分离逻辑

  • 默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏。
  • 如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源。
pthread_detach(tid);

内核响应：

  • 修改tsk->exit_signal为SIGNAL_GROUP_EXIT
  • 设置tsk->ptrace = 0（解除跟踪）
  • 禁止后续Join操作

分离后的资源回收

线程终止 → 内核自动回收资源 → 无需用户干预

在这里插入图片描述

2.5 控制手段与内存管理

  1. 虚拟地址空间交互（对应mm_struct）
  • 创建时：共享父进程的mm_struct（CLONE_VM标志）
  • ​终止时：检查引用计数，若为0则释放mm_struct
  1. 页表操作示例
// 线程访问共享变量时的页表行为
void* shared_var = mmap(NULL, size, PROT_READ|PROT_WRITE, 
                       MAP_SHARED, -1, 0); 

// 内核处理：
// 1. 建立共享映射
// 2. 多个线程的页表项指向同一物理页
// 3. 修改时触发COW（若未用MAP_SHARED）

🏳️‍🌈三、手把手实现线程库

// 目标使用方式
Thread thread([](){
    std::cout << "线程执行中..." << std::endl; 
});
thread.Start();
thread.Stop();
thread.Join();
thread.Detach();

3.1 状态机管理

    // 线程状态枚举
    enum class TSTATUS
    {
        NEW,      // 新建未启动状态
        RUNNING,  // 运行中状态
        STOP      // 已停止状态
    };

3.2 成员变量管理

private:
        std::string _name;    // 线程名称标识
        pthread_t _tid;       // 线程ID（系统级）
        pid_t _pid;           // 所属进程ID
        bool _joinable;       // 是否是分离的，默认不是（可join状态）
        func_t _func;         // 用户回调函数
        TSTATUS _status;      // 当前线程状态

3.3 构造函数 && 析构函数

        // 构造函数：接收用户回调函数
        Thread(func_t func) : _func(func), _status(TSTATUS::NEW), _joinable(true)
        {
            // 生成唯一线程名称（Thread-1, Thread-2...）
            _name = "Thread-" + std::to_string(number++);
            _pid = getpid();  // 记录所属进程ID
        }
		
		// 析构函数
		~Thread(){}

3.4 启动线程

        // 静态线程入口函数（POSIX线程要求格式）
        static void *Routine(void *args)
        {
            // 将void*参数转换回Thread对象指针
            Thread *t = static_cast<Thread *>(args);
            t->_status = TSTATUS::RUNNING;  // 更新线程状态
            t->_func();                     // 执行用户回调函数
            return nullptr;
        }
        // 启动线程方法
        bool Start()
        {
            if (_status != TSTATUS::RUNNING)  // 防止重复启动
            {
                // 创建POSIX线程（Routine为入口，this指针作为参数）
                // pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
                    //   thread：指向线程ID的指针
                    //   attr：线程属性（可选）
                    //   start_routine：线程入口函数
                    //   arg：入口函数参数（这里是this指针）
                // 返回值：0表示成功，其他表示失败
                int n = ::pthread_create(&_tid, nullptr, Routine, this); // TODO
                return n == 0;  // 返回创建结果
            }
            return false;
        }

3.5 停止线程

// 强制停止线程（慎用）
        bool Stop()
        {
            if (_status == TSTATUS::RUNNING)
            {
                // 发送取消请求到目标线程
                int n = ::pthread_cancel(_tid);
                if (n == 0) _status = TSTATUS::STOP;
                return n == 0;
            }
            return false;
        }

3.6 线程等待

// 等待线程结束（阻塞调用）
        bool Join()
        {
            if (_joinable)  // 只有非分离线程可调用
            {
                int n = ::pthread_join(_tid, nullptr);
                if (n == 0) _status = TSTATUS::STOP;
                return n == 0;
            }
            return false;
        }

3.7 分离线程

// 设置线程分离
        void Detach()
        {
            EnableDetach();          // 修改内部状态
            pthread_detach(_tid);    // 系统级分离设置
        }

🏳️‍🌈四、添加模板

// 线程模板类（支持带参数执行）
    template <typename T>
    class Thread

T _data;              // 数据副本（存储在栈区）

🏳️‍🌈五、整体代码

当前为v2版，即可用模板版

5.1 Thread.hpp

#ifndef _THREAD_HPP__
#define _THREAD_HPP__

#include <iostream>
#include <string>
#include <pthread.h>
#include <functional>
#include <sys/types.h>
#include <unistd.h>

// v2
#define v2
#ifdef v2
namespace ThreadModule
{
    static int number = 1;  // 线程实例计数器（对应图示中的task_struct数量）
    
    // 线程状态机（对应图示中task_struct的状态变化）
    enum class TSTATUS {
        NEW,      // 新建状态（已创建未启动）
        RUNNING,  // 运行状态（对应CPU调度队列中的task_struct）
        STOP      // 终止状态（等待资源回收）
    };

    // 线程模板类（支持带参数执行）
    template <typename T>
    class Thread
    {
        using func_t = std::function<void(T)>;  // 带参数的执行函数类型
    
    private:
        // POSIX线程入口函数（需满足C链接约定）
        static void* Routine(void* args) {
            // 将void*参数还原为Thread对象指针（对应图示中的task_struct关联）
            Thread<T>* t = static_cast<Thread<T>*>(args);
            t->_status = TSTATUS::RUNNING;  // 更新状态为运行中
            t->_func(t->_data);             // 执行用户逻辑（访问共享内存区）
            return nullptr;                 // 线程自然终止
        }

        // 设置分离状态（修改图示中的task_struct标志位）
        void EnableDetach() { _joinable = false; }

    public:
        // 构造函数：初始化执行函数和数据副本（在栈区创建数据副本）
        Thread(func_t func, T data) : _func(func), _data(data), 
            _status(TSTATUS::NEW), _joinable(true) 
        {
            _name = "Thread-" + std::to_string(number++);  // 生成唯一标识
            _pid = getpid();  // 记录所属进程PID（对应图示中的mm_struct所属进程）
        }

        // 启动线程（创建轻量级进程）
        bool Start() {
            if (_status != TSTATUS::RUNNING) {
                // 创建POSIX线程（对应图示中的clone系统调用）
                int n = ::pthread_create(&_tid, nullptr, Routine, this);
                return n == 0;  // 返回内核创建结果
            }
            return false;  // 防止重复启动
        }

        // 强制终止线程（可能引发资源泄漏）
        bool Stop() {
            if (_status == TSTATUS::RUNNING) {
                // 发送取消请求（可能中断页表查询过程）
                int n = ::pthread_cancel(_tid);
                if (n == 0) _status = TSTATUS::STOP;
                return n == 0;  // 返回内核操作结果
            }
            return false;
        }

        // 等待线程结束（处理ZOMBIE状态）
        bool Join() {
            if (_joinable) {
                // 阻塞等待并回收资源（对应图示中的task_struct回收）
                int n = ::pthread_join(_tid, nullptr);
                if (n == 0) _status = TSTATUS::STOP;
                return n == 0;
            }
            return false;
        }

        // 设置线程分离（自动回收资源）
        void Detach() {
            EnableDetach();         // 修改可连接状态
            pthread_detach(_tid);   // 通知内核自动回收（对应图示中的SIGNAL_GROUP_EXIT）
        }

        // 状态查询接口
        bool IsJoinable() { return _joinable; }
        std::string Name() { return _name; }

        ~Thread() {
            // 建议添加：if(_joinable) Join(); // RAII方式自动回收
        }

    private:
        std::string _name;    // 线程名称（调试用）
        pthread_t _tid;       // 线程ID（对应图示中的LWP）
        pid_t _pid;           // 进程ID（共享mm_struct的标识）
        bool _joinable;       // 连接状态（控制ZOMBIE状态转换）
        func_t _func;         // 执行函数（存储在代码区）
        TSTATUS _status;      // 状态机（NEW→RUNNING→STOP）
        T _data;              // 数据副本（存储在栈区）
    };
}

// v1
#else
namespace ThreadModule
{
    using func_t = std::function<void()>;  // 定义无参回调函数类型
    static int number = 1;                // 线程编号计数器
    
    // 线程状态枚举
    enum class TSTATUS
    {
        NEW,      // 新建未启动状态
        RUNNING,  // 运行中状态
        STOP      // 已停止状态
    };

    class Thread
    {
    private:
        // 静态线程入口函数（POSIX线程要求格式）
        static void *Routine(void *args)
        {
            // 将void*参数转换回Thread对象指针
            Thread *t = static_cast<Thread *>(args);
            t->_status = TSTATUS::RUNNING;  // 更新线程状态
            t->_func();                     // 执行用户回调函数
            return nullptr;
        }

        // 设置分离状态（内部方法）
        void EnableDetach() { _joinable = false; }

    public:
        // 构造函数：接收用户回调函数
        Thread(func_t func) : _func(func), _status(TSTATUS::NEW), _joinable(true)
        {
            // 生成唯一线程名称（Thread-1, Thread-2...）
            _name = "Thread-" + std::to_string(number++);
            _pid = getpid();  // 记录所属进程ID
        }

        // 启动线程方法
        bool Start()
        {
            if (_status != TSTATUS::RUNNING)  // 防止重复启动
            {
                // 创建POSIX线程（Routine为入口，this指针作为参数）
                // pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
                    //   thread：指向线程ID的指针
                    //   attr：线程属性（可选）
                    //   start_routine：线程入口函数
                    //   arg：入口函数参数（这里是this指针）
                // 返回值：0表示成功，其他表示失败
                int n = ::pthread_create(&_tid, nullptr, Routine, this); // TODO
                return n == 0;  // 返回创建结果
            }
            return false;
        }

        // 强制停止线程（慎用）
        bool Stop()
        {
            if (_status == TSTATUS::RUNNING)
            {
                // 发送取消请求到目标线程
                int n = ::pthread_cancel(_tid);
                if (n == 0) _status = TSTATUS::STOP;
                return n == 0;
            }
            return false;
        }

        // 等待线程结束（阻塞调用）
        bool Join()
        {
            if (_joinable)  // 只有非分离线程可调用
            {
                int n = ::pthread_join(_tid, nullptr);
                if (n == 0) _status = TSTATUS::STOP;
                return n == 0;
            }
            return false;
        }

        // 设置线程分离
        void Detach()
        {
            EnableDetach();          // 修改内部状态
            pthread_detach(_tid);    // 系统级分离设置
        }

        // 状态查询方法
        bool IsJoinable() { return _joinable; }
        std::string Name() { return _name; }

        ~Thread(){}

    private:
        std::string _name;    // 线程名称标识
        pthread_t _tid;       // 线程ID（系统级）
        pid_t _pid;           // 所属进程ID
        bool _joinable;       // 是否是分离的，默认不是（可join状态）
        func_t _func;         // 用户回调函数
        TSTATUS _status;      // 当前线程状态
    };
}

#endif
#endif

5.2 Thread.cc

#include <unordered_map>
#include <memory>

#include "Thread.hpp"

#define NUM 10

using namespace ThreadModule;
// using thread_ptr_t = std::shared_ptr<ThreadModule::Thread>;

using namespace ThreadModule;

class threadData
{
public:
    int max;
    int start;
};

#define v2
#ifdef v2
void Count(threadData td)
{
    for (int i = td.start; i < td.max; i++)
    {
        std::cout << "i == " << i << std::endl;
        sleep(1);
    }
}

#else
void Count(){
    std::cout << "线程执行中..." << std::endl; 
}
#endif

int main()
{
    threadData td;
    td.max = 60;
    td.start = 50;
    // v2 版
    ThreadModule::Thread<threadData> thread(Count, td);

    // v1 版
    // ThreadModule::Thread thread(Count);

    

    thread.Start();

    thread.Join();

    // 先描述，在组织！
    // std::unordered_map<std::string, thread_ptr_t> threads;
    // // 如果我要创建多线程呢？？？
    // for (int i = 0; i < NUM; i++)
    // {
    //     thread_ptr_t t = std::make_shared<ThreadModule::Thread>([](){
    //         while(true)
    //         {
    //             std::cout << "hello world" << std::endl;
    //             sleep(1);
    //         }
    //     });
    //     threads[t->Name()] = t;
    // }

    // for(auto &thread:threads)
    // {
    //     thread.second->Start();
    // }

    // for(auto &thread:threads)
    // {
    //     thread.second->Join();
    // }

    // ThreadModule::Thread t([](){
    //     while(true)
    //     {
    //         std::cout << "hello world" << std::endl;
    //         sleep(1);
    //     }
    // });

    // t.Start();
    // std::cout << t.Name() << "is running" << std::endl;
    // sleep(5);

    // t.Stop();
    // std::cout << "Stop thread : " << t.Name()<< std::endl;
    // sleep(1);
    // t.Join();
    // std::cout << "Join thread : " << t.Name()<< std::endl;

    return 0;
}

5.3 Makefile

bin=testThread
cc=g++
src=$(wildcard *.cc)
obj=$(src:.cc=.o)

$(bin):$(obj)
	$(cc) -o $@ $^ -lpthread
%.o:%.cc
	$(cc) -c $< -std=c++17

.PHONY:clean
clean:
	rm -f $(bin) $(obj)

.PHONY:test
test:
	echo $(src)
	echo $(obj)

👥总结

本篇博文对 线程thread从内核原理到C++封装 做了一个较为详细的介绍，不知道对你有没有帮助呢

觉得博主写得还不错的三连支持下吧！会继续努力的~

请添加图片描述

C++ Linux多线程
谢谢大家的关注
02-22 620
由于进程中的所有线程共享该进程的信号，所以线程库将根据线程掩码决定把信号发送给哪个具体的线程。这两点都说明，我们应该定义一个专门的线程来处理所有的信号。这个互斥锁可能被加锁了，但并不是由调用fork函数的那个线程锁住的，而是由其他线程锁住的。函数来回收其他线程( 前提是目标线程是可回收的，见后文)，即等待其他线程结束，这类似于回收进程的wait和waitpid系统调用。这两个函数的第一个参数分别用于设置线程的取消状态(是否允许取消)和取消类型(如何取消)，第二个参数则分别记录线程原来的取消状态和取消类型。
Linux C++的多线程编程
m0_74282605的博客
01-29 1077
线程（thread）技术早在60年代就被提出，但真正应用多线程到操作系统中去，是在80年代中期，solaris是这方面的佼佼者。传统的Unix也支持线程的概念，但是在一个进程（process）中只允许有一个线程，这样多线程就意味着多进程。现在，多线程技术已经被许多操作系统所支持，包括Windows/NT，当然，也包括Linux。为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？什么的系统应该选用多线程？我们首先必须回答这些问题。使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务
C++ thread编程（Linux系统为例）—thread成员函数与thread的创建方法
qaaaaaaz的博客
05-21 1738
c++ 11 之后有了标准的线程库：std::thread。
Linux多线程C/C++
风间琉璃的博客
07-24 1779
在 Linux 中，多线程编程可以显著提高应用程序的性能和响应能力。多线程允许程序在多个线程中并行执行，从而更好地利用多核处理器。Linux 中的多线程编程主要依赖于 POSIX 线程（pthread）库。这个库提供了创建、同步和管理线程的各种函数。使用 头文件可以实现多线程应用。
C++_2——thread & Linux多线程
fangfang12138的博客
08-27 567
C++_2——thread & Linux多线程线程的创建、资源回收线程锁线程池线程通信与同步线程安全线程与进程进程间的通信方式其他摘抄和参考 线程的创建、资源回收 #include <thread> // 构造函数 // 默认构造 thread() noexcept; // 显式构造：输入重载函数的函数指针，导致编译错误 template <class Fn, class... Args> explicit thread (Fn&& fn, Arg
Linux线程thread详解（线程池）
m0_74830524的博客
08-13 1127
多线程就可以让我们的代码并行运行起来，本篇从线程的基本概念开始介绍，然后比较了多线程与多进程之间的区别。接着介绍了在 Linux 系统下的线程控制，介绍了在 Linux 系统下使用多线程的函数接口。然后讲解了线程的互斥，需要使用锁互斥，同时揭示了互斥的缺点，然后引入了线程同步，需要使用条件变量来解决。在介绍完条件变量之后，我们又介绍了在多线程中常用的生产消费模型，实现了两种经典的生产消费模型：阻塞队列（使用条件变量和互斥锁完成）和环形队列（使用信号量和互斥锁完成）。同时还介绍了线程安全和可重入以及死锁的概念
C++对windows/linux线程的简单封装
04-15
总的来说，"C++对windows/linux线程的简单封装"涉及到了如何使用C++标准库的`std::thread`结合Windows API（如`CreateThread`）和Linux API（如`pthread_create`）实现跨平台的线程管理。这需要对操作系统内核的线程...
C++ 进程与线程
qq_37464701的博客
03-22 1425
程序：就是磁盘上的可执行文件，并且只占用磁盘上的空间，是一个静态的概念。进程：被执行后的程序就叫做进程，不占用磁盘空间，需要消耗系统的内存，CPU资源，每个运行的进程都对应一个属于自己的虚拟地址空间。？？？后面有空去了解下？？？CPU时间片：CPU在某个时间点只能处理一个任务，但是操作系统都支持多任务的，那么在计算机CPU只有一个的情况下是怎么完成任务处理的？原理和古时候救济灾民的思路是一样的，每个人分一点，但是又不叫吃饱。
【C++20 协程原理】从 Linux 线程、线程与异步编程、协程与异步，一文带你弄清楚
Linux高级开发的博客
02-17 586
协程不是系统级线程，很多时候协程被称为“轻量级线程”、“微线程”、“纤程(fiber)”等。简单来说可以认为协程是线程里不同的函数，这些函数之间可以相互快速切换。 协程和用户态线程非常接近，用户态线程之间的切换不需要陷入内核，但部分操作系统中用户态线程的切换需要内核态线程的辅助。 协程是编程语言（或者 lib）提供的特性（协程之间的切换方式与过程可以由编程人员确定），是用户态操作。协程适用于 IO 密集型的任务。常见提供原生协程支持的语言有：c++20、golang、python 等，其他语言以库的..
ThreadX_C++：全面封装的线程调用工具库
ThreadX_C++是ThreadX的C++封装版本，它提供了一个面向对象的接口，使开发者能够以更加直观和面向对象的方式来使用ThreadX的线程管理功能。 1. ThreadX_C++概述 ThreadX_C++是ThreadX实时操作系统的面向对象封装。...
Linux C/C++线程
Abieai的博客
04-25 1128
文章目录一、线程是什么？二、线程创建三、线程终止四、线程分离五、线程连接六、线程属性总结 一、线程是什么？ （英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread
【Linux】一文带你了解C++中的多线程及其底层逻辑（thread、join、封装线程库、__thread让线程局部使用全局变量）
溟洵的博客
01-24 2035
本章是线程的第三篇章，前两章带你了解了线程以及线程原生库中的操作，本章主要结合前两章的基础，学习入门c++中的线程函数，了解其底层是什么，并且自己封装一个线程库来使用并巩固。
【Linux】多线程 -＞ 使用C/C++实现简单的线程池
最新发布
2202_75924820的博客
02-22 926
使用C和C++实现了线程池的基本设计......
Linux C++11——多线程类thread
YBAdiam的博客
03-10 5021
一、并发和并行 1、并行(parallel) 指在同一时刻，有多条指令在多个处理器上同时执行。就好像两个人各拿一把铁锨在挖坑，一小时后，每人一个大坑。所以无论从微观还是从宏观来看，二者都是一起执行的。 2、并发(concurrency) 指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。这就好像两个人用同一把铁锨，轮流挖坑，一小时后，两个人各挖一个小一点的坑，要想挖两
C++实战-Linux多线程(入门到精通)
weixin_46120107的博客
08-20 4603
1.进程间的信息难以共享。由于除去只读代码段外，父子进程并未共享内存，因此必须采用一些进程间通信方式，在进程间进行信息交换。2.调用fork()来创建进程的代价相对较高(复制一份地址空间)，即便采用"写时复制"机制，仍然需要复制诸如内存页表和文件描述符表之类的多种进程属性，这意味着fork()调用在时间上的开销依然不菲3.线程之间能够方便、快速地共享信息，只需要将数据复制到共享(栈不行，见上图)变量中即可4.创建线程比创建进程通常要快10倍甚至更多。
Linux 下 c++ 类内使用多线程 std::thread
qq_18076309的博客
11-01 508
Linux 下 c++ 类内使用多线程 std::thread。
linux编程 - C/C++每线程（thread-local）变量的使用
热门推荐
落尘纷扰的专栏
05-12 3万+
在一个进程中定义的全局或静态变量都是所有线程可见的，即每个线程共同操作一块存储区域。而有时我们可能有这样的需求：对于一个全局变量，每个线程对其的修改只在本线程内有效，即每个线程虽然共享这个全局变量的名字，但这个变量的值就像只有在本线程内才会被修改和读取一样。 线程局部存储和线程特有数据都可以实现上述需求。 1. 线程局部存储 线程局部存储提供了持久的每线程存储，每个线程都拥有一份对变量的拷贝
[C++11 std::thread] 使用C++11 编写 Linux 多线程程序
JoeBlackZQQ的专栏
12-26 1万+
From: http://www.ibm.com/developerworks/cn/linux/1412_zhupx_thread/index.html   本文讲述了如何使用 C++11 编写 Linux 下的多线程程序，如何使用锁，以及相关的注意事项，还简述了 C++11 引入的一些高级概念如 promise/future 等。 0 评论： 朱
评论 27
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值