Linux：详解多线程（线程安全、互斥和死锁）(二)

最新推荐文章于 2022-02-24 19:52:29 发布
最新推荐文章于 2022-02-24 19:52:29 发布
阅读量777 收藏 2
点赞数 11
分类专栏： Linux/网络/操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43937101/article/details/116585010
版权

目录

1. 线程安全(面试热点)

1.1 线程安全的定义

在多个执行流访问同一临界资源的时候，不会导致程序结果产生二义性，即就是线程安全。

在这里，我们首先需要知道以下几个名词的含义：

  • 执行流：这里的执行流可以理解为线程，即一个执行流就是一个线程的运行。
  • 访问：指的是对临界资源的操作。
  • 临界资源：多个线程都可以访问到得资源(例如：全局变量、某个结构体变量、某个类的实例化指针)。
  • 临界区：代码操作临界资源的代码区域称为临界区。
  • 二义性：程序结果会产生多个。

1.2 对正常变量进行操作的原理

根据冯诺伊曼体系结构，我们可以得知要对一个正常的变量进行操作的步骤是：

① 寄存器首先从内存中获取变量的值，
② 然后再将获取到的值传入CPU进行运算，
③ CPU对该变量进行相应的操作之后，再其结果返回给寄存器，
④ 再由寄存器将相应的结果返回给内存。

如图所示：
在这里插入图片描述

1.3 描述线程不安全的现象(重点)

① 假设场景

假设当前程序有一个线程A和一个线程B，以及全局变量 i ，并且 i 的值是10，现在线程A要对i进行++操作，线程B要对 i 进行--操作。

② 线程A和线程B的描述

首先是线程A，线程A先从内存中拿到i = 10的值，然后再将其交给寄存器准备传入CPU进行运算，假设当寄存器正准备将i的值传入CPU时，线程A的时间片耗尽了，需要进行线程的切换，这时候线程A的PCB中上下文信息会保存寄存器中的值，即i = 10，程序计数器会保存下一条要运行的指令，然后线程A被切换出去。

当线程A被切换出去的时候，线程B开始运行，线程B也是先从内存中拿到i = 10的值，然后将其交给寄存器，并由寄存器将其传入CPU进行运算(--操作)，CPU运算完成之后，会将结果返回寄存器，此时寄存器拿到i的值就为 9，最终再写回内存中i的值就为9。我们假设在线程B运行的的时候，是没有发生线程切换的，对i的操作是在一个时间片内完成的。

当线程B运行完之后，线程A会再次被切换进来继续它的操作，此时线程A的PCB中的上下文信息会恢复线程A切换出去之前的现场，程序计数器会指明下一条要运行的指令，也就是说，此时Q 的寄存器并不会再次从内存中读值，而是直接从上下文信息中读取i的值，因此此时寄存器中i的值为10，交给CPU进行运算(++操作)，CPU运算之后，再将结果返回给寄存器，寄存器再返回给内存，此时内存中i的值就为11。

最终的结果就是在经过线程A操作(++操作)和线程B操作(--操作)后，i的值变成了11；而并非是按正常逻辑来讲的对i进行++和--操作后，i的值不变，依然为10，这就导致了程序结果产生了二义性，造成了线程不安全。

③ 总结

造成这样的情况产生的根本原因就是多个执行流对同一临界资源进行操作，并且导致程序结果产生了二义性，发生了线程不安全的现象。

1.4 线程不安全的代码模拟(抢票系统的模拟)

现在我们来实现一个抢票程序的基本功能，抢票，我们可以创建出两个线程，并将票数设置为全局变量，在两个线程入口函数中分别对该票数进行减减操作(表示抢到票了)，由此我们观察程序运行所产生的现象。

代码如下：

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

#define THREADNUM 2

int ticket = 100000;

void* threadEntry(void* arg)
{
    while(1)
    {
        if(ticket > 0)
        {
            printf("i am Thread %p, i have tecket ID is %d\n",pthread_self(),ticket);
            --ticket;
        }
        else
        {
            pthread_exit(NULL);
        }
    }
    return NULL;
}

int main()
{
    pthread_t tid[THREADNUM];

    for(int i = 0; i < THREADNUM; ++i)
    {
        int ret = pthread_create(&tid[i],NULL,threadEntry,NULL);
        if(ret < 0)
        {
            perror("pthread_create");
            return 0;
        }
    }

    for(int i = 0;i < THREADNUM; ++i)
    {
        int ret = pthread_join(tid[i],NULL);
        if(ret < 0)
        {
            perror("pthread_join");
            return 0;
        }
    }

    puts("thread join end.....");
    return 0;
}

部分运行结果如下：

由于打印结果过多，这里使用>符号将结果重定向到一个文件中。
在这里插入图片描述
在这里插入图片描述
不难发现，第38548张票被同时抢了2次。这就造成了我们上面所说的多个执行流对同一临界资源进行访问操作，导致了程序结果产生了二义性，造成了线程的不安全。

为了验证这里的抢票不仅仅是对同一张票抢了两次，而是又可能抢了多次，这里我们将该文件放入NotePad++中，对其进行计数。

在这里插入图片描述
发现第3356张票既然被同时抢了20次！！，想想如果放在现实生活中该是多么恐怖的事情。并且，当线程越多，CPU越多的时候，这种效果就越明显，因为线程在CPU中是并行的运行的。

那么，我们该如何解决这种情况的发生呢？如何保证以下几点：

  • 线程在获取票的时候，多个线程没有拿到同一张票的情况，并且没有线程拿到的负数的票。
  • 线程都能够合理的去获取到票。

接下来所说的互斥就能够解决这种情况的产生。

2. 互斥

2.1 互斥锁的原理

互斥锁的底层是一个互斥量，而互斥量的本质是一个计数器。计数器的取值只有两种，一种是1，一种是0。

  • 1：表示当前临界资源是可以被访问的
  • 0：表示当前临界资源是不可以被访问的

当我们的线程要访问临界资源时，需要先访问互斥锁，当互斥锁中的取值为1的时候，该线程就可对该临界资源进行访问，并将其互斥锁中的取值从1变为0，使其它线程不能够访问该临界资源，也就是所谓的加锁。

在这里插入图片描述

获取/释放互斥锁的逻辑：

  • 调用加锁接口，加锁接口内部判断计数器的值是否为1，如果为1，则表示能够访问，并且当加锁成功之后，计数器的值就会从1变为0，如果为0，则表示无法访问。
  • 调用解锁逻辑，计数器的值从1变为0，表示资源可用。

那么问题来了，加锁操作其实也是对临界资源进行了访问，那么它是如何保证加锁这个操作是原子性的呢？

答案是交换，是将我们寄存器中的值和内存中的值进行交换，不管寄存器现在的值为多少，先将寄存器的值初始化为0，再和内存进行交换。因此每当线程想要访问临界区资源的时候，都会先判断寄存器中的值是否为1，如果为1，则表示能够加锁，否则就不可以。这里的交换操作就是一条汇编指令，表明了它就是一个原子性的操作。

对应汇编指令如下：
在这里插入图片描述
其中交换的操作就发生在xchgb一行。

2.2 互斥锁的接口

首先我们需要知道互斥锁的类型为pthread_mutex_t，我们可以在源码中查看它的定义。

在这里插入图片描述
它是一个联合体类型。

2.2.1 初始化互斥锁变量

初始化互斥锁变量分为静态初始化和动态初始化。
我们可以通过man pthread_mutex_init来查看相关的静态初始化和动态初始化

① 静态初始化：

pthread_mutex_t mutex = PTHREAD_MUTEX_INITALIZER

这里的PTHREAD_MUTEX_INITALIZER是一个宏定义，如下：
在这里插入图片描述
静态初始化的好处就是用完之后不需要去主动的释放空间，操作系统会自动回收。

② 动态初始化：
int pthread_mutex_init(pthread_mutex_t *restrict mutex, \
const pthread_mutexattr_t *restrict attr);

参数

  • mutex：该参数为一个出参，由调用者传递一个互斥锁变量的地址，由pthread_mutex_init函数进行初始化。
  • attr：互斥锁的属性信息，一般设置为NULL，采用默认属性。

注意：

动态初始化互斥锁变量需要动态的销毁互斥锁，否则就会造成内存泄漏。

2.2.2 加锁接口

互斥锁的加锁接口有三个：阻塞加锁接口、非阻塞加锁接口和带有超时时间的加锁接口。

① 阻塞加锁接口

int pthread_mutex_lock(pthread_mutex_t *mutex);

参数：

  • mutex：待要加锁的互斥锁变量

返回值：

  • 0 ：加锁成功
  • <0：加锁失败

注意：

  • 如果互斥锁变量当中计数器的值为1，调用该接口，则加锁成功，该接口调用完毕，函数返回。
  • 如果互斥锁变量当中计数器的值为0，调用该接口，则调用该接口的执行流就会进入阻塞状态。

② 非阻塞加锁接口

int pthread_mutex_trylock(pthread_mutex_t *mutex);

参数：

  • mutex：待要加锁的互斥锁变量

返回值：

  • 0 ：加锁成功
  • <0：加锁失败

注意：

不管有没有加锁成功，都会返回，所以需要对加锁结果进行判断，如果成功，则操作临界资源，反之则需要循环的获取互斥锁，直到拿到该互斥锁为止。

③ 带有超时时间的加锁接口

int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex, \
const struct timespec *restrict abs_timeout);

参数：

  • mutex：待要加锁的互斥锁变量
  • abs_timeout：是一个struct timespec结构体的变量，可以用来记录当前线程的运行时间。

struct timespec结构体

typedef long time_t;
#ifndef _TIMESPEC
#define _TIMESPEC
struct timespec {
time_t tv_sec; // seconds
long tv_nsec; // and nanoseconds
};

struct timespec有两个成员，一个是秒，一个是纳秒, 所以最高精确度是纳秒。

返回值：

  • 0 ：加锁成功
  • <0：加锁失败

注意：

  • 超时时间内，如果还没有获取到互斥锁，则返回
  • 超时时间内，如果获取到了互斥锁，也是直接返回

2.2.3 解锁接口

int pthread_mutex_unlock(pthread_mutex_t *mutex);

参数：

  • mutex：待要解锁的互斥锁变量

返回值：

  • 0 ：加锁成功
  • <0：加锁失败

注意：

不管是阻塞加锁接口、非阻塞加锁接口还是带有超时时间的加锁成功的互斥锁，都可以使用该接口。

2.2.4 销毁接口

int pthread_mutex_destroy(pthread_mutex_t *mutex);

参数：

  • mutex：待要销毁的互斥锁变量

返回值：

  • 0 ：加锁成功
  • <0：加锁失败

2.3 互斥锁的代码验证(解决线程不安全的实战)

下面我们就使用上面的互斥锁的接口来解决第一节中抢票程序所造成的线程不安全问题。

在写代码之前，我们需要首先明确以下几点：

① 什么时候要初始化互斥锁？

解答：要在创建工作线程之前。

② 什么时候进行加锁？

解答：要在执行流访问临界资源之前进行加锁，需要注意的是，如果一个执行流加锁成功之后，再去获取该互斥锁，该执行流会依旧被阻塞掉；并且在加锁之后，一定要记得解锁，否则就会导致死锁。

③ 什么时候进行解锁？

解答：要在执行流所有可能退出的地方进行解锁。

④ 什么时候释放互斥锁资源？

解答：在所有使用该互斥锁的线程退出之后，就可以释放该互斥锁了。

我们现在再来整理一下这个代码的逻辑，我们现在只需要在访问全局变量ticket的时候，对其进行加锁操作，然后在使用完之后，再对该变量进行解锁操作即可。

代码如下：

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

#define THREADNUM 2

int ticket = 10;
//注意互斥锁变量的定义一定要在全局中定义
pthread_mutex_t mutex;

void* threadEntry(void* arg)
{
    while(1)
    {
        //在对临界资源进行操作之前进行加锁
        pthread_mutex_lock(&mutex);
        if(ticket > 0)
        {
            printf("i am Thread %p, i have tecket ID is %d\n",pthread_self(),ticket);
            --ticket;
        }
        else
        {
            //注意一定要在线程所有可能退出的位置进行解锁
            //如果在该位置不解锁，那么就有可能该工作线程带着这把锁退出了，
            //而其他线程会一直处于等待拿锁的时刻，这样就造成了死锁
            pthread_mutex_unlock(&mutex);
            pthread_exit(NULL);
        }
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main()
{
    pthread_t tid[THREADNUM];
    //在工作线程之前动态的创建互斥锁
    pthread_mutex_init(&mutex,NULL);

    for(int i = 0; i < THREADNUM; ++i)
    {
        int ret = pthread_create(&tid[i],NULL,threadEntry,NULL);
        if(ret < 0)
        {
            perror("pthread_create");
            return 0;
        }
    }

    for(int i = 0;i < THREADNUM; ++i)
    {
        int ret = pthread_join(tid[i],NULL);
        if(ret < 0)
        {
            perror("pthread_join");
            return 0;
        }
    }

    //在所有线程都退出之后释放互斥锁
    pthread_mutex_destroy(&mutex);

    puts("thread join end.....");
    return 0;
}

运行结果：

在这里插入图片描述
先不说别的，就但从现象来说，至少是没有出现不同进程抢到同一张票的情况出现了。但是该程序还是有问题的，就从结果来看，所有的票数都是由一个进程抢到的，并没有实现我们所希望的各个进程并发的进行抢票，那这个就牵扯到同步的问题了，我会在下一篇进行详细的讲解。

2.4 扩展（使用gdb对多线程代码进行调试）

  • 当代码正在运行的时候，我们可以使用gdb attach [PID]的语句对其进行调试。
  • 查看当前程序所有的调用堆栈信息，使用b t命令。
  • 将线程应用到所有的调用堆栈当中，使用thread apply all bt。
  • 跳转到某一个线程的编号，使用t [线程编号]命令。
  • 跳转到具体的某个堆栈当中，使用f [堆栈编号]命令。

扩展：libpthread.so.o是系统线程库，是release版本，是没有办法进行调试的。

3. 死锁

3.1 死锁的定义

简单的定义：

当一个执行流获取到互斥锁之后，并没有进行解锁，就会导致其他执行流由于获取不到锁的资源而进行阻塞，我们将这种现象称为死锁。

复杂的定义：

当线程A获取到互斥锁1，线程B获取到互斥锁2的时候，线程A和线程B还想获取对方手中的锁，即线程A还想获取互斥锁2，线程B还想获取互斥锁1，这样就会造成死锁。
如图：
在这里插入图片描述

3.2 死锁的必要条件

① 不可剥夺：执行流获取到互斥锁之后，除了自己主动释放锁，其他执行流不能解锁该互斥锁。

② 循环等待：就是上图中所显示的情况，线程A和线程B一直在循环的等待对方的锁解锁。

③ 互斥条件：一个互斥锁只能被一个执行流在同一时刻拥有。

④ 请求与保持：就是"吃着碗里的，看着锅里的"。

需要注意的是，第①和③条件是不可修改的，这是实现互斥所必须拥有的条件

3.3 预防死锁

  • 破坏必要条件：即破坏上面所说的第②和④的情况即可。
  • 加锁顺序一致：就是线程A和线程B都要先对互斥锁1进行加锁，在对互斥锁2进行加锁。
  • 避免锁没有被释放：在书写代码时，一定要注意解锁的位置，避免发生锁没有被释放。
  • 资源一次性分配：就是说一旦进行加锁，则就将所有的资源全部分配给该线程。

3.4 避免死锁算法

3.4.1 死锁检测算法

在这里插入图片描述

本图节选自这篇文章，要是想查看具体的实践，可以去看该文章。

3.4.2 银行家算法

在这里插入图片描述
在这里插入图片描述

本图节选自这篇文章，要是想查看具体的实践及具体的算法，可以去看该文章。

It‘s so simple
关注
  • 11
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
linux进程线程同步之 - POSIX线程互斥锁
07-17 1119
POSIX线程互斥锁 使用范围：线程同步 本文转自： 一、函数介绍 1.初始化互斥锁 #include int pthread_mutex_init(pthread_mutex_t*restrict mutex,const pthread_mutexattr_t *restrict attr); 函数功能：根据输入的参数和配置初始化线程互斥锁。 返回值：If successful
linux多线程——互斥量实现同步
weixin_46199479的博客
03-26 777
静态初始化互斥量，也可以调用函数动态初始化。使用到的函数有pthread_mutex_lock，给资源上锁，和mutex_unlock，给资源解锁，可以实现同步访问，避免竞争。 #include<stdio.h> #include<unistd.h> #include<stdlib.h> #include<pthread.h> pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER; void *func(voi.
【Java并发编程】Java多线程（二）：多线程一定好吗？线程阻塞时占用CPU吗？
A minor
09-14 6297
1.多线程一定好吗 1.1 适用场景 阻塞等待时充分利用CPU 当程序发生阻塞的操作时候，例如IO等待，CPU将就空闲下来了。而使用多线程，当一些线程发生阻塞的时候，另一些线程则仍能利用CPU，而不至于让CPU一直空闲。 利用CPU的多核并行计算能力 现在的CPU基本上都是多核的。使用多线程，可以利用多核同时执行多个线程，而不至于单线程时一个核心满载，而其他核心空闲。 1.2 多线程弊端 线程切换是有开销的，这会导致程序运行变慢。 多线程程序必须非常小心地同步代码，否则会引起死锁。 多线程程序极难调试
函数sem_wait, sem_timedwait, sem_trywait比较
热门推荐
woxiaozhi的专栏
03-04 2万+
#include int sem_wait(sem_t*sem); intsem_trywait(sem_t *sem); intsem_timedwait(sem_t *sem, const struct timespec *abs_timeout); 与 -lrt 或 -pthread 一起链接。 glibc 需要特性测试宏(参看 feature_test_macros(7))：
线程 介绍
陆星材的博客
05-25 137
线程与进程区别： 线程是轻量级的进程，本质是进程； 进程是最小分配资源单元，线程是最小的执行单元 进程有独立的地址空间，拥有PCB；线程也有PCB，但没有独立的地址空间(共享内存) 线程基本操作： 获取线程编号：pthread_t pthread_self(void); 线程创建函数：int pthread_create(pthread_t *thread(线程号的类型，不一定是整型), const pthread_attr_t *attr(线程属性), void *(*start_routine(启.
详解Java多线程编程中互斥锁ReentrantLock类的用法
09-02
在Java多线程编程中，ReentrantLock提供了更灵活的锁管理机制，相比synchronized，它允许更细粒度的控制，并且提供了更多的同步原语。以下是一些使用ReentrantLock的关键点： 1. **可重入性**：ReentrantLock允许一...
Linux中多线程详解及简单实例
09-15
然而，多线程也存在缺点，比如设计和调试难度增加，线程间的同步问题可能导致数据竞争和死锁，以及线程安全问题需要谨慎处理。 Linux系统提供了POSIX线程接口，即pthread，来支持多线程编程。要创建线程，我们需要...
多线程死锁的产生以及如何避免死锁方法(详解)
08-30
【多线程死锁的产生以及如何避免死锁方法详解】 多线程死锁是并发编程中一个重要的问题，它发生在多个线程之间，当它们因竞争资源而陷入一种互相等待的状态，没有外部干预，都无法继续执行。了解死锁的产生原因及...
Java多线程 ReentrantLock互斥锁详解
08-25
Java多线程ReentrantLock互斥锁详解 ReentrantLock是Java多线程编程中的一种锁机制，它可以实现线程之间的同步访问资源。ReentrantLock的主要特点是可以重入，即一个线程可以多次获得锁，而不需要释放锁。这种机制...
Linux线程管理必备:解析互斥量与条件变量的详解
09-05
在Linux系统中，线程管理是一项关键任务，特别是在多线程编程中，互斥量（Mutex）和条件变量（Condition Variable）是确保线程安全和高效协作的重要工具。本文将详细解析这两种机制及其应用。 首先，互斥量是用于...
Linux c++编译so文件 c++ java调用c++的so文件 支持c++17 多线程
mandiheyanyu的博客
11-16 1824
以SEAL库的编译为例 ，使用cmake能够成功编译SEAL库的可执行文件的前提下，将使用SEAL库的函数编译成可执行的so文件。 以里边的1_bfv_basics.cpp为例，里边有个函数void example_bfv_basics()，如果你直接用它的话还得带着#include “examples.h”，这个examples.h里边又带着seal的一大串函数很麻烦。可以把这个函数编译成so文件。 g++ 1_bfv_basics.cpp -std=c++17 -fPIC -shared -lm -ld
setsotimeout java_Java：setSoTimeout和多线程问题
weixin_42475535的博客
02-21 264
我正在编写一个服务器，它应该保持与客户端的连接，只要它通过套接字发送命令 . 每次接受新连接时， soTimeout 都设置为 60000 ，套接字将传递给提交给线程池的Runnable .这是接受新连接的主线程：ExecutorService tpl = Executors.newFixedThreadPool(10);while (!isCancelled) {try {ServerSocke...
linux线程互斥与同步（part1）—互斥锁（mutex）的原理及其实现机制
My Coding Life
05-25 1万+
一段代码引发的问题首先，我们来编写一段代码，它的目的是定义一个全局变量，创建两个线程对其进行5000++的操作。运行结果如下： 当然，目前来看，这段程序并没有任何的问题。然而，对于此程序，结合线程的特点，我们需要明确两点： 局部变量 i 不是共享的，因为它在栈中 gCount是共享的，因为它是全局变量，属于代码段。 我们知道，只要是共享的资源，那么它就可以看作临界资源，而临界资源的访问需要同步与互
Linux线程同步之互斥锁
青山绿水
06-20 816
1.互斥锁作用： 互斥锁mutex是用来保护线程间共享的全局变量安全的一种机制，保证多线程中在某一时刻只允许某一个线程对临界区的访问。 2.初始化方式： 互斥锁对象的数据类型是 pthread_mutex_t ； 互斥锁的初始方式分为静态方式和动态方式： //动态初始化互斥锁方式 int pthread_mutex_init(pthread_mutex_t *restrict mutex, con...
Linux多线程编程---线程间同步（互斥锁、条件变量、信号量和读写锁）
木牛的博客
04-26 436
本篇博文转自http://zhangxiaoya.github.io/2015/05/15/multi-thread-of-c-program-language-on-linux/ Linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量、信号量和读写锁。 下面是思维导图： 简介 进程— 资源分配的最小单位 线程— 程序执行的最小单位 进程是一个程序的一个实例，拥有自己独立的各种段（数据段，代码段等等），每次创建一个进程需要从操作系统分配这些资源给他，消耗一定的时间，在linu.
linux多线程读写环缓存,linux下多线程循环队列读写
weixin_29001327的博客
05-09 368
linux下多线程循环队列读写，一条线程从一个文件打开，将读取的数据放进循环队列，另一条线程再从循环队列的数据写入另一个文件。所要注意的地方是要用linux超级用户比较好，不要放在windos的共享目录中，也就是说不要放在linux下/mnt/hgfs/.../，其中/.../是自定义文件夹。1.[代码][C/C++]代码#include #include #include #include #i...
【Java多线程】Thread，Runnable两种实现，Thread调用Runnable接口实现多线程传参，带参数实现多线程
Maoziii的博客
02-24 2729
Java多线程一、单独使用Thread和Runnable两种实现方式（传参困难）二、使用Thread调用Runnable两种实现方式（方便传参） 一、单独使用Thread和Runnable两种实现方式（传参困难） 1、继承Thread类实现多线程   继承Thread类的方法本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实
单线程目标进程注入一个多线程的动态库（so）失败
lqw198421的专栏
07-28 413
简介 当前项目中，需要查看C++的目标进程的内存分配情况，最直接的方式就是跟踪new/delete的使用情况；通过查看libstd++的源码发现，new的底层调用的还是malloc（有的版本可能不是，需要注意，c++的标准里没有强制要求new的底层一定要通过malloc来实现）；因此就对libstd++.so里的malloc进行hook【这里需要注意：不能对全局的malloc进行hook，而要对libstd++.so里的malloc进行hook】； 具体实现 当前考虑的方案是通过ptrace对目标进程进行a
linux 下std::thread多线程如何减少CPU占用率
最新发布
07-15
在Linux下，可以使用一些方法来减少std::thread多线程的CPU占用率： 1. 使用sleep或者wait方法：在多线程中，可以在每个线程的循环中添加一个sleep或者wait方法，使线程在执行完当前任务后进入休眠状态，从而减少CPU的占用率。可以根据实际需求设置合适的休眠时间。 2. 使用互斥锁（mutex）和条件变量（condition variable）：通过使用互斥锁和条件变量，可以实现线程的同步和等待。当线程没有任务可执行时，可以让线程等待条件变量的触发，从而减少CPU的占用率。 3. 使用线程池：创建一个线程池，将任务分配给线程池中的线程执行，线程在执行完任务后可以继续等待新的任务而不是退出，从而减少线程的频繁创建和销毁，降低CPU的占用率。 4. 使用线程优先级：可以通过设置线程的优先级来控制线程的执行顺序和占用CPU的时间。将一些低优先级的线程设置为较低的优先级，从而减少它们对CPU的占用。 5. 使用CPU亲和性（CPU affinity）：可以将线程绑定到特定的CPU核心上，从而控制线程在特定CPU上执行，减少线程的切换和竞争，降低CPU的占用率。 这些方法可以根据具体的需求和场景来选择和组合使用，以达到减少CPU占用率的目的。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值