【Linux】线程控制

已于 2024-08-01 00:12:32 修改
阅读量454 收藏 14
点赞数 15
分类专栏： Linux 文章标签： linux 运维 服务器 网络 阿里云 学习 后端
于 2024-07-31 22:46:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Weraphael/article/details/140803033
版权

在这里插入图片描述

👦个人主页：Weraphael
✍🏻作者简介：目前正在学习c++和算法
✈️专栏：Linux
🐋 希望大家多多支持，咱一起进步！😁
如果文章有啥瑕疵，希望大佬指点一二
如果文章对你有帮助的话
欢迎 评论💬 点赞👍🏻 收藏 📂 加关注😍

目录

一、 POSIX线程库

在上篇博客中（点击跳转），我们说过：Linux操作系统中没有很明确的线程的概念，因为线程调度成本低 + 用进程的数据结构模拟线程（和进程使用相同的内核数据结构），因此Linux内核将线程视为轻量级进程。所以Linux操作系统不会直接提供线程的系统调用。只会给我们提供轻量级进程系统调用。

可是我们用户需要的是线程的接口！所以，在用户层和内核层之间，即应用层，就有了一个 pthread线程库。它是将轻量级进程接口进行了封装。对于这个pthread线程库（第三方库），几乎所有的Linux平台都是默认自带这个库的。因此，pthread线程库也称原生线程库（原来就生在Linux系统里，只要Linux在，这个库就在）。

总之，在Linux中编写线程相关代码，需要使用第三方pthread库。

注意：

  • 要使用这些函数库，要通过引入头文件<pthread.h>。
  • 链接这些线程函数库时要使用编译器命令的-lpthread选项。

二、快速使用线程接口

2.1 创建线程

【函数原型】

#include <pthread.h>

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

说明：

  • pthread_t *thread：它是一个输出型参数，在成功创建线程后，返回线程ID。（输出型参数：函数可以修改参数的值，并返回）

  • const pthread_attr_t *attr：用于指定线程的属性（比如优先级、状态、私有栈大小）。一般直接填 nullptr即可，表示线程将使用默认属性。

  • void *(*start_routine) (void *)：是一个函数指针（函数地址），表示线程启动后要执行的函数。返回值和形参类型均为void*。表示可以接收或返回任意指针类型，因为C语言没有模板，但是想用泛型。注意：不可以定义形如void x;这样定义变量；但可以定义void*变量。

  • void *arg：它是一个输入型参数，是传递给 start_routine 函数的参数，它可以是任何类型的指针，用于向新线程传递数据。如果不需要给start_routine 函数传递数据，直接设置nullptr即可。（输入型参数：函数可以读取这些参数的值，但形参的改变不影响实参）

  • 返回值：成功返回0；失败返回错误码。

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

// 新线程
void *thread_task(void *arg)
{
    while (true)
    {
        printf("我是 %s, 我的进程id: %d\n", (char *)arg, getpid());
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t tid;
    char *name = new char[32];
    snprintf(name, 32, "thread 1");

    // 创建线程
    pthread_create(&tid, nullptr, thread_task, name);

    // 主线程
    while (true)
    {
        cout << "主线程的进程id: " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

非常简单的代码，此时如果直接编译会引发报错

在这里插入图片描述

未定义 pthread_create 这个函数。一看就是链接报错，我们使用的是第三方库pthread，那么在编译的时候必须要指明该库！

解决方法：编译时带上 -lpthread。

此时再编译就没有问题了

在这里插入图片描述

我们可以使用以下命令来查看库的链接情况

ldd 可执行程序

在这里插入图片描述

可以看到，原生线程库路径： /lib64/libpthread.so.0。这足以证明原生线程库确确实实的存在于我们的系统中！

【运行结果】

在这里插入图片描述

几乎所有的进程默认都有一个主线程，而主线程主要是执行main函数中的代码。我们发现：无论是主线程还是新线程，它们的进程id都是一样的。这也验证了线程是进程的执行分支，只不过一个进程里有两个执行流。

至于主次线程的运行顺序，线程的调度机制源于进程，而多进程运行时，谁先运行取决于调度器，因此主次线程运行的先后顺序不定，具体取决于调度器的调度。

可以通过以下查看正在运行中的线程信息：

 ps -aL
 #这里的L可以理解为light，表示轻的意思，也就是轻量级进程

在这里插入图片描述

解释说明：

  • PID字段：表示进程的标识符。主次线程PID都相等，说明它们隶属同一个进程。
  • LWP字段：表示轻量级进程（Light Weight Process）的标识符，本质上就是线程的标识符。我们发现：其中有一个PID等于LWP，说明了这个线程是主线程，剩下的是被创建出来的线程。像我们以前写的代码，PID永远等于LWP。
  • TTY字段：指示与线程相关联的终端设备，通常是一个终端（例如，通过SSH登录的会话）。如果线程没有与任何终端相关联，则该字段可能显示为?或空白。
  • TIME：指示进程或线程已经占用CPU的时间。
  • CMD：指示启动进程或线程的完整命令。

另外，在Linux中，进程的多个线程共享同一地址空间。也就说，如果定义一个函数，在各线程中都可以调用，如果定义一个全局变量，在各线程中都可以访问到等等。而可以被多个执行流同时调用而不会产生不正确的结果的函数，我们称为可重入函数。

我们可以来验证：

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

const char *symbol = "# ";

void sayhello(const string &words)
{
    cout << "你好, 我的名字是" << symbol << words << endl;
}

// 新线程
void *thread_task(void *arg)
{
    while (true)
    {
        sayhello((char *)arg);
        sleep(1);
    }
    return nullptr;
}

int main()
{
    pthread_t tid;
    char *name = new char[32];
    snprintf(name, 32, "thread 1");

    // 创建线程
    pthread_create(&tid, nullptr, thread_task, name);

    // 主线程
    while (true)
    {
        sayhello("主线程");
        sleep(1);
    }

    return 0;
}

【程序结果】

在这里插入图片描述

注意：多个线程同时访问一个共享资源，如果没有合适的同步机制保护，可能导致数据不一致或者意外的行为。例如，两个线程同时尝试递增一个共享的计数器，由于没有同步措施，最终的计数结果可能会不符合预期。

除此之外，不管给主线程还是任意的线程发送信号，默认是进程收到信号。这就是为什么线程的健壮性很差，只要有一个线程挂掉了，整个进程也就挂掉了。

在这里插入图片描述

2.2 线程等待

如果进程内存在多个线程，一般来说主线程要最后退出。因为是主线程创建的线程，它要对其进行管理。但如果主线程退出，那么整个进程也就退出了，即进程内的所有执行流都退出了。

为什么需要等待子线程退出？

  • 如果主线程在退出时没有等待子线程完成，可能会导致一些资源无法正确释放。例如，子线程可能在使用共享资源或者分配了内存，在主线程退出后这些资源可能会变成未定义的状态。（内存泄漏）
  • 类似于僵尸进程的问题，如果创建的线程没有被正确地等待和回收，它们可能会成为"僵尸线程"，即虽然它们的执行已经结束，但是它们的退出状态和其他资源（如线程栈）并没有被释放，这可能会消耗系统资源，并且可能导致未定义的行为。当然了，“僵尸线程”是验证不出来的，因为在Linux中没有线程。（内存泄漏）
  • 新线程被主线程创建出来，就是让新线程办事的，我们得知道它办的怎么样，结果数据是什么？如果需要，我们也可以获取其退出结果。（获取退出结果）

总结线程等待的目的：

  1. 防止内存泄漏。
  2. 如果需要，也可以获取一下子进程的退出结果。

【函数原型】

#include <pthread.h>

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

说明：

  • thread：要等待结束的目标线程的标识符，通常通过 pthread_create 创建线程时返回的 pthread_t 对象来指定。

  • retval：这是一个输出型参数，用于存储目标线程的退出状态，目标线程的退出状态就是函数的返回值。如果不关心线程的退出状态，可以将 retval 设置为 nullptr。（输出型参数：函数可以修改参数的值，并返回）

  • 返回值

    • 如果成功，pthread_join 返回 0。
    • 如果出错，返回一个非零的错误码。可以通过 errno 全局变量获取具体的错误信息。
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string>
using namespace std;

const char *symbol = "# ";

void sayhello(const string &words)
{
    cout << "你好, 我的名字是" << symbol << words << endl;
}

// 新线程
void *thread_task(void *arg)
{
    int cnt = 3;
    while (cnt--)
    {
        sayhello((char *)arg);
        sleep(1);
    }
    // 当cnt=0走到这里，新线程就退出了。
    return (void *)233;
}

int main()
{
    pthread_t tid;
    char *name = new char[32];
    snprintf(name, 32, "thread 1");

    // 创建线程
    pthread_create(&tid, nullptr, thread_task, name);

    void *res;
    // 线程等待
    pthread_join(tid, &res);
    cout << "次线程退出了，其退出信息为： " << (long long)res << endl;

    return 0;
}

注意：次线程的退出信息为233，那么首先能想到将res强转为int类型并打印。但我的云服务器是64位，因此指针大小都是8字节。8字节强转为4字节会发生截断，因此我将res强转为8字节的long long类型（8字节）。

【程序结果】

在这里插入图片描述

2.3 线程终止

如果我们想要终止线程，能否使用exit函数呢？我们可以用下面代码来验证一下：

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

const char *symbol = "# ";

void sayhello(const string &words)
{
    cout << "你好, 我的名字是" << symbol << words << endl;
}

// 新线程
void *thread_task(void *arg)
{
    int cnt = 3;
    while (cnt--)
    {
        sayhello((char *)arg);
        sleep(1);
    }

    exit(233);
}

int main()
{
    pthread_t tid;
    char *name = new char[32];
    snprintf(name, 32, "thread 1");

    // 创建线程
    pthread_create(&tid, nullptr, thread_task, name);

    void *res;
    // 线程等待
    pthread_join(tid, &res);
    cout << "次线程退出了，其退出信息为： " << (long long)res << endl;

    return 0;
}

【程序结果】

在这里插入图片描述

我们发现：当次线程使用exit函数退出后，主线程并执行 cout << "次线程退出了，其退出信息为： " << (long long)res << endl;这条语句。所以说明exit函数直接将主线程也终止了。即 exit函数是用来终止进程的！不能用来直接终止线程！

因此，线程库中有专门终止线程运行的接口pthread_exit，即哪个线程调用就终止哪个线程，不会误伤其他线程。

【函数原型】

#include <pthread.h>

void pthread_exit(void *retval);

参数介绍：

  • retval： 指定线程的退出信息。本质上就是目标线程的函数的返回值。
  • 需要注意：pthread_exit或者return的参数的指针所指向的内存单元必须是全局的或者是用动态内存分配的，不能在线程函数的栈上分配。因为当其它线程得到这个返回指针时线程函数已经退出了（野指针）。
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string>
using namespace std;

const char *symbol = "# ";

void sayhello(const string &words)
{
    cout << "你好, 我的名字是" << symbol << words << endl;
}

// 新线程
void *thread_task(void *arg)
{
    int cnt = 3;
    while (cnt--)
    {
        sayhello((char *)arg);
        sleep(1);
    }
 
    pthread_exit((void *)233);
}

int main()
{
    pthread_t tid;
    char *name = new char[32];
    snprintf(name, 32, "thread 1");

    // 创建线程
    pthread_create(&tid, nullptr, thread_task, name);

    void *res;
    // 线程等待
    pthread_join(tid, &res);
    cout << "次线程退出了，其退出信息为： " << (long long)res << endl;
 
    return 0;
}

【程序结果】

在这里插入图片描述

注意：上面是新线程去调用pthread_exit接口，那么只有这个线程会退出，如果主线程去调用这个接口退出的话，那么整个进程都会终止。

2.4 线程取消

pthread_cancel 是POSIX线程库中的一个函数，它允许一个线程请求另一个线程终止其执行。

【函数原型】

#include <pthread.h>

int pthread_cancel(pthread_t thread);

说明：

  • thread：要取消执行的目标线程的标识符，通常是通过pthread_create创建线程时返回的pthread_t对象来指定。
  • 返回值
    • 成功返回0。
    • 失败返回一个非零的错误码。
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <string>
using namespace std;

const char *symbol = "# ";

void sayhello(const string &words)
{
    cout << "你好, 我的名字是" << symbol << words << endl;
}

// 新线程
void *thread_task(void *arg)
{
    int cnt = 3;
    while (cnt--)
    {
        sayhello((char *)arg);
        sleep(1);
    }
    pthread_exit((void *)233);
}

int main()
{
    pthread_t tid;
    char *name = new char[32];
    snprintf(name, 32, "thread 1");

    // 创建线程
    pthread_create(&tid, nullptr, thread_task, name);
    sleep(1); // 保证线程已启动

    // 线程取消
    pthread_cancel(tid);

    void *res;
    // 线程等待
    pthread_join(tid, &res);
    cout << "次线程退出了，其退出信息为： " << (long long)res << endl;

    return 0;
}

【程序结果】

在这里插入图片描述

我们发现：主线程获取次线程的退出信息始终是-1。

注意：如果某个线程被别的线程调用pthread_ cancel异常终止的话，默认会返回一个宏PTHREAD_ CANCELED。这个宏的值就是-1。

在这里插入图片描述

总结：如果只终止某个线程而不终止整个进程，可以三种方法：

  1. 从线程函数return。注：这种方法对主线程不使用，从main函数return相当于调用exit。
  2. 线程可以调用pthread_exit终止自己。
  3. 一个线程可以调用pthread_cancel终止同一进程中的另一个线程。

2.5 综合使用以上接口

无论是 pthread_create 还是 pthread_join，他们的参数都有一个共同点：包含了一个 void* 类型的参数，这就是意味着我们可以 给线程传递对象，并借此进行某种任务处理。比如计算[0, N]的总和

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

// 计算
class Request
{
public:
    Request(int start, int end, const string &threadname)
        : _start(start), _end(end), _threadname(threadname)
    {
    }

public:
    int _start;
    int _end;
    string _threadname;
};

// 计算结果
class Responese
{
public:
    Responese(int result, int exitcode)
        : _result(result), _exitcode(exitcode)
    {
    }

public:
    int _result;   // 计算结果
    int _exitcode; // 计算结果是否可靠
};

void *sumCount(void *arg)
{
    Request *rq = static_cast<Request *>(arg);
    Responese *rsp = new Responese(0, 0);
    for (int i = rq->_start; i <= rq->_end; i++)
    {
        // 运算过程
        cout << rq->_threadname << " is running, cacling..., " << i << endl;
        usleep(100000);
        rsp->_result += i;
    }
    delete rq;
    return (void *)rsp;
}

int main()
{
    pthread_t tid;
    // 求1~100总和
    Request *rq = new Request(1, 100, "thread 1");
    // 创建线程
    pthread_create(&tid, nullptr, sumCount, rq); // 传对象

    void *res;
    pthread_join(tid, &res);
    Responese *rsp = static_cast<Responese *>(res);
    cout << "rsp->_result = " << rsp->_result << " , exitcode: " << rsp->_exitcode << endl;

    delete rsp;
    return 0;
}

【程序结果】

在这里插入图片描述

当然了，也可以创建多个线程来计算，最后再将结果合在一起即可。并且我们发现，我们的这些对象都是在堆区创建的。并且我们是交叉使用的，说明堆空间的也是被线程共享使用的。

2.6 线程分离

父进程需要阻塞式等待子进程退出，主线程等次线程时也是阻塞式等待，父进程可以设置为 WNOHANG，变成轮询式等待，避免自己一直处于阻塞。

同理的，当调用pthread_join函数时，主线程也是阻塞式等待次线程退出。

#include <iostream>
#include <pthread.h> // Linux下的线程库
#include <unistd.h>
#include <string>
using namespace std;

void *task(void *)
{

    while (1)
    {
        cout << "thread: void *task(void*)" << endl;
        sleep(1);
    }
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, task, nullptr);

    pthread_join(tid, nullptr);

    while (1)
    {
        cout << "main thread" << endl;
        sleep(1);
    }
    return 0;
}

【程序结果】

在这里插入图片描述

那么，次线程该如何做才能避免等待时阻塞呢？

答案是： 分离Detach

pthread_detach是一个POSIX线程库中的函数，用于将一个线程标记为“可分离”的状态。这意味着当线程结束时，系统可以自动回收其资源，而无需等待其他线程来获取它的返回状态。

【函数原型】

#include <pthread.h>

int pthread_detach(pthread_t thread);

说明：

  • thread：一个pthread_t类型的线程标识符，表示要设置为“可分离”状态的线程。
  • 返回值：
    • 如果成功，返回 0。
    • 如果失败，返回一个非零的错误码，指示出错的原因。

注意：pthread_detach函数的作用是将指定的线程设置为“可分离”的状态。一个线程默认情况下是非分离状态的，这意味着它在结束时会留下其资源，直到另一个线程调用pthread_join来等待获取其退出状态为止。而“可分离”状态的线程在结束时，其资源会立即被系统回收，不需要其他线程等待或获取其退出状态。

#include <iostream>
#include <pthread.h> // Linux下的线程库
#include <unistd.h>
#include <string>
// #include<thread> // C++下的线程库
using namespace std;

void *task(void *)
{

    while (1)
    {
        cout << "thread: void *task(void*)" << endl;
        sleep(1);
    }
}

int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, task, nullptr);
    // 线程分离
    pthread_detach(tid);

    pthread_join(tid, nullptr);
    while (1)
    {
        cout << "main thread" << endl;
        sleep(1);
    }
    return 0;
}

【程序结果】

在这里插入图片描述

建议将pthread_detach放在待分离线程的 线程创建 语句之后，如果放在线程执行函数中，可能会因为调度优先级问题引发错误（未知结果）

三、C++11中的线程（浅聊）

在Linux中，我们使用的是原生线程库（pthread库）

其实C++11语言本身也已经支持线程了，它与我们的原生线程库有什么关系呢？

C++11的线程需要包含头文件#include<thread>

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

void thread_task()
{
    while (true)
    {
        cout << "I am a new thread for C++" << endl;
        sleep(1);
    }
}

int main()
{
    thread t1(thread_task);

    t1.join();

    return 0;
}

写完以下代码，编译没有问题，但是运行时报错了！

在这里插入图片描述

我们需要注意的是，在Linux环境中运行以上代码，在编译的时候还是需要使用-lpthread选项的。如果在Winodows环境下运行，而无需显式指定链接选项。这是因为Windows开发环境已经包含了所需的库和头文件路径配置，使得开发者可以直接使用标准库功能。

而高级语言（如C++）通常具备跨平台能力。因为它在不同平台下已经写好了不同版本的库，这些库的实现会依据不同的操作系统提供相应的底层支持，从而使得多线程编程在不同平台上表现一致。所以对我们而言，不同的平台写代码是没有感觉的。

因此，平时最好使用高级语言的线程。因为具有跨平台性。

在这里插入图片描述

四、代码

Gitee仓库链接：点击跳转

没有难学的知识~
关注
  • 15
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux 多线程原理深剖
qq_61500888的博客
12-24 3万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
基于linux的进程和线程控制
02-01
对于线程控制，Linux提供了pthread库，它包含了一系列函数来创建、销毁、同步和通信线程。例如，pthread_create()用于创建新线程，pthread_join()用于等待线程结束，pthread_mutex_lock()和pthread_mutex_unlock()...
Linux——线程控制
kkbca的博客
04-01 1517
线程控制，如何操控一个线程完成任务，同时能取消线程、等待线程，分离线程。
Linux多线程——线程控制
Dirty_artist的博客
01-18 976
线程控制（线程创建、等待、终止、取消）
Linux之线程控制
最新发布
wmh
04-09 1940
对页表的理解，对线程概念，线程ID和线程创建，线程终止，线程等待，线程分离进行了详细讲解！
浅谈linux线程切换问题
09-15
本文将详细探讨Linux线程切换的相关知识点。 首先，理解处理器的运行状态至关重要。处理器总是在内核态和用户态之间切换。在内核态下，处理器可以执行特权指令，既可以运行于进程上下文，代表某个进程执行，也可以...
pthreadexample_linux线程_
09-29
在Linux操作系统中，线程是进程内的执行单元，与进程相比，线程具有更低的开销，更快的上下文切换，使得多任务处理更为高效。本示例集合着重于使用`pthread`库进行线程编程，这是一个在POSIX标准中定义的C语言接口，...
linux线程使用说明，小白手册
12-10
在 Linux 系统中，线程被称作轻量级进程，是操作系统调度的基本单元。虽然线程本质上仍然是进程，但它比传统进程更轻便，因为线程之间共享大部分资源，包括地址空间。每个线程都有自己的程序计数器（PCB）、线程ID...
Linux下的多线程编程实例解析
09-14
【Linux下的多线程编程实例解析】 在计算机操作系统中，多线程编程是实现并行处理和提高系统效率的一种重要技术。Linux系统同样支持多线程编程，这使得开发者能够利用这一特性创建高效的、响应迅速的应用程序。多...
Linux下多线程间通信
09-14
此外，线程1还使用了条件变量`pthread_cond_signal`和`pthread_cond_wait`来控制线程间的协作。线程2在`i`不是3的倍数时会等待线程1的信号，而线程1在`i`是3的倍数时会发送信号唤醒线程2。 条件变量（pthread_cond_...
linux线程技术
03-07
【Linux线程技术】在操作系统领域，Linux线程是指在Linux环境下实现的多线程编程技术。虽然在早期的Linux内核中并没有直接支持线程的概念，而是通过轻量级进程（Lightweight Process, LWP）来模拟线程的行为。在...
linux 线程实验
01-08
Linux 线程实验 在本实验中，我们将学习 Linux 系统中的多线程编程，了解进程概念和 Linux 可执行文件结构。我们将通过编写多个程序，使用系统调用 fork() 创建多个子进程，并观察进程之间的并发执行。 一、理解...
Linux系统下的多线程编程入门.pdf
12-20
本文将深入探讨Linux环境中的多线程概念、创建与管理线程的方法、线程同步与通信机制，以及多线程编程中可能遇到的问题和解决策略。 一、多线程概念 多线程是指在一个进程中可以同时执行多个独立的代码段，每个代码...
Linux多线程实现令牌桶流量控制
02-19
本文将深入探讨如何在Linux环境下利用多线程技术来实现令牌桶流量控制。 首先，我们要理解令牌桶算法的基本原理。令牌桶算法是一个允许突发数据传输并同时保持平均传输速率的机制。桶中存储一定数量的令牌，只有当...
duoxiancheng.rar_linux 多线程
09-19
信号量可以控制对共享资源的访问数量，常用于限制并发线程数；读写锁在多读少写的情景下能提供更高的并行性，允许多个读线程同时访问数据，但写线程会独占资源。 在"duoxiancheng.pdf"文件中，可能包含的具体实验...
linux 多线程安全定时器
08-16
同时，为了防止多个线程同时触发同一个定时器的回调，可能需要使用条件变量或者互斥锁进行同步控制。 在给定的`XTimer`项目中，可能包含了一个示例程序，演示如何在多线程环境下使用`timerfd`和`epoll`。`makefile`...
Linux 线程浅析
04-19
### Linux线程浅析 #### 一、线程的基本概念 在典型的UNIX进程中，我们可以将一个进程视为只有一个控制线程的实体，也就是说，在同一时刻进程只能处理一件事情。然而，随着多线程技术的发展，现代的进程可以包含多...
linux线程间同步详细说明
11-05
本文将详细讲解Linux线程间同步的各种机制和实现方法。 一、互斥量（Mutex） 互斥量是一种基本的同步原语，通过获取和释放锁来控制对共享资源的访问。当一个线程持有互斥量时，其他试图获取该锁的线程将被阻塞，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值