一. 引言

这一章,来学习linux应用的重点之一:线程。

上一章,学习到了进程,我们知道进程是linux系统下资源分配的一种方式,每一个进程在内核中有一个独立的对应的页框,所以不同进程间彼此是相互独立的,如果要进行通讯数据交互,就需要用到进程间通讯如管道,共享内存,消息队列,socket等方式。但是在系统的调度使用中,不同进程间切换的系统开销很大,因为存在页表切换,TLB转义,CPU Cache缓存等等,这些导致了进程间切换的开销巨大,为了解决这一问题,所以操作系统就引入了轻量级进程LWP(线程)。

线程是linux系统下资源调度的一种方式。

二. 介绍

2.1 概念

线程:线程是操作系统能够进行CPU调度的最小执行单位,也是进程内部的一条独立执行路径,他不拥有自己的资源,是依附于进程的,所以共享进程的大部分资源,如代码段,数据段,全局变量,文件描述符等等,但是每一个线程都有自己独立的寄存器状态,程序计数器和栈,而切换线程是只需要保存和恢复少量寄存器,不需要更换整个内存地址空间,所以会很快。

Linux不区分进程、线程:在linux系统中是不区分进程、线程的,因为在内核里,进程和线程都可以看成task_struct这样的可调度任务,内核本身是不严格区分两者的,而关键点在于资源是否共享。

Linux的线程库是后来加入的,内核没有它的库,使用时得记得链接线程库:线程通常是借助线程库(pthread),通过clone系统调用创建共享地址空间的执行流,在编译时需要连接pthread的库,因为像pthread_create这样的API并不属于标准C库,二十POSIX线程接口的一部分

2.2 特点

先说一下线程的特点

  • 线程是系统独立调度和分派CPU资源的基本单位。线程切换仅需保存和恢复少量寄存器(PC、SP、通用寄存器),不涉及地址空间切换(即不切换页表基址寄存器 ),因此上下文切换开销远小于进程.

  • 线程本身不拥有进程资源,但共享所属进程的地址空间等资源,同时又有自己独立的执行上下文(如栈和寄存器)
  • 多个线程可以并发执行,每个线程都是一个独立的执行路径,拥有自己的线程ID(TID)
  • 线程依附于进程存在,进程结束,内部所有线程都会被中止。线程崩溃(如段错误)会导致其所属进程终止(这里是指异常崩溃,正常退出被回收不会影响进程)。

再具体说一下线程拥有的资源

一个进程中的多个线程共享以下资源:

  • 可执行的指令
  • 虚拟地址空间
  • 静态数据,全局变量,堆
  • 进程中打开的文件描述符
  • 信号处理方式,socket等
  • 当前工作目录
  • 用户ID
  • 用户组ID

每个线程私有的资源包括:

  • 线程ID (TID)
  • PC(程序计数器)和相关寄存器
  • 栈(线程中堆不私有,即使创建了也是进程共享资源)
  • 错误号 (errno)
  • 优先级
  • 执行状态和属性

三. 线程使用

在线程的实际中,其实已经有好几套很成熟的使用的标准了,我就先说明两套,一个是POSIX 标准,一个是C++。

3.1 POSIX 线程

POSIX 线程是 Linux 应用层最常用的一套线程接口,也是比较底层的一种使用

在使用线程时都要连接对应的线程库 pthread 或者是 -lpthread . (链接示例:gcc xxx -o xxx -pthread)

1.创建线程

#include <pthread.h>
//线程的创建
int pthread_create(pthread_t *thread,
                   const pthread_attr_t *attr,
                   void *(*start_routine)(void *),
                   void *arg);


struct pthread_attr_t
{
    unsigned p_state;
    void *stack;
    size_t s_size;
    struct sched_param param;
};

返回:成功返回 0,失败返回 错误码。

  • thread:输出参数,成功时保存新线程的 ID。

  • attr:线程属性,传 NULL 表示使用默认属性。

  • start_routine:线程入口函数,类型必须是 void *(*)(void *)。

  • arg:传给线程入口函数的参数,类型是 void *

创建线程中的第二个参数线程属性涉及到其实很多东西,包括线程优先级,系统调度等,是需要深入理解linux内核系统调度方面了,这里就不过多说了,后续我再学习时,也整理一份关于此的详细内容。

2.查看线程

#include <pthread.h>

pthread_t pthread_self(void);//获取当前线程的 POSIX 线程 ID

#include <unistd.h>
#include <sys/syscall.h>

pid_t gettid(void);//获取当前线程的内核 TID(glibc 2.30+)
long tid = syscall(SYS_gettid);//兼容旧版 glib

获取的是线程的ID,要在线程中使用可以获取此线程的ID

3.资源回收

线程占用的资源并不会因为执行结束而得到释放,如线程描述符,内核TID线程栈等等,所以需要用到pthread_join来手动回收,他会阻塞等待线程结束,并回收线程占有的资源

#include <pthread.h>

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

返回值:成功返回 0,失败返回 错误码。

此函数会调用线程阻塞直到thread结束

  • thread:线程id

  • retval:接收线程退出时返回的数据(返回值)。

4.线程取消

向指定线程发送取消请求,这里是取消请求不是强制杀死线程,线程什么时候取消与取消状态,取消类型等有关,请求会一直发送,直到线程执行到有取消点的地方比如sleep,read、write,pthread_testcancel,accept等这种。

#include <pthread.h>

int pthread_cancel(pthread_t thread);

返回值:成功返回 0,失败返回 错误码。

  • thread:线程id

5.结束线程

#include <pthread.h>

void pthread_exit(void *retval);

这个是线程结束的函数,主动结束当前线程

  • retval:接收线程退出时返回的数据(返回值)。

6.线程分离

线程创建其实会有两种状态:joinable 和 detached,对于初始创建的线程,会默认处于joinable,意思是线程结束后资源会保留,必须由其他线程通过pthread_join进行回收资源

而detached状态意思是线程结束后资源会由系统自己回收,不由创建方回收。

需要注意,线程只能处于二选一的状态,一个线程不能既由线程回收又由系统回收。

下面的函数就是让线程不由创建者进行资源回收,自行结束后,由系统回收资源

#include <pthread.h>

int pthread_detach(pthread_t thread);

返回值:成功返回 0,失败返回 错误码。

3.2 C++线程

1.介绍

在c++中,线程的创建等等都基于POSIX被封装成了一到自动化的类中(RAII机制),锁离开作用域会自动释放(锁的使用在第四节),给出一个完整的示例。

2. 基本线程

namespace std {
    class thread {
    public:
        // 1. 构造函数
        template<class Function, class... Args>
        explicit thread(Function&& f, Args&&... args); //构造函数创建线程

        // 3. 核心 API
        bool joinable() const noexcept; 
        void join();//等待线程结束回收资源
        void detach(); //线程分离
    };
    class mutex {
    public:
        mutex() noexcept;
        // 核心 API
        void lock();     // 阻塞加锁
        bool try_lock(); // 尝试加锁,成功返回 true,失败返回 false
        void unlock();   // 解锁
    };
    class condition_variable {
    public:
        condition_variable();
        ~condition_variable();

        // 通知 API
        void notify_one() noexcept; // 唤醒一个等待线程
        void notify_all() noexcept; // 唤醒所有等待线程

        // 等待 API(必须配合 unique_lock 使用)
        void wait(unique_lock<mutex>& lock);
    };
}

这里是基本的c++线程的std命名空间中的封装,对应的api我在上面列出来了。

3. lamdba表达式

lambda表达式是c++不同于POSIX线程的一个很方便的工具,免去了我们需要定义一个完成的线程处理函数的过程,直接使用匿名函数来创建

std::thread t([factor](int base) {
        std::cout << "子线程计算结果: " << base * factor << "\n";
    }, x);

这里直接给出一个使用示例吧,
[factor] 是用来捕获外层作用域的参数,这里捕获的值是const不可以修改的,如果需要修改可以使用&引用,但是这种方式修改时会连同原变量一起修改,或者使用(int base) mutable{...  这样使用,这样会在线程函数内部使用单独的值,修改也不会改变外部参数的值,
(){} 就是创建一个函数的基本步骤,最后的一个x 是传给函数的参数,会赋值给base。

差不多就先说这么多吧,只是使用方式和安全性等有差别,在使用中可以更多的了解,下面是完整的示例

#include <iostream>
#include <thread>
#include <mutex>
#include <atomic>
#include <chrono>


std::mutex mtx;                          // 保护 shared_x
std::atomic<bool> running{true};         // 线程运行标志
int shared_x = 0;                        // 全局,线程共享

void worker1() {
    while (running.load()) {
        {
            std::lock_guard<std::mutex> lock(mtx);   // 构造加锁
            shared_x = 30;
            std::cout << "[thread worker1] update shared_x = " << shared_x << "\n";
        }                                            // 作用域结束,自动解锁

        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    std::cout << "[thread worker1] exit\n";
}

void worker2() {
    while (running.load()) {
        {
            std::lock_guard<std::mutex> lock(mtx);
            shared_x = 50;
            std::cout << "[thread worker2] update shared_x = " << shared_x << "\n";
        }
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    std::cout << "[thread worker2] exit\n";
}

int main() {
    std::cout << "[thread main] init shared_x = " << shared_x << "\n";
    int x=20;
    int y=100;
    std::thread t([&y](int k){
        while(running.load()){
            k++;
            y++;
            std::cout << "[thread main] k = " << k << ", y = " << y << "\n";
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
        std::cout << "[thread main] exit\n";
    },x);
    std::thread t1(worker1);             // 构造即启动
    std::thread t2(worker2);

    std::cout << "[thread main] id = " << std::this_thread::get_id() << "\n";
    std::cout << "[thread worker1] id = " << t1.get_id() << "\n";
    std::cout << "[thread worker2] id = " << t2.get_id() << "\n";

    // 让工作线程跑约 5 秒
    std::this_thread::sleep_for(std::chrono::seconds(5));

    running.store(false);                // 通知线程退出
    t1.join();                           // 等待并回收
    t2.join();
    t.join();

    std::cout << "[thread main] all threads exit, program exit\n";
    return 0;
}

四. 线程互斥锁

通过上面的学习,我们知道了如何创建使用线程等操作,也知道了线程会共享进程的资源,并有自己独立的上下文内存,实际场景中我们可能会开很多个线程,那么多个线程之间就会共享同一个进程资源,这就会引起一个问题,当超过两个线程需要操作共享资源中的同一个资源时,到底是谁先处理呢。比如两个A,B线程都要操作一个变量,线程A会从内存读取到变量数值进行运算在写入,线程B也从内存读取变量数值运算写入,如果A还没有写入完成,cpu就切换到了线程B读取了数据,那最后运算结果肯定是不对的,甚至会发生错误,数值随机。这就形成了线程里非常重要的一个概念竞态条件

竞态条件:程序的正确性依赖于多个线程、进程或事件执行的时序或交错顺序。当这些并发执行单元以不同顺序访问共享资源时,可能得到不同甚至错误的结果。

解决这个问题就需要用到  互斥锁 ( mutex )

互斥锁的原理其实非常简单,就是在一个线程操作一个变量或资源时,给加上一把锁不让其他线程同步操作他,当操作完成后把锁解开,另一个线程就可以在操作此资源了,举个简单的例子,要对int count变量进行运算,线程A先上个锁不然其他线程操作,然后进行运算处理写入,完成后把锁解开,其他线程就可以继续读取或操作这个变量了。

基本流程是初始化(创建)→ 加锁(申请/获取)→ 解锁(释放)→ 销毁

1.互斥锁的创建

#include <pthread.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //静态初始化

//动态初始化
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr); 

返回值:成功返回 0,失败返回错误码

  • mutex:指向要初始化的互斥锁对象。

  • mutexattr:互斥锁属性。传 NULL 表示使用默认属性;需要递归锁、检错锁时才传自定义属性对象。

在运行时动态初始化一把互斥锁。适用于堆上分配、结构体成员、或需要非默认属性的场景。用这种方式初始化的锁,不再使用时应当调用 pthread_mutex_destroy
静态初始化则不需要调用pthread_mutex_destroy

锁设置的属性这里也列一个表格了解一下,如果出现什么问题,可以加属性用于调试

锁类型行为
PTHREAD_MUTEX_NORMAL默认/普通锁。不检测死锁。同一线程重复加锁会自死锁;解锁非自己持有的锁行为未定义。
PTHREAD_MUTEX_ERRORCHECK检错锁。同一线程重复加锁返回 EDEADLK;解锁非自己持有的锁或已解锁的锁返回 EPERM 或 EINVAL。用于调试。
PTHREAD_MUTEX_RECURSIVE递归锁。同一线程可以重复加锁,内部维护一个计数。每加锁一次,必须对应解锁一次,计数归零后锁才真正释放。
PTHREAD_MUTEX_DEFAULT默认行为,通常映射为 NORMAL,但规范允许实现将其映射为其他类型,行为不完全确定。

2.互斥锁的申请

#include <pthread.h>

int pthread_mutex_lock(pthread_mutex_t *mutex); //阻塞加锁

int pthread_mutex_trylock(pthread_mutex_t *mutex); //非阻塞加锁

//超时的加锁
#include <pthread.h>
#include <time.h>

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

返回值:成功返回 0,失败返回 错误码。

  • mutex:要初始化的互斥锁对象

  • pthread_mutex_lock():无法获得锁,任务阻塞(挂起休眠,不占 CPU)

  • pthread_mutex_trylock():无法获得锁,返回EBUSY而不是挂起等待

  • abstime:等待超时时间,绝对等待时间,需要先获取时间,再设置超时的时间

pthread_mutex_lock 的非阻塞版本。拿不到锁时立即返回,由调用者决定后续策略(重试、做别的事、放弃等)。常用于避免死等,或实现“尝试获取,失败则释放已有锁再重试”的逻辑。

3.互斥锁的释放

#include  <pthread.h>

int  pthread_mutex_unlock(pthread_mutex_t *mutex);

返回值:成功返回 0,失败返回错误码

  • mutex:指向当前线程持有的互斥锁对象。

这里释放锁是指释放锁的所有权而不是销毁

4.互斥锁的销毁

#include  <pthread.h>

int pthread_mutex_destroy(pthread_mutex_t *mutex)

返回值:成功返回 0,失败返回错误码

  • mutex:指向要销毁的互斥锁对象。

在Linux中,互斥锁并不占用任何资源,因此LinuxThreads中的 pthread_mutex_destroy()除了检查锁状态以外(锁定状态则返回EBUSY)没有其他动作

5.锁清理

void pthread_cleanup_push(void (*routine)(void *), void *arg);
void pthread_cleanup_pop(int execute);

//示例的函数,对应void (*routine)(void *)
static void unlock_cleanup(void *arg) {
    pthread_mutex_unlock((pthread_mutex_t *)arg);
}

返回值:无

  • routine:清理函数指针。线程退出(cancel 或 pthread_exit)时会被调用

  • arg:传给 routine 的参数

  • execute:0 = 弹出后丢弃,不执行;非 0 = 弹出后立刻执行该项的 routine(arg)

这是可用于锁清理的宏,使用时需要成对出现,使用pthread_cleanup_push把清理函数入队,pthread_cleanup_pop用此进行弹出,execute参数决定了是否执行清理函数,这是POSIX 标准的执行,会在线程结束时自动调用pthread_cleanup_pop,确保锁清理函数执行,保证锁的释放。

6.死锁

了解锁的使用后,我们来说一个非常常见的问题:死锁

死锁问题的来源同样是因为竞争资源,具体是指线程A占有资源A的同时,想访问使用资源B,但是线程B在这个时候占有着资源B,想要访问使用资源A,此时,两个线程都占有着对方想要的资源又想获取对方的资源,因为两方都用锁占有着资源,无法解锁,线程A和线程B就会死等对方手里的资源释放,就形成了一个死结,这就是死锁。

解决方法:

1.这个问题的解决最好的方式就是从源头解决,顺序使用锁,不交叉使用,或者用超时锁,让线程不用死等,

2.如果发生需要定位问题,可以使用gdb调试器查看进程,堆栈使用等,或者加日志打印信息是比较方便的

3.valgrind --tool=helgrind ./程序 可以用来检测线程错误,包括数据竞争,锁,锁顺序等问题  

-fsanitize=thread在编译时加上这个检测线程,如果有数据竞争,会直接打印报告

7.示例

线程和互斥锁使用示例

#include <stdio.h>
#include <unistd.h> // 包含 pid_t 和 fork()、getpid()
#include <errno.h>  // 用于 perror
#include <pthread.h> // 包含 pthread_create()、pthread_join()、pthread_exit()
#include <atomic> // 包含 std::atomic

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
int y = 0;  //全局,线程共享
void* testmain(void *arg){
    y = 5;
    printf("y是: %d \n",y);
    static int i=25;
    while(1){
        pthread_mutex_lock(&mutex);
        *(int*)arg = 30 ; 
        printf("线程1修改后的值是: %d \n",*(int*)arg);
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
    return &i;
}
void* testmain2(void *arg){
    while (1)
    {
        pthread_mutex_lock(&mutex);
        *(int*)arg = 50 ; 
        printf("线程2修改后的值是: %d \n",*(int*)arg);
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
    return NULL;
}

int main(){
    int x=25;
    pthread_t th,th2;
    printf("主线程修改前的值是: %d \n",x);
    pthread_create(&th, NULL,testmain, &x);
    pthread_create(&th2, NULL,testmain2, &x);
    pid_t pid = gettid();
    printf("linux内核的tid是:  %d \n",pid);
    pthread_t pid2 = pthread_self();
    printf("pthread_t的tid是:  %lu \n",pid2);
    void *ret;
    while(1){
        int key = getchar();
        if(key==27){
            printf("退出 \n");
            break;
        }
        sleep(1);
    }
    pthread_cancel(th);
    pthread_cancel(th2);
    pthread_join(th,&ret);
    pthread_join(th2,&ret);
    pthread_mutex_destroy(&mutex);
    return 0;
}

这是一个简单的使用示例,创建两个线程并循环改变一个变量的值,然后设置取消函数发送取消信号,等待线程退出和销毁锁。输出如下:

我们可以注意到,    pthread_create(&th, NULL,testmain, &x);这个函数中我把x变量的地址传入了线程函数中,如果把&x改为NULL那函数中的x就会报错。这就涉及到线程中共享进程信息的部分,线程会共享进程地址空间,而x是在栈上的,而栈不是共享的。每个线程创建时,线程库会为它单独分配一块栈,是私有的 ,像全局变量、静态变量,堆等这些才都是共享的,所以如果定义一个全局的变量,那不同线程是都可以读取到的,

另外,关于线程取消函数pthread_cancel和锁还有一个问题,线程取消函数是给线程发送取消信号,线程内部遇到取消点(如sleep等)才会取消,配合锁可以引起一个问题,如果当上锁之后有取消点线程取消了,锁没有解除,另一个线程会等待解锁使用。而持锁的线程已经没有了,锁无法取消,这就陷入了死锁的状态。所以更常用的方式是不用while(1)的死循环,用一个std::atomic_int running(1) 循环条件来控制,不用pthread_cancel了,用atomic_store(&running, 0);来控制,这样更有保证,或者是使用锁清理。

大概是下面这种

#include <stdio.h>
#include <unistd.h> // 包含 pid_t 和 fork()、getpid()
#include <errno.h>  // 用于 perror
#include <pthread.h> // 包含 pthread_create()、pthread_join()、pthread_exit()
#include <atomic> // 包含 std::atomic
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
std::atomic_int running(1); // 线程运行标志

static void unlock_cleanup(void *arg) {
    pthread_mutex_unlock((pthread_mutex_t *)arg);
}

int x = 0;  //全局,线程共享
void* testmain(void *arg){
    while(running){
        // pthread_mutex_lock(&mutex);
        // x = 30 ; 
        // printf("线程1修改后的值是: %d \n",x);
        // pthread_mutex_unlock(&mutex);
        pthread_mutex_lock(&mutex);
        pthread_cleanup_push(unlock_cleanup, &mutex);
        x = 30;
        printf("线程1修改后的值是: %d \n",x);
        pthread_cleanup_pop(1);           // 执行 unlock_cleanup,解锁
        sleep(1);
    }
    return NULL;
}
void* testmain2(void *arg){
    while (running)
    {
        // pthread_mutex_lock(&mutex);
        // x = 50 ; 
        // printf("线程2修改后的值是: %d \n",x);
        // pthread_mutex_unlock(&mutex);
        pthread_cleanup_push(unlock_cleanup, &mutex);
        x = 50;
        printf("线程2修改后的值是: %d \n",x);
        pthread_cleanup_pop(1);           // 执行 unlock_cleanup,解锁        
        sleep(1);
    }
    return NULL;
}

int main(){
    pthread_t th,th2;
    printf("主线程修改前的值是: %d \n",x);
    pthread_create(&th, NULL,testmain, NULL);
    pthread_create(&th2, NULL,testmain2, NULL);
    pid_t pid = gettid();
    printf("linux内核的tid是:  %d \n",pid);
    pthread_t pid2 = pthread_self();
    printf("pthread_t的tid是:  %lu \n",pid2);
    while(1){
        int key = getchar();
        if(key==27){
            printf("退出 \n");
            break;
        }
        sleep(1);
    }
    // pthread_cancel(th);
    // pthread_cancel(th2);
    atomic_store(&running, 0);
    pthread_join(th,NULL);
    pthread_join(th2,NULL);
    pthread_mutex_destroy(&mutex);
    return 0;
}

五.线程池

posix没有规定线程池,这是通过我们自己手动封装实现的一个高效线程工作方式

从性能资源的角度来看,线程在创建,执行和销毁时都会有开销,如果线程反复创建和销毁就会把系统的资源浪费在大量的创建和销毁过程中,这是我们不想发生的场景,于是,线程池和条件变量应运而生

线程池:线程池预先创建一组工作线程,并维护一个受互斥锁和条件变量保护的共享任务队列。提交者将任务入队并唤醒等待中的工作线程;工作线程循环从队列取任务,在锁外执行,执行完回到等待状态。通过复用线程降低频繁创建销毁的开销,并通过固定或受限的线程数控制并发度;关闭时用停止标志加广播唤醒,再逐个 join 实现退出。

上面的线程池是一个基本的固定的线程池,大概逻辑是这样的,线程池有很多种实现方式,有固定的,动态扩建的,多队列的等等,我们这里就介绍一个典型的吧:固定线程池 + 单任务队列 + mutex + 条件变量。

1.条件变量

条件变量是线程间用来“等某个条件成立”的同步工具,让线程在条件不满足时休眠,条件满足时被唤醒,而不是一直循环检查,造成空转浪费资源

1.1 创建初始化

#include <pthread.h>

pthread_cond_t cond; //定义

//初始化
int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr);

成功返回 0,失败返回错误码

  • cond:指向需要初始化的条件变量。

  • attr:条件变量的属性,传 nullptr 表示默认属性。

  • 可以直接使用静态初始化 cond = PTHREAD_COND_INITIALIZER

  • pthread_cond_init动态初始化需要配合pthread_cond_destroy释放资源,不然可能资源泄露

1.2 等待

#include <pthread.h>

int pthread_cond_wait( pthread_cond_t *cond, pthread_mutex_t *mutex);

成功返回 0,失败返回错误码

  • cond:等待的条件变量。

  • mutex:与条件变量配合使用的互斥锁,调用前必须由当前线程持有。

此函数使用时,会自动释放锁,并进入等待被唤醒的状态,被唤醒后会获取锁

1.3 唤醒

#include <pthread.h>

//唤醒至少一个正在等待该条件变量的线程
int pthread_cond_signal(pthread_cond_t *cond);

//唤醒所有正在等待该条件变量的线程。
int pthread_cond_broadcast(pthread_cond_t *cond);

成功返回 0,失败返回错误码。

  • cond:要通知的条件变量。

1.4 销毁

#include <pthread.h>

int pthread_cond_destroy(pthread_cond_t *cond);

成功返回 0,失败返回错误码。

  • cond:要销毁的条件变量。

销毁不再使用的条件变量。必须确保没有线程仍在该条件变量上等待

2.线程池

线程池是自己封装的,主要包括几个部分:任务队列,工作线程,同步对象,控制标志。

组成

作用

pthread_t

保存工作线程

std::queue

保存等待执行的任务

pthread_mutex_t

保护任务队列

pthread_cond_t

通知工作线程有新任务

bool stop

控制线程池退出

2.1 任务队列

任务队列也是由自己进行封装的,这里用c语言完整看一下实现过程吧,用一个环形队列来实现任务队列,可以理解一下实现过程

#include <stdio.h>
#define TaskNUM  10// 任务队列的最大容量

typedef struct TaskQueue{
    Task task[TaskNUM];
    int head ;
    int tail ;
    int count ;
}TaskQueue;

int task_push(TaskQueue *queue, Task *task){
    if(queue->count == TaskNUM) return -1; // 队列已满,无法添加任务
    queue->task[queue->tail] = *task;
    queue->tail = (queue->tail + 1) % TaskNUM;//写到末尾回到 0
    queue->count++;
    return 0;
}

int task_pop(TaskQueue *queue , Task *task){
    if(queue->count == 0) return -1;
    *task = queue->task[queue->head];
    queue->head = (queue->head + 1) % TaskNUM; //读到末尾回到 0
    queue->count--; 
    return 0;
}

2.2 线程队列

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

struct threadpool{
    pthread_mutex_t lock; // 互斥锁,用于保护任务队列的访问
    pthread_cond_t notify; // 条件变量,用于通知线程有新任务到来
    pthread_t  threads[THREADNUM]; // 线程数组,存储线程池中的线程
    TaskQueue queue; // 任务队列,存储待执行的任务
    int thread_count; // 线程池中线程的数量
    int shutdown; // 标志,指示线程池是否关闭
};

void *worker(void * arg){
    threadpool *pool = (threadpool *)arg;
    while(1){
        pthread_mutex_lock(&pool->lock);
        while(pool->queue.count==0 && !pool->shutdown) {
            pthread_cond_wait(&pool->notify,&pool->lock);
        }
        if(pool->queue.count==0 && pool->shutdown) {
            pthread_mutex_unlock(&pool->lock);
            break;
        }
        Task task;
        if(task_pop(&pool->queue,&task)!=0){
            pthread_mutex_unlock(&pool->lock);
            printf("Task popped from queue failed\n");
            continue;
        }
        pthread_mutex_unlock(&pool->lock);
        task.func(task.arg);
    }
    return NULL;
}

int threadPoolAddTask(threadpool *pool,void (*function)(void *),void *arg){
    // 1. 创建任务
    Task task = {function, arg};
    // 2. 加锁
    pthread_mutex_lock(&pool->lock);
    // 3. 检查线程池是否停止
    if (pool->shutdown)
    {
        pthread_mutex_unlock(&pool->lock);
        return -1;
    }
    // 4. 将任务添加到队列
    if (task_push(&pool->queue, &task) != 0)
    {
        pthread_mutex_unlock(&pool->lock);
        return -1;
    }
    // 5. 通知一个工作线程
    pthread_cond_signal(&pool->notify);
    // 6. 解锁
    pthread_mutex_unlock(&pool->lock);
    return 0;
}

void threadPoolDestroy(threadpool *pool)
{
    // 1. 加锁
    pthread_mutex_lock(&pool->lock);
    // 2. 设置停止标志
    pool->shutdown = 1;
    // 3. 唤醒所有等待线程
    pthread_cond_broadcast(&pool->notify);
    // 4. 解锁
    pthread_mutex_unlock(&pool->lock);
    // 5. 等待所有线程退出
    for (int i = 0; i < THREADNUM; i++)
    {
        pthread_join(pool->threads[i], NULL);
    }
    // 6. 销毁同步资源
    pthread_mutex_destroy(&pool->lock);
    pthread_cond_destroy(&pool->notify);
}

这里自己封装了工作函数,线程池增加销毁任务。

然后给出一个完整的示例,可能会挺难理解,因为有点绕,需要有队列的知识,先入先出,入栈出栈这些

#include <stdio.h>
#include <unistd.h> // 包含 pid_t 和 fork()、getpid()
#include <pthread.h> // 包含 pthread_create()、pthread_join()、pthread_exit()

#define THREADNUM 4 // 线程池中线程的数量
#define TaskNUM  10// 任务队列的最大容量

typedef struct Task{
    void (*func)(void *); // 函数指针,指向任务函数
    void * arg; // 任务函数的参数
}Task;

typedef struct TaskQueue{
    Task task[TaskNUM];
    int head ;
    int tail ;
    int count ;
}TaskQueue;

int task_push(TaskQueue *queue, Task *task){
    if(queue->count == TaskNUM) return -1; // 队列已满,无法添加任务
    queue->task[queue->tail] = *task;
    queue->tail = (queue->tail + 1) % TaskNUM;//环形
    queue->count++;
    return 0;
}

int task_pop(TaskQueue *queue , Task *task){
    if(queue->count == 0) return -1;
    *task = queue->task[queue->head];
    queue->head = (queue->head + 1) % TaskNUM;
    queue->count--; 
    return 0;
}

void task_function(void * arg){
    int  num = (int)(intptr_t)arg;
    printf("线程 %lu 开始任务 %d\n",
           (unsigned long)pthread_self(), num);

    sleep(2);

    printf("线程 %lu 完成任务 %d\n",
           (unsigned long)pthread_self(), num);
}

struct threadpool{
    pthread_mutex_t lock; // 互斥锁,用于保护任务队列的访问
    pthread_cond_t notify; // 条件变量,用于通知线程有新任务到来
    pthread_t  threads[THREADNUM]; // 线程数组,存储线程池中的线程
    TaskQueue queue; // 任务队列,存储待执行的任务
    int thread_count; // 线程池中线程的数量
    int shutdown; // 标志,指示线程池是否关闭
};

void *worker(void * arg){
    threadpool *pool = (threadpool *)arg;
    while(1){
        pthread_mutex_lock(&pool->lock);
        while(pool->queue.count==0 && !pool->shutdown) {
            pthread_cond_wait(&pool->notify,&pool->lock);
        }
        if(pool->queue.count==0 && pool->shutdown) {
            pthread_mutex_unlock(&pool->lock);
            break;
        }
        Task task;
        if(task_pop(&pool->queue,&task)!=0){
            pthread_mutex_unlock(&pool->lock);
            printf("Task popped from queue failed\n");
            continue;
        }
        pthread_mutex_unlock(&pool->lock);
        task.func(task.arg);
    }
    return NULL;
}

int threadPoolAddTask(threadpool *pool,void (*function)(void *),void *arg){
    // 1. 创建任务
    Task task = {function, arg};
    // 2. 加锁
    pthread_mutex_lock(&pool->lock);
    // 3. 检查线程池是否停止
    if (pool->shutdown)
    {
        pthread_mutex_unlock(&pool->lock);
        return -1;
    }
    // 4. 将任务添加到队列
    if (task_push(&pool->queue, &task) != 0)
    {
        pthread_mutex_unlock(&pool->lock);
        return -1;
    }
    // 5. 通知一个工作线程
    pthread_cond_signal(&pool->notify);
    // 6. 解锁
    pthread_mutex_unlock(&pool->lock);
    return 0;
}

void threadPoolDestroy(threadpool *pool)
{
    // 1. 加锁
    pthread_mutex_lock(&pool->lock);
    // 2. 设置停止标志
    pool->shutdown = 1;
    // 3. 唤醒所有等待线程
    pthread_cond_broadcast(&pool->notify);
    // 4. 解锁
    pthread_mutex_unlock(&pool->lock);
    // 5. 等待所有线程退出
    for (int i = 0; i < THREADNUM; i++)
    {
        pthread_join(pool->threads[i], NULL);
    }
    // 6. 销毁同步资源
    pthread_mutex_destroy(&pool->lock);
    pthread_cond_destroy(&pool->notify);
}

int main(){
    //TaskQueue queue={0};
    threadpool pool={0};
    // 初始化同步对象
    pthread_mutex_init(&pool.lock, NULL);
    pthread_cond_init(&pool.notify, NULL);
    for(int i=0 ; i<THREADNUM ; i++){
        pthread_create(&pool.threads[i],NULL,worker,&pool);
    }
    for(int i=0 ; i<TaskNUM; i++){
        threadPoolAddTask(&pool,task_function,(void *)(intptr_t)i);

    }
    sleep(2);
    threadPoolDestroy(&pool);
    return 0;
}

这里大部分都是用c语言实现的,属于完全的手搓,对于c++而言,STL已经封装好了关于队列和线程很多的部分,实现就会容易很多

Logo

openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目,面向数字基础设施四大核心场景(服务器、云计算、边缘计算、嵌入式),全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构

更多推荐