侧边栏壁纸
博主头像
如此肤浅博主等级

但行好事,莫问前程!

  • 累计撰写 24 篇文章
  • 累计创建 12 个标签
  • 累计收到 6 条评论

目 录CONTENT

文章目录

多线程编程

如此肤浅
2022-10-19 / 0 评论 / 1 点赞 / 458 阅读 / 12,658 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2023-03-31,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

相关概念

与进程(process)类似,线程(thread)是允许应用程序并发执行多个任务的一种机制。一个进程可以包含多个线程。同一个程序中的所有线程均会独立执行相同程序,且共享同一份全局内存区域,其中包括初始化数据段、未初始化数据段,以及堆内存段。(传统意义上的 UNIX 进程只是多线程程序的一个特例,该进程只包含一个线程)。

进程是 CPU 分配资源的最小单位,线程是操作系统调度执行的最小单位。

线程是轻量级的进程(LWP:Light weight Process) ,在 Linux 环境下线程的本质仍是进程。

查看指定进程的 LWP 号:ps -Lf pid

线程和进程的区别

  1. 进程间的信息难以共享。由于除去只读代码段外,父子进程并未共享内存,因此必须采用一些进程间通信方式,在进程间进行信息交换。

  2. 调用 fork() 来创建进程的代价相对较高,即便利用写时复制技术。仍需要复制诸如内存页表和文件描述符表之类的多种进程属性,这意味着 fork() 调用在时间上的开销依然不菲。

  3. 线程之间能够方便、快速地共享信息。只需将数据复制到共享(全局或堆)变量中即可。

  4. 创建线程比创建进程通常要快10倍甚至更多。线程间是共享虚拟地址空间的,无需采用写时复制来复制内存,也无需复制页表。

线程之间共享和非共享的资源

共享资源 非共享资源
进程ID和父进程ID 线程ID
进程组 ID和会话ID 信号掩码(阻塞信号集)
用户ID和用户组ID 线程特有数据
文件描述符表 error变量
信号处理 实时调度策略和优先级
文件系统的相关信息:文件权限掩码(umask) 、当前工作目录 栈,本地变量和函数的调用链接信息
虚拟地址空间(除栈、代码段)

创建线程和结束线程

pthread_create 创建线程

#include<pthread.h>

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

功能

  • 创建一个线程。

参数

  • thread:新线程的标识符,传出参数。(Linux 上几乎所有的资源标识符都是一个整型数,比如 socket)
  • attr:用于设置新线程的属性。一般传递 NULL 表示使用默认的线程属性。
  • start_routine:函数指针。指定新线程将运行的函数。
  • arg:给第三个参数使用,即函数 start_routine 函数的参数。

返回值

  • 成功:0
  • 失败:返回错误号(与 errno 不太一样)。获取错误号的信息:char* strerror(int errnum);
// 子线程的回调函数
void* callback(void* arg) {
    printf("child thread....\n");
    printf("arg value : %d\n", *(int*)arg);
    return NULL;
}

// 主线程
int main() {
    // 创建子线程
    pthread_t tid;
    int num = 10;
    int ret = pthread_create(&tid, NULL, callback, (void *)&num);
    if(ret != 0) {
        char* errstr = strerror(ret);
        printf("error : %s\n", errstr);
    }

    for(int i = 0; i < 5; ++i) {
        printf("%d\n", i);
    }

    sleep(1); // 让主线程休眠一秒,以便观察子线程的输出

    return 0;
}

image-1680058379356

pthread_exit 线程退出

如果进程中的任一线程调用了 exit(),则整个进程会终止,所以,在线程的 start_routine 函数中,不能采用 exit() 结束该线程。

线程的终止有三种方式:
① 线程的 start_routine 函数代码结束,自然消亡;
② 线程的 start_routine 函数调用 pthread_exit 结束;
③ 被主进程或其它线程中止。

#include <pthread.h>

void pthread_exit(void *retval);

功能

  • 在 start_routine 中调用,确保安全、干净地退出当前线程。

参数

  • retval:pthread_exit 通过 retval 向线程的回收者传递其退出信息,一般填空。
// 子线程的回调函数
void* callback(void* arg) {
    // pthread_self() 返回当前线程的ID
    printf("child thread id = %ld\n", pthread_self());
    return NULL; // 相当于执行 pthread_exit(NULL)
}

// 主线程
int main() {
    // 创建子线程
    pthread_t tid;
    int ret = pthread_create(&tid, NULL, callback, NULL);
    if(ret != 0) {
        char* errstr = strerror(ret);
        printf("error: %s\n", errstr);
    }
    
    for(int i = 0; i < 5; ++i) {
        printf("%d\n", i);
    }

    printf("tid = %ld, main thread id = %ld\n", tid, pthread_self());

    // 让main线程退出,主线程退出时不会影响其他正常运行的线程
    pthread_exit(NULL);

    // 由于main线程退出,下面这句话不会执行,也不会执行到return,
    // 因此不会对子线程造成影响
    printf("main thread exit\n");

    return 0;
}


输出:
zengyq@zengyq:~/cpp学习/牛客C++学习$ ./a.out 
0
1
2
3
4
tid = 139872626734848, main thread id = 139872626739008
child thread id = 139872626734848

pthread_join 线程回收

include <pthread.h>

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

功能

  • 一个进程中的所有线程都可以调用 pthread_join 函数来回收其他线程(前提是目标线程是可回收的,见后文),即等待其他线程结束。

参数

  • thread:目标线程的标识符。
  • retval:接收目标线程退出时的返回值。

返回值

  • 成功: 0
  • 失败:返回错误码,可能的错误码如下。
    • EDADLK:可能引起死锁。比如两个线程互相针对对方调用 pthread_join,或者线程对自身调用 pthread_join。
    • EINVAL:目标线程是不可回收的,或者已经有其他线程在回收该目标线程。
    • ESRCH:目标线程不存在。

注意事项

  • 该函数会一直阻塞,直到被回收的线程结束为止。
// 子线程的回调函数
void* callback(void* arg) {
    printf("child thread id = %ld\n", pthread_self());
    int val = 10;
    pthread_exit((void*)&val);
}

// 主线程
int main() {
    // 创建子线程
    pthread_t tid;
    int ret = pthread_create(&tid, NULL, callback, NULL);
    if(ret != 0) {
        char* errstr = strerror(ret);
        printf("pthread_create error: %s\n", errstr);
    }
    
    for(int i = 0; i < 5; ++i) {
        printf("%d\n", i);
    }

    printf("tid = %ld, main thread id = %ld\n", tid, pthread_self());

    // 主线程回收子线程的资源,并获取子线程传递出来的值
    int* thread_retval;
    ret = pthread_join(tid, (void**)&thread_retval);
    if(ret != 0) {
        char* errstr = strerror(ret);
        printf("pthread_join error: %s\n", errstr);
    }
    printf("exit data : %d\n", *thread_retval);

    // 让main线程退出
    pthread_exit(NULL);

    return 0;
}

输出:
zengyq@zengyq:~/cpp学习/牛客C++学习$ ./a.out 
0
1
2
3
4
tid = 140367713195776, main thread id = 140367713199936
child thread id = 140367713195776
exit data : 32681

pthread_detach 线程分离

#include <pthread.h>

int pthread_detach(pthread_t thread);

功能

  • 分离一个线程。被分离的线程在终止的时候,会自动释放资源归还系统。

参数

  • thread:需要分离的线程的ID。

返回值

  • 成功:0
  • 失败:返回错误码

注意

  • 不能多次分离一个已经分离的线程,否则会产生不可预料的行为。
  • 不能去 pthread_join 去回收一个已经分离的线程,否则会报错。
// 子线程的回调函数
void* callback(void* arg) {
    printf("child thread id = %ld\n", pthread_self());
    pthread_exit(NULL);
}

// 主线程
int main() {
    // 创建子线程
    pthread_t tid;
    int ret = pthread_create(&tid, NULL, callback, NULL);
    if(ret != 0) {
        char* errstr = strerror(ret);
        printf("pthread_create error : %s\n", errstr);
    }

    // 输出主线程和子线程的id
    printf("tid: %ld, main thread id: %ld\n", tid, pthread_self());

    // 设置子线程分离,子线程分离后,其资源不需要住线程释放
    pthread_detach(tid);

    // 对设置分离的子线程进行回收(会报错)
    ret = pthread_join(tid, NULL);
    if(ret != 0) {
        char* errstr = strerror(ret);
        printf("pthread_join error : %s\n", errstr);
    }

    pthread_exit(NULL);
    return 0;
}

输出:
zengyq@zengyq:~/cpp学习/牛客C++学习$ ./a.out 
tid: 140554128701184, main thread id: 140554128705344
pthread_join error : Invalid argument 	# 会返回错误的信息
child thread id = 140554128701184

pthread_cancel 线程取消

#inlude <pthread.h>

int pthread_cancel(pthread_t thread);

功能

  • 取消线程(即让线程终止)。但不是立马终止,而是当子线程允许取消,且当子线程执行到取消点的时候才会终止。

参数

  • thread

返回值

  • 成功:0
  • 失败:返回错误码

接收到取消请求的目标线程可以决定是否允许被取消以及如何取消,这分别由如下两个函数完成:

#include <pthread.h>

int pthread_setcancelstate(int state, int *oldstate);
int pthread_setcanceltype(int type, int *oldtype);

state

  • 设置线程的取消状态(是否运行取消),有两个可选值。
  • PTHREAD_CANCEL_ENABLE:运行被取消,是默认取消状态。
  • PTHREAD_CANCEL_DISABLE:禁止线程被取消。这种情况下,如果一个线程收到取消请求,则它会将请求挂起,直到该线程允许被取消。

oldstate

  • 记录线程原来的取消状态。

type

  • 设置线程的取消类型(如何取消),有两个可选值。
  • PTHREAD_CANCEL_ASYNCHRONOUS:线程随时都可以被取消。它将使得收到取消请求的目标线程立即采取行动。
  • PTHREAD_CANCEL_DEFERRED:允许目标线程推迟行动,直到它到取消点。

oldtype

  • 记录线程原来的取消类型。

pthread_attr_* 线程属性

初始化、释放属性变量

#include <pthread.h>

int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destroy(pthread_attr_t *attr);

获取、设置线程分离的状态属性

#include <pthread.h>

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
  • 案例
    // 子线程的回调函数
    void* callback(void* arg) {
        printf("child thread id = %ld\n", pthread_self());
        pthread_exit(NULL);
    }
    
    // 主线程
    int main() {
        // 创建一个线程属性变量
        pthread_attr_t attr;
        // 初始化属性变量
        pthread_attr_init(&attr);
    
        // 设置分离的属性
        pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    
        // 创建子线程
        pthread_t tid;
        int ret = pthread_create(&tid, &attr, callback, NULL);
        if(ret != 0) {
            char* errstr = strerror(ret);
            printf("pthread_create error : %s\n", errstr);
        }
    
        // 输出主线程和子线程的id
        printf("tid: %ld, main thread id: %ld\n", tid, pthread_self());
    
        // 释放线程属性资源
        pthread_attr_destroy(&attr);
    
        pthread_exit(NULL);
        return 0;
    }
    

线程资源的回收

线程有 joinable 和 unjoinable 两种状态,如果线程是 joinable 状态,当线程主函数终止时(自己退出或调用 pthread_exit 退出)不会释放线程所占用内存资源和其它资源,这种线程被称为“僵尸线程”。创建线程时默认是 joinable 状态的。

避免僵尸线程就是如何正确的回收线程资源,有四种方法:

  • 方法一:创建线程后,在创建线程的程序中调用 pthread_join 等待线程退出,一般不会采用这种方法,因为 pthread_join 会发生阻塞。

    pthread_join(pthid, NULL);
    
  • 方法二:创建线程前,调用 pthread_attr_setdetachstate 将线程设为 detached,这样线程退出时,系统自动回收线程资源。

    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    pthread_create(&pthid, &attr, pth_main, pth_main的参数);
    
  • 方法三:创建线程后,在创建线程的程序中调用 pthread_detach 将新创建的线程设置为 detached 状态。

    pthread_detach(pthid);
    
  • 方法四:在线程主函数中调用 pthread_detach 改变自己的状态。

    pthread_detach(pthread_self());
    

线程同步方式

线程的主要优势在于,能够通过全局变量来共享信息。不过,这种便捷的共享是有代价的:必须确保多个线程不会同时修改同一变量,或者某一线程不会读取正在由其他线程修改的变量。

临界区:是指访问某一共享资源的代码片段,并且这段代码的执行应为原子操作,也就是同时访问同一共享资源的其他线程不应终端该片段的执行。

线程同步:即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作,其他线程才能对该内存地址进行操作,而其他线程则处于等待状态。

  • 卖票案例

    int tickets = 100;
    
    void* sellticket(void* arg) {
        // 卖票
        while(tickets > 0) {
            usleep(6000); // 睡眠6000微妙,让其他线程有机会抢占到CPU
            printf("%ld 正在卖第 %d 张门票\n", pthread_self(), tickets);
            tickets--;
        }
    
        pthread_exit(NULL);
    }
    
    // 主线程
    int main() {
    
        // 创建3个子线程
        pthread_t tid1, tid2, tid3;
        pthread_create(&tid1, NULL, sellticket, NULL);
        pthread_create(&tid2, NULL, sellticket, NULL);
        pthread_create(&tid3, NULL, sellticket, NULL);
    
        // 设置线程分离
        pthread_detach(tid1);
        pthread_detach(tid2);
        pthread_detach(tid3);
    
        pthread_exit(NULL); // 退出主线程
    
        return 0;
    }
    
    输出:
    140412228163328 正在卖第 7 张门票
    140412244948736 正在卖第 7 张门票
    140412236556032 正在卖第 4 张门票
    140412244948736 正在卖第 3 张门票
    140412228163328 正在卖第 2 张门票
    140412244948736 正在卖第 1 张门票
    140412236556032 正在卖第 0 张门票
    140412228163328 正在卖第 -1 张门票
    

    可以发现,同一张篇被卖了多次,而且卖出了第0张、第-1张票的情况。

    因此需要采用线程同步使对共享数据的操作保证原子性。

信号量

Linux 信号量 API 有两组,一组是多进程中提到的信号量,一组是此处的信号量,且功能类似。

#include <semaphore.h>

int sem_init(sem_t *sem, int pshared, unsigned int value);
int sem_destroy(sem_t *sem);
int sem_wait(sem_t *sem);
int sem_trywait(sem_t *sem);
int sem_post(sem_t *sem);

sem_init

  • 初始化一个信号量。
  • pshared:指定信号量的类型。如果其值为 0,就表示这个信号量是当前进程的局部信号量,否则该信号量就可以在多个进程之间共享。
  • value:指定信号量的初始值。此外,初始化一个已经被初始化的信号量将导致不可预期的结果。

sem_destroy

  • 销毁信号量,以释放其占用的内核资源。

sem_wait

  • 以原子操作的方式将信号量的值减 1。
  • 如果信号量的值为 0,则 sem_wait 将被阻塞,直到这个信号量具有非 0 值。

sem_trywait

  • 与 sem_wait 函数相似,不过它始终立即返回,而不论被操作的信号量是否具有非 0 值,相当于 sem_wait 的非阻塞版本。
  • 当信号量的值非 0 时,sem_trywait 对信号量执行减 1 操作。
  • 当信号量的值为 0 时,它将返回 -1 并设置 errno 为 EAGAIN。

sem_post

  • 以原子操作的方式将信号量的值加 1。
  • 当信号量的值大于 0 时,其他正在调用 sem_wait 等待信号量的线程将被唤醒。

返回值

  • 上面这些函数成功时返回 0,失败则返回 -1 并设置 errno。

互斥锁

为避免线程更新共享变量时出现问题,可以使用互斥锁(mutex)来确保同时仅有一个线程可以访问某项共享资源。可以使用互斥锁来保证对任意共享资源的原子访问。

互斥锁有两种状态:已锁定(locked)和未锁定(unlocked)。任何时候,至多只有一个线程可以锁定该互斥锁。试图对已经锁定的某一互斥锁再次加锁,将可能阻塞线程或者报错失败,具体取决于加锁时使用的方法。

一旦线程锁定互斥锁,随即成为该互斥锁的所有者,只有所有者才能给互斥锁解锁。一般情况下,对每一共享资源(可能由多个相关变量组成)会使用不同的互斥锁,每一线程在访问同一资源时将采用如下协议:① 针对共享资源锁定互斥锁;② 访问共享资源;③ 对互斥锁解锁。

#include <pthread.h>

// pthread_mutex_t:互斥锁的类型

// 初始化互斥锁。mutex:需要初始化的互斥锁;attr:互斥锁相关的属性;
// 修饰符 restrict:被其修饰的指针,不能被另一个指针操作
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);

// 释放互斥锁资源
int pthread_mutex_destroy(pthread_mutex_t *mutex);

// 加锁,阻塞,没获取到锁的阻塞等待
int pthread_mutex_lock(pthread_mutex_t *mutex);

// 尝试加锁,如果加锁识别不会阻塞,会直接返回
int pthread_mutex_trylock(pthread_mutex_t *mutex);

// 解锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);
  • 卖票案例
    int tickets = 1000;
    
    // 创建一个互斥量
    pthread_mutex_t mutex;
    
    void* sellticket(void* arg) {
        // 卖票
        while(1) {
            // 加锁
            pthread_mutex_lock(&mutex);
    
            if(tickets > 0) {
                usleep(3000); // 睡眠3000微妙,让其他线程有机会抢占到CPU
                printf("%ld 正在卖第 %d 张门票\n", pthread_self(), tickets);
                tickets--;
            } else {
                // 解锁
                pthread_mutex_unlock(&mutex);
                break;
            }
    
            // 解锁
            pthread_mutex_unlock(&mutex);
        }
    
        pthread_exit(NULL);
    }
    
    // 主线程
    int main() {
        // 初始化互斥量
        pthread_mutex_init(&mutex, NULL);
    
        // 创建3个子线程
        pthread_t tid1, tid2, tid3;
        pthread_create(&tid1, NULL, sellticket, NULL);
        pthread_create(&tid2, NULL, sellticket, NULL);
        pthread_create(&tid3, NULL, sellticket, NULL);
    
        // 设置线程分离
        pthread_detach(tid1);
        pthread_detach(tid2);
        pthread_detach(tid3);
    
        pthread_exit(NULL); // 退出主线程
    
        // 释放互斥量
        pthread_mutex_destroy(&mutex);
    
        return 0;
    }
    

死锁

两个或两个以上的进程在执行过程中,因争夺共享资源而造成的一种互相等待的现象.若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。

同时满足以下四个条件才会发生死锁:
① 互斥条件,多个线程不能同时使用同一资源;
② 持有并等待;
③ 不可剥夺条件;
④ 环路等待条件。

读写锁

当有一个线程已经持有互斥锁时,互斥锁将所有试图进入临界区的线程都阻塞住。但是考虑一种情形,当前持有互斥锁的线程只是要读访问共享资源,而同时有其它几个线程也想读取这个共享资源,但是由于互斥锁的排它性,所有其它线程都无法获取锁,也就无法读访问共享资源了,但是实际上多个线程同时读访问共享资源并不会导致问题。

在对数据的读写操作中,更多的是读操作,写操作较少。例如对数据库数据的读写应用。为了满足当前能够允许多个读出,但只允许一个写入的需求,线程提供了读写锁来实现。

读写锁的特点:
① 如果有其它线程读数据,则允许其它线程执行读操作,但不允许写操作。
② 如果有其它线程写数据。则其它线程都不允许读、写操作。
③ 写是独占的,写的优先级高。

// 读写锁的类型:pthread_rwlock_t

int pthread_rwlock_init(pthread_rwlock_t * restrict rwlock, const pthread_rwlockattr_t *restrict attr);

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

int pthread_rwlock_rdlock(pthread_rwlock_t * rwlock);

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_wrlock(pthread_rwlock_t * rwlock);

int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
  • 案例:8个线程,操作同一个全局变量,3个线程不定时地写,5个线程不定时地读。
    int num = 1;
    pthread_rwlock_t rwlock;
    
    void* writeNum(void* arg) {
        while(1) {
            pthread_rwlock_wrlock(&rwlock);
            num++;
            printf("++write, tid: %ld, num: %d\n", pthread_self(), num);
            pthread_rwlock_unlock(&rwlock);
            usleep(100);
        }
        return NULL;
    }
    
    void* readNum(void* arg) {
        while(1) {
            pthread_rwlock_rdlock(&rwlock);
            printf("==read, tid: %ld, num: %d\n", pthread_self(), num);
            pthread_rwlock_unlock(&rwlock);
            usleep(100);
        }
        return NULL;
    }
    
    // 主线程
    int main() {
        pthread_rwlock_init(&rwlock, NULL);
    
        // 创建3个写线程,5个读线程
        pthread_t wtids[3], rtids[5];
        for(int i = 0; i < 3; ++i) {
            pthread_create(&wtids[i], NULL, writeNum, NULL);
        }
    
        for(int i = 0; i < 5; ++i) {
            pthread_create(&rtids[i], NULL, readNum, NULL);
        }
    
        // 设置线程分离
        for(int i = 0; i < 3; ++i) {
            pthread_detach(wtids[i]);
        }
    
        for(int i = 0; i < 5; ++i) {
            pthread_detach(rtids[i]);
        }
    
        pthread_exit(NULL);
    
        pthread_rwlock_destroy(&rwlock);
        return 0;
    }
    

生产者消费者模型

条件变量

如果说互斥锁是用于同步线程对共享数据的访问的话,那么条件变量则是用于在线程之间同步共享数据的值。条件变量提供了一种线程间的通知机制:当某个共享数据达到某个值的时候,唤醒等待这个共享数据的线程。

#include <pthread.h>

/* 初始化条件变量 */
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *cond_attr);

/* 销毁条件变量 */
int pthread_cond_destroy(pthread_cond_t *cond);

/* 以广播的方式唤醒所有等待目标条件变量的线程 */
int pthread_cond_broadcast(pthread_cond_t *cond );

/* 唤醒一个等待目标条件变量的线程 */
int pthread_cond_signal(pthread_cond_t *cond );

/* 等待目标条件变量 */
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex );

cond

  • 要操作的目标条件变量,条件变量的类型是 pthread_cond_t 结构体。

cond_attr

  • 指定条件变量的属性。如果设置为 NULL,则使用默认属性。

mutex

  • mutex参数是用于保护条件变量的互斥锁,以确保 pthread_cond_wait 操作的原子性。
  • 在调用 pthread_cond_wait 前,必须确保互斥锁 mutex 已经加锁,否则将导致不可预期的结果。pthread_cond_wait 函数执行时,首先把调用线程放入条件变量的等待队列中,然后将互斥锁 mutex 解锁。

进程和线程

如果一个多线程程序的某个线程调用了 fork 函数,那么新创建的子进程是否将自动创建和父进程相同数量的线程呢?

答案是“否”。子进程只拥有一个执行线程,它是调用 fork 的那个线程的完整复制。并且子进程将自动继承父进程中互斥锁(条件变量与之类似)的状态。也就是说,父进程中已经被加锁的互斥锁在子进程中也是被锁住的。这就引起了一个问题:子进程可能不清楚从父进程继承而来的互斥锁的具体状态(是加锁状态还是解锁状态)。这个互斥锁可能被加锁了,但并不是由调用 fork 函数的那个线程锁住的,而是由其他线程锁住的。如果是这种情况,则子进程若再次对该互斥锁执行加锁操作就会导致死锁。

1

评论区