LINKONG's Blog

Linux下通过C++调用POSIX线程库实现经典多线程问题

Wed, 17 Jun 2026 00:00:00 GMT

生产者消费者问题

本质是为了解决多个线程在信号量机制的协调下，实现有序协作，确保在单一时刻内只有一个线程能够访问修改缓冲区内的数据。

信号量机制

在计算机中使用原子级操作，实现对计算机资源的计数。

原子级操作：在计算机的控制下，将内存地址中的数据值进行增加或删除，同时将该步骤封装成为一个完整的步骤，不可被打断，此区间内任何其余操作都将被屏蔽

信号量机制下的核心操作

Somephore: 申请计数器，设置计数器的大小。

P: 申请操作，申请一个资源，并将资源数量 -1，如果此时资源数量为 0, 那么暂时阻塞该线程。

V: 释放操作, 释放一个资源，并将资源数量 +1，并唤醒因为资源不足而被P操作阻塞的线程。

Linux下的POSIX信号量库

相关对应操作:
Somephore: sem_t
P: sem_wait();
V: sem_post();

生产者消费者问题的详细解决

通过定义当前剩余空位置以及已有位置来定义缓冲区，节约系统资源，无需消耗过多资源来进行资源的判断。

sem_t full, empty;

定义互斥锁，确保在一个时刻只有一个线程可以进行操作。

sem_t mutex;

在线程执行的过程中，首先需要查看是否拥有足够的相对应的资源，然后申请互斥锁，如果申请成功，那么进行函数段的运行；运行结束后，在进行互斥锁的释放，同时释放生产出来的资源。如此循环直至，因为P操作申请不到足够的资源而阻塞。

定义生产者函数，申请空闲位置，申请成功后申请互斥锁，在申请到互斥锁后进行函数段内的操作；函数段内的操作完成后释放互斥锁，同时释放生产出的代码。

void productor(){
    sem_wait(&empty); //只要有空位置就进行申请
    sem_wait(&mutex); //申请互斥锁

    /*
        执行的程序段
    */

    sem_post(&mutex); //释放互斥锁
    sem_post(&full);  //释放生产出来的资源
}

定义消费者函数，申请已有位置，申请成功后申请互斥锁，在申请到互斥锁后进行函数段内的操作；函数段内的操作完成后释放互斥锁，同时释放消耗后的位置。

void consumer(){
    sem_wait(&full); //只要有产品就进行申请
    sem_wait(&mutex); //申请互斥锁

    /*
        执行的程序段
    */

    sem_post(&mutex); //释放互斥锁
    sem_post(&full);  //释放消耗后的位置
}

初始化

使用sem_init初始化未命名信号量。
参考格式:sem_init(sem_t *sem, int pshared, unsigned int value)
sem: 申请的信号量;
pshared: 控制信号量的范围,(0代表线程间共享，非0代表进程间共享)。
value: 信号量的初始值。
在main函数中对缓冲区以及互斥锁进行初始化:

sem_init(&mutex, 0, 1); //初始化互斥锁
sem_init(&full, 0, 0);  //初始化已有产品
sem_init(&empty, 0, N); //初始化空位置的值为N

将代码段封装成为单个线程

添加头文件库phread.h。

创建线程

使用pshared_t创建线程。

pshared_t p, c; //使用pshared_t作变量类型，创建两个线程p,c

对已有代码段进行封装

对原有代码段进行更改：

void *productor(void *arg){
    while(true){
        sem_wait(&empty);
        sem_wait(&mutex);

        /*
            执行的程序段
        */

        sem_post(&mutex);
        sem_post(&full);
    }
}

较原有代码更改后对函数类型进行了更改，重定义为void*，同时允许接收一个参数arg，代表需要使用该程序段的线程，允许函数的复用。
在main中使用'pshared_create()'对代码段进行封装。
参考格式:

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

thread: 线程名称。
attr: 线程属性，通常使用NULL传递默认参数。 start_routine: 接收封装完成的线程函数，该函数类型必须为void*。
arg: 传递给线程的参数，无则填NULL。

pthread_creat(p, NULL, productor, NULL);

完成对生产者函数的封装，同理完成对消费者函数的封装。

void *consumer(void *arg){
    while(true){
        sem_wait(&full);
        sem_wait(&mutex);

        /*
            执行的程序段
        */

        sem_post(&mutex);
        sem_post(&empty);
    }
}

在main中封装:

pthread(c, NULL, consumer, NULL);

为保证程序健壮性，设置监管程序: pthread_join()，用于在线程结束时回收资源。
参考格式:pthread_join(pthread_t thread, void **retval)。
retval：用于接收可能存在的void *类型的返回值(没有就是NULL)。

pthread_join(c, NULL);
pthread_join(p, NULL);

参考实例

附完整的伪代码:

#include <thread.h>
#include <semaphore.h>

#define N 5

sem_t mutex, full, empty;

void *productor(void *arg){
    while(true){
        sem_wait(&empty);
        sem_wait(&mutex);

        //执行的代码段

        sem_post(&mutex);
        sem_post(&full);
    }
}

void *consumer(void *arg){
    while(true){
        sem_wait(&full);
        sem_wait(&mutex);

        //执行的代码段

        sem_post(&mutex);
        sem_post(&empty);
    }
}

int main(){
    sem_init(&mutex, 0, 1);
    sem_init(&full, 0, 0);
    sem_init(&empty, 0, N);

    pthread_t p, c;
    pthread_create(p, NULL, productor, NULL);
    pthread_create(c, NULL, consumor, NULL);

    pthread_join(p, NULL);
    pthread_join(c, NULL);
}

C/C++进程的基础操作

Mon, 15 Jun 2026 00:00:00 GMT

新进程的创建

调用unistd.h库中的fork()语句,会创建一个新的子进程，在单核中，CPU的调度列表上会有两个进程，原有的父进程与新创建出的子进程，两进程并发执行，互不干扰；但是在子进程中，子进程会进行标记，将自身PID标记成为0，用于身份区分。

调用sys/types.h库下的pid_t类型，来显式定义新变量的类型。
(在大多数linux计算机中unistd.h库会自动链接sys/types.h库)

#include <unistd.h>

int main(){

    pid_t pid = fork();
    //也可以使用 int 来进行定义，但是可能会出现PID超出int上限的情况

    return 0;
}

测试是否出创建了两个进程

#include <iostream>
#include <unistd.h>
#include <sys/types.h>

using namespace std;

int main(){
    pid_t pid = fork();
    
    if(pid == 0) cout << "here is child process" << endl;
    else cout << "here is parents process" << endl;
}

查看编译结果:

可以看到程序被父进程和子进程分别调用了一次。

自定义错误参数的返回

在进程创建的过程中，当今进程创建失败时会弹出报错消息，此时我们可以利用unistd.h库下的perror函数，来对报错消息进行自定义注释。例如:perror("进程创建失败!")

父进程接收子进程的返回值

进程执行完毕后不会立即进行销毁，而是会进入类似阻塞状态并保留相对应的状态，因此需要调用unitsd.h库下的exit()函数进行资源解放。
同时sys/wait.h库下的wait()函数常与exit()函数进行配套使用，在父进程中调用wait()函数会将父进程进行阻塞，此时父进程会等待子进程的结束，并尝试接收子进程中主动调用exit()函数的返回值。

#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

int main(){
    pid_t pid = fork();
    
    if(pid < 0){
        perror("进程创建失败!");
    }else if(pid == 0){
        exit(1);
    }else{
        int status;
        wait(&status);
        cout << status;
    }
}

编译并运行:

得到编译结果，此时我们发现返回值由1变成了256，这是因为内核为了在一个int类型中插入更多信息，因此对返回值进行了左移运算，左移了8位，因此从00000000 00000001变成了00000001 00000000，即从1变为了256。

我们可以使用宏进行逆向操作 WEXITSTATUS()。此时可以得到正确的值:

如何获取PID

直接说结论:

获取自身PID: 在父进程中直接输出,在子进程中需要使用getpid()函数。
获取父进程PID: 均需要使用getppid()函数。

对上文代码进行更新:

#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

int main(){
    pid_t pid = fork();
    
    if(pid < 0){
        perror("进程创建失败!");
    }else if(pid == 0){
        
    //new
        cout << getpid() << ' '
             << getppid() << endl;
        
        exit(1);
    }else{
        int status;
        wait(&status);
        cout << WEXITSTATUS(status);

    //new
        cout << pid << ' '
             << getppid();
    }
}

查看编译结果:

可以看到已经成功打印了。

C++ nlohmann/json的基本操作

Sat, 06 Jun 2026 00:00:00 GMT

nlohmann/json库提供了一种格式用于存储，支持多种类型的格式存储读取

解释了几种基础操作

json文件的声明
json数组中元素的插入和读取
json对象的键值映射
C++类与json类的相互转化

github地址：https://github.com/nlohmann/json

json文件的声明：

j = nlohmann::json();

nlohmann::json几乎支持C++中所有类型

创建测试变量：

std::string a = "hello world";
int b = 10;
float c = 1.1;

在声明时进行插入:

j = nlohmann::json{
    {"a", a},
    {"b", b},
    {"c", c}
};

或者:

j = nlohmann::json();
j["a"] = a;
j["b"] = b;
j["c"] = c;

从json变量中读取数据

j.at("a").get_to(a);
j.at("b").get_to(b);
j.at("c").get_to(c);

创建一个json数组 声明 nlohmann::json j = nlohmann::json::array(); 插入操作：

j.push_back(a);
j.push_back(b);
j.push_back(c);
显示长度：
j.size();

在C++类中的自动调用

class test{
private:
    std::string a;
    int b;
public:
    test(){
        std::cin >> a >> b;
    }
    ~test();
    
    //使用friend实现外部调用,实现自动转化
    friend void to_json(nlohmann::json & j, const test & t){
        j = nlohmann::json{
            {"a", t.a},
            {"b", t.b}
        };
    }

    friend void from_json(const nlohmann::json & j, test & t){
        j.at("a").get_to(t.a);
        j.at("b").get_to(t.b);
    }
};

json对象的键值映射

//创建一个json对象/

j = nlohmann::json::object();

//新建键对数组
const std::string arr[2] = {"a", "b"};

可以用于区分插入的数据,内部数据可以采用数组遍历的方式进行循环读取