Linux 线程同步与互斥详解（含 C++ 代码示例）

根据互斥的定义：任何时刻只允许一个线程申请锁成功！其他线程申请失败时，会在 mutex 锁上进行阻塞，本质也就是等待。

推出了不阻塞的锁： 5. 不阻塞的申请锁：pthread_mutex_trylock(pthread_mutex_t* mutex)

线程在临界区中访问加锁的临界资源的时候是可能发生切换，但即便切换了别人也仍然不能访问。（理解成，一个房间只要有钥匙才能进入，而当我们进入后我们出去时是拿着钥匙走的，别人同样还是进不去）

1.3 简单互斥锁（源码）

// main.cpp
#include <iostream>
#include <thread>
#include <cstdlib>
#include "LockGuard.hpp"
#include "Thread.hpp"
#include <unistd.h>
#include <vector>
#include <string>
using namespace std;

// 应用方的视角
// 为了能同时传递线程名和锁变量
// 就构建 ThreadData 类，让其可以直接一起传递进去
class ThreadData {
public:
    ThreadData(string& name, pthread_mutex_t* lock) : threadname(name), pmutex(lock) {}
public:
    string threadname;
    pthread_mutex_t* pmutex;
};

void Print(int num) {
    while (num) {
        std::cout << "hello world: " << num-- << std::endl;
        sleep(1);
    }
}

int ticket = 10000; // 全局的共享资源
// pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //全局锁，不用 init 初始化

void GetTicket(ThreadData* td) // 抢票原理：
{
    while (true) {
        {
            // 通过花括号括起来的部分为一个代码块也就是确定了临界区
            // pthread_mutex_lock(mutex); //加锁
            LockGuard lockguard(td->pmutex); // LockGuard 类会自动的申请锁，并且释放锁（因为当他构造和析构时就会执行加锁解锁操作！）
            if (ticket > 0) // 4. 一个线程在临界区中访问临界资源的时候，可不可能发生切换？可能，完全允许！！
            {
                // 充当抢票花费的时间
                usleep(1000);
                printf("%s get a ticket: %d\n", td->threadname.c_str(), ticket);
                ticket--;
                // pthread_mutex_unlock(mutex); //解锁
            }
            else {
                // pthread_mutex_unlock(mutex); //解锁
                break;
            }
        }
    }
}

string GetThreadName() {
    static int number = 1;
    char name[64];
    snprintf(name, sizeof(name), "Thread-%d", number++);
    return name;
}

int main() {
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, nullptr);
    
    string name1 = GetThreadName();
    ThreadData* td1 = new ThreadData(name1, &mutex); // 构造类
    Thread<ThreadData*> t1(td1, GetTicket, name1); // 把 ThreadData 这个类做参数传递进去，在内部就能同时拿到
    
    string name2 = GetThreadName();
    ThreadData* td2 = new ThreadData(name2, &mutex);
    Thread<ThreadData*> t2(td2, GetTicket, name2);
    
    string name3 = GetThreadName();
    ThreadData* td3 = new ThreadData(name3, &mutex);
    Thread<ThreadData*> t3(td3, GetTicket, name3);
    
    string name4 = GetThreadName();
    ThreadData* td4 = new ThreadData(name4, &mutex);
    Thread<ThreadData*> t4(td4, GetTicket, name4);
    
    t1.Start();
    t2.Start();
    t3.Start();
    t4.Start();
    
    t1.Join();
    t2.Join();
    t3.Join();
    t4.Join();
    
    pthread_mutex_destroy(&mutex);
    delete td1;
    delete td2;
    delete td3;
    delete td4;
    return 0;
}

// Thread.hpp
#pragma once
#include <iostream>
#include <string>
#include <functional>
#include <pthread.h>
using namespace std;

// typedef function<void()> func_t
// 注意！！
// 此处的修改，因为带有模板所以后面用该类型变成 fun_t<T>
template<class T>
using func_t = function<void(T)>; // 返回值 void 参数为；加上模板，这个类型是给传进来的参数数据 data 的！

template<class T>
class Thread {
public:
    Thread(T data, func_t<T> func, const string& name) : _tid(0), _name(name), _isrunning(false), _func(func), _data(data) {}

    // 因为在类内的函数默认是有 this 指针的这样就会导致 pthread_create 的 threadroutine 的类型不匹配而导致的无法传参
    // 所以解决方法就是改成静态函数，但此时又不能使用成员变量了，所哟把参数 args 改成 this 传递进来！
    static void* ThreadRoutine(void* args) {
        Thread* ts = static_cast<Thread*>(args);
        ts->_func(ts->_data);
        return nullptr;
    }

    bool Start() {
        int n = pthread_create(&_tid, nullptr, ThreadRoutine, this);
        if (n == 0) {
            _isrunning = true;
            return true;
        } else
            return false;
    }

    string Threadname() { return _name; }

    bool Join() {
        if (!_isrunning) return true;
        int n = pthread_join(_tid, nullptr);
        if (n == 0) {
            _isrunning = false;
            return true;
        }
        return false;
    }

    bool Isrunning() { return _isrunning; }

    ~Thread() {}

private:
    string _name;
    func_t<T> _func;
    pthread_t _tid; // 创建自动形成
    bool _isrunning;
    T _data; // pid_t tid;
};

1.3. 附加：封装锁

• 把锁封装成一个类实现，当构造时加锁，析构时释放。
• 这样把该类写在一个代码块中当成局部变量，这样就能让其在代码块中进行加锁，出代码块析构解锁。

LockGuard.hpp：

#pragma once
#include <pthread.h>

class Mutex {
public:
    Mutex(pthread_mutex_t* lock) : _lock(lock) {}
    void Lock() { pthread_mutex_lock(_lock); }
    void Unlock() { pthread_mutex_unlock(_lock); }
    ~Mutex() {}

private:
    pthread_mutex_t* _lock; // 不定义锁，默认外面会创建传进来
};

class LockGuard {
public:
    LockGuard(pthread_mutex_t* lock) : _mutex(lock) { _mutex.Lock(); }
    ~LockGuard() { _mutex.Unlock(); }

private:
    Mutex _mutex;
};

上述代码就能实现一个基本的抢票机制，通过互斥锁就不会导致数据错乱。

但有可能一个票被一个人全部都抢了，对其他线程就形成了饥饿问题，他的原理是一个线程在申请完锁，解锁后又立马申请锁资源。

要解决饥饿问题，互斥是无法解决的，也就是同步解决：当一个线程申请完锁后不能再立马申请锁资（也就是有一定的顺序性），请看目录中的同步。

1.4 互斥锁的本质

大多数体系结构都提供了 swap/exchange 指令，该指令的作用是把寄存器和内存单元的数据相交换。

底层汇编原理：

exchange eax mem_addr（也就是把寄存器 eax 的内容和内存数据 mem_addr 交换的汇编语句），因为只有一条主要语句所以交换的过程是原子的，其他语句执行时即使被切换，也会把自身数据（%al 寄存器的数据）带走，也就不会影响其他线程。

互斥锁的实现原理：

解释：

每个线程要执行加锁时首先都会先 move 0 到 %al 寄存器中，然后在和 mutex 的数据进行交换，然后判断寄存器 %al 中的值>0 则表示加锁成功，反之则加锁失败在加锁处挂起等待！ 加锁失败的情况，因为有人已经在使用该锁，所以会把内存中的 mutex 改为了 0（他也会执行第一个 move 操作），当他没有归还锁资源时，mutex 中的值为 0，当别人一交换则 %al 寄存器中就会变成 0 就会挂起等待了。（这样也就实现了互斥锁，加锁的区域只能由一个线程使用！）

所以加锁的本质就是：

• 寄存器和内存数据的交换（因为只有一条语句所以交换的过程是原子的，xchgb %al mutex）
• 解锁的原理就是基于加锁的，把内存数据 mutex 改回 1，并唤醒等待挂起的线程即可。
• 加锁原则：谁加锁，谁解锁

1.5 认识：可重入 与 线程安全

线程安全：

1. 多个线程并发同一段代码时，不会出现不同的结果。
2. 若出现问题（如：崩溃，数据异常），则是线程不安全的。
3. 其中线程安全和可重入本质是一样的，只不过可重入是函数的概念，线程安全则是线程的概念。

线程不安全的情况：

1. 不保护共享变量的函数（全局变量）
2. 函数状态随着被调用，状态发生变化的函数（静态变量在函数中，每当被调用就会发生改变）
3. 返回指向静态变量指针的函数
4. 调用线程不安全函数的函数

线程安全的情况：

1. 每个线程对全局变量或者静态变量只有读取的权限，而没有写入的权限，一般来说这些线程是安全的（可以理解成这个变量即使线程修改了，当线程结束后该值又会变回来相当于没变）
2. 类或者接口对于线程来说都是原子操作
3. 多个线程之间的切换不会导致该接口的执行结果存在二义性

常见不可重入的情况：

1. 调用了 malloc/free 函数，因为 malloc 函数是用全局链表来管理堆的
2. 调用了标准 I/O 库函数，标准 I/O 库的很多实现都以不可重入的方式使用全局数据结构
3. 可重入函数体内使用了静态的数据结构

常见可重入的情况：

1. 不使用全局变量或静态变量
2. 不使用用 malloc 或者 new 开辟出的空间
3. 不调用不可重入函数
4. 不返回静态或全局数据，所有数据都有函数的调用者提供
5. 使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据

可重入与线程安全联系：

1. 可重入函数一定是线程安全的。
2. 函数是不可重入的，那就不能由多个线程使用，有可能引发线程安全问题。
3. 如果一个函数中有全局变量，那么这个函数既不是线程安全也不是可重入的。

可重入与线程安全区别：

1. 可重入函数是线程安全函数的一种。
2. 线程安全不一定是可重入的，而可重入函数则一定是线程安全的。
3. 如果将对临界资源的访问加上锁，则这个函数是线程安全的，但如果这个重入函数若锁还未释放则会产生死锁，因此是不可重入的。

1.6 死锁问题

原理： 死锁是指在一组进程中的各个进程均占有不会释放的资源，但因互相申请被其他进程所占用不会释放的资源而处于的一种永久等待状态。 可以理解成，现在用了两把锁 A/B 各用了一把锁，但两个线程必须同时持有两把锁才能继续往后运行（如下图）。

一个线程也可能死锁：在程序内部重复申请已经申请过的锁（此时申请不到就会被永久的挂起了）。

1.6.1 死锁产生的必要条件：

1. 互斥条件：一个资源每次只能被一个执行流使用。
2. 请求与保持条件：一个执行流因请求资源而阻塞时，对已获得的资源保持不放（相当于上面两个线程的情况）。
3. 不剥夺条件：一个执行流已获得的资源，在末使用完之前，不能强行剥夺（没有因为一个线程优先级高而强行使用所要的锁）。
4. 循环等待条件：若干执行流之间形成一种头尾相接的循环等待资源的关系（可见上图）。

1.6.2 避免死锁：

1. 不加锁（破坏互斥条件，但有些时候难以实现）。
2. 若申请某个锁不成功后，释放自身的锁已有的锁（那么就破坏了请求与保持条件）。
3. 当申请某个锁时发现他是被占用的时，直接把他解锁再加锁到当前自己线程（破坏不剥夺条件）。
4. 尽量的把锁资源按顺序申请给线程！（破坏循环等待条件）。
5. 避免锁未释放的场景以及资源一次分配（一个资源配一把锁）。

避免死锁的算法：死锁检测算法，银行家算法。

2. 线程的同步

背景： 当一个线程短时间的不断的申请锁，释放锁，导致其他人长时间得不到资源，也就对其他线程产生饥饿问题，为了解决饥饿问题，归还资源后线程不能立即再次申请，再通过类似队列的结构（先进先出，也就是有顺序性）管理要申请锁资源的线程。

对此解决这个问题的方法就是同步：

同步：在临界资源使用安全的前提下，让多线程执行具有一定的顺序性。互斥能保证资源的安全，同步能够较为充分高效的使用资源。

2.1 同步 + 互斥 -> CP 生产者消费者模型

（计算机领域非常重要的模型）

日常生活中超市就是典型的生产者消费者模型就有生产者、消费者（如下图）：

生产者、消费者的三大关系：

1. 生产者与生产者的关系：互斥（供应商相互竞争）。
2. 消费者与消费者的关系：互斥（假如只有一份商品了而都想要这个商品那么就是竞争关系）。
3. 生产者和消费者的关系：互斥（生产者放完了商品消费者才能拿商品）、同步（不能让一方持续的处理商品（不断地买/卖）都是有问题的）。

生产者消费者模型本质就是处理好上方的三个关系。

321 原则：

3. 三种关系 2. 两种角色（生产线程/消费进程）

1. 一个交易场所（内存空间）

2.2.1 生产者消费者模型的优势：

1. 让多执行流之间的一个执行解耦（把生产者和消费者两个线程，双方在内存空间内写或者拿数据，相当于把内存空间当成一个缓冲区可以存一部分数据，所以生产消费不需要相互等待）。
2. 提高处理数据的效率（通过代码解释）。

2.2 条件变量

同步的实现就是通过：条件变量（互斥中有锁一样）。

条件变量是类似于铃铛提醒人的工具，这个条件变量是为了避免消费者（线程）在资源还没准备好就不断的去内存申请但也拿不到资源的情况（本质就是同步的工具），因为共享空间是互斥的，这样就会导致生产者也无法放数据（饥饿）。

条件变量：当生产者将资源准备好去提醒消费者。

• 其中消费者并不是在锁上等待资源，而是在条件变量处的一个队列（一个阻塞队列）。
• 先在条件变量处的队列中排队，当资源就绪条件变量就会唤醒消费线程。
• 当拿取后若想再拿就必须从后开始排（队列）。

也就相当于条件变量的结构为：

struct cond {
    // 条件是否就绪
    int flag;
    // 维护一个线程队列 tcb_queue
}()

当 flag 表示就绪就从线程队列中唤醒一个线程。

2.3 条件变量的函数

1. 条件变量的定义：
   • 头文件：#include <pthread.h>
   • 成功返回 0，错误返回错误码。
   • 条件变量的使用必须要声明和摧毁。

// 对局部条件变量摧毁
int pthread_cond_destroy(pthread_cond_t *cond);
// 对局部条件变量进行初始化
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
// 全局的条件变量，和锁一样可以直接使用
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

2. 线程等待（等待响铃，或者本质就是申请资源）：
   • 头文件：#include <pthread.h>
   • 成功返回 0，错误返回错误码。

// 在指定的条件变量 cond 处等待，并且还要传递一把锁 mutex
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

3. 唤醒线程（条件变量成立并）：
   • 头文件：#include <pthread.h>
   • 成功返回 0，错误返回错误码。

// 唤醒所有线程
int pthread_cond_broadcast(pthread_cond_t *cond);
// 唤醒一个线程
int pthread_cond_signal(pthread_cond_t *cond);

2.3.1 条件变量的基本使用：

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

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* threadRoutine(void* args) {
    string name = static_cast<const char*>(args);
    while (true) {
        // sleep(1);
        pthread_mutex_lock(&mutex);
        pthread_cond_wait(&cond, &mutex); // 等待
        cout << "I am a new thread：" << name << endl;
        pthread_mutex_unlock(&mutex);
    }
}

// 主线程
int main() {
    pthread_t t1, t2, t3;
    pthread_create(&t1, nullptr, threadRoutine, (void*)"thread-1");
    pthread_create(&t2, nullptr, threadRoutine, (void*)"thread-2");
    pthread_create(&t3, nullptr, threadRoutine, (void*)"thread-3");
    sleep(5); // 5s 后让条件变量唤醒线程
    while (true) {
        pthread_cond_signal(&cond); // 唤醒一个线程
        // pthread_cond_broadcast(&cond); // 唤醒全部线程
        sleep(1);
    }
    pthread_join(t1, nullptr);
    pthread_join(t2, nullptr);
    pthread_join(t3, nullptr);
}

当只唤醒一个线程（pthread_cond_signal）时他是逐个的：

当唤醒全部线程 (pthread_cond_broadcast) 时他是所有线程一起的：

从上面的饥饿问题不能发现：单纯的互斥，能保证数据的安全，但不一定合理或高效。

pthread_cond_wait 函数的细节：

1. 当让线程在进行等待的时候，要自动释放申请的锁。
2. 线程被在临界区内唤醒的时候，要重新申请并持有锁。
3. 当多个线程被唤醒的时候，它们都要重新申请并持有锁，所以是要竞争锁的。
4. 调用该函数可能失败，这样就会让线程在不满足使用资源条件的前提下（队列中的资源不够多个线程分配）唤醒生产/消费线程，也称为：伪唤醒，也就是可能同时唤醒多个，但只有一个线程能拿到锁资源，其他没拿到锁资源的线程就是伪唤醒状态。（对此解决方法是将 if 语句换成 while 语句这样就能）

2.4 实现：阻塞队列（及条件变量的应用）

下面将使用到：

1. 互斥锁
2. 条件变量
3. 锁的封装
4. 将任务对象化
5. 阻塞队列（让线程实现顺序性）
6. 模拟生产者消费者模型的运行！

原理：

生产者将一个任务 push 到队列中，而消费者再去通过 pop 得到数据并处理。

阻塞队列：

// BlockQueue.hpp
#pragma once
#include <iostream>
#include <queue>
#include <ctime>
#include <unistd.h>
#include <pthread.h>
#include "LockGuard.hpp"
using namespace std;

const int defaultcap = 5;

template<class T>
class Blockqueue {
public:
    Blockqueue(int cap = defaultcap) : _capacity(cap) {
        pthread_mutex_init(&_mutex, nullptr);
        pthread_cond_init(&_c_cond, nullptr);
        pthread_cond_init(&_p_cond, nullptr);
    }

    bool IsFull() { return _q.size() == _capacity; }
    bool IsEmpty() { return _q.size() == 0; }

    // 生产者
    void Push(const T& in) {
        LockGuard lockgaurd(&_mutex);
        // pthread_mutex_lock(&_mutex);
        if (IsFull()) {
            // 生产线程，阻塞等待
            pthread_cond_wait(&_p_cond, &_mutex);
        }
        _q.push(in);
        pthread_cond_signal(&_c_cond); // 放到里面被唤醒了会在锁处等待了，而非 cond 处，只要释放锁后就能立刻拿到锁
        // if(_q.size() > _productor_water_line) pthread_cond_signal(&_c_cond);
        // pthread_mutex_unlock(&_mutex);
    }

    void Pop(T* out) {
        LockGuard lockgaurd(&_mutex);
        // pthread_mutex_lock(&_mutex);
        if (IsEmpty()) {
            // 阻塞等待
            pthread_cond_wait(&_c_cond, &_mutex);
        }
        *out = _q.front();
        pthread_cond_signal(&_p_cond);
        // (_q.size() > _consumer_water_line) pthread_cond_signal(&_p_cond);
        _q.pop();
        // pthread_mutex_unlock(&_mutex);
    }

    ~Blockqueue() {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_c_cond);
        pthread_cond_destroy(&_p_cond);
    }

private:
    queue<T> _q;
    size_t _capacity; // q.size == capacity 满
    pthread_mutex_t _mutex;
    pthread_cond_t _p_cond; // 给生产者的
    pthread_cond_t _c_cond; // 消费者
    // int _consumer_water_line; // capacity / 3 * 2
    // int _productor_water_line; // capacity / 3
};

封装锁：

// LockGuard.hpp
#pragma once
#include <pthread.h>

class Mutex {
public:
    Mutex(pthread_mutex_t* lock) : _lock(lock) {}
    void Lock() { pthread_mutex_lock(_lock); }
    void Unlock() { pthread_mutex_unlock(_lock); }
    ~Mutex() {}

private:
    pthread_mutex_t* _lock; // 不定义锁，默认外面会创建传进来
};

class LockGuard {
public:
    LockGuard(pthread_mutex_t* lock) : _mutex(lock) { _mutex.Lock(); }
    ~LockGuard() { _mutex.Unlock(); }

private:
    Mutex _mutex;
};

任务对象：

// Task.hpp
#pragma once
#include <iostream>
enum { ok = 0, div_zero, mod_zero, unknow };

class Task {
public:
    Task() {}
    Task(int x, int y, char op) : _x(x), _y(y), _oper(op) {}

    void Run() {
        switch (_oper) {
        case '+': result = _x + _y; break;
        case '-': result = _x - _y; break;
        case '*': result = _x * _y; break;
        case '/': {
            if (_y == 0) {
                code = div_zero; break;
            }
            result = _x / _y;
        }
        break;
        case '%': {
            if (_y == 0) {
                code = mod_zero; break;
            }
            result = _x % _y;
        }
        break;
        default: code = unknow; break;
        }
    }

    string PrintTask() {
        string s;
        s += to_string(_x);
        s += _oper;
        s += to_string(_y);
        s += "=?";
        return s;
    }

    void operator()() { Run(); }

    string PrintResult() {
        string s;
        s += to_string(_x);
        s += _oper;
        s += to_string(_y);
        s += " =";
        s += to_string(result);
        s += " [";
        s += to_string(code);
        s += "]";
        return s;
    }

    ~Task() {}

private:
    int _x;
    int _y;
    char _oper;
    int result;
    int code; // 任务退出码，0 结果可信，!0 结果不可信
};

主程序：

// main.cc
#include <iostream>
#include <queue>
#include <ctime>
#include <unistd.h>
#include <pthread.h>
#include "LockGuard.hpp"
using namespace std;

const int defaultcap = 5;

template<class T>
class Blockqueue {
public:
    Blockqueue(int cap = defaultcap) : _capacity(cap) {
        pthread_mutex_init(&_mutex, nullptr);
        pthread_cond_init(&_c_cond, nullptr);
        pthread_cond_init(&_p_cond, nullptr);
    }

    bool IsFull() { return _q.size() == _capacity; }
    bool IsEmpty() { return _q.size() == 0; }

    // 生产者
    void Push(const T& in) {
        LockGuard lockgaurd(&_mutex);
        // pthread_mutex_lock(&_mutex);
        // if(IsFull())
        while (IsFull()) // 把 if 改成 while 这样即使返回来了，也要判断数据是否能再放数据
        {
            // 生产线程，阻塞等待
            pthread_cond_wait(&_p_cond, &_mutex);
        }
        _q.push(in);
        pthread_cond_signal(&_c_cond);
        // 放到里面被唤醒了会在锁处等待了，而非 cond 处，只要释放锁后就能立刻拿到锁
        // if(_q.size() > _productor_water_line) pthread_cond_signal(&_c_cond);
        // pthread_mutex_unlock(&_mutex);
    }

    void Pop(T* out) {
        LockGuard lockgaurd(&_mutex);
        // pthread_mutex_lock(&_mutex);
        // if(IsEmpty())
        while (IsEmpty()) // 把 if 改成 while 这样即使返回来了，也要判断是否有数据能使用
        {
            // 阻塞等待
            pthread_cond_wait(&_c_cond, &_mutex);
        }
        *out = _q.front();
        pthread_cond_signal(&_p_cond);
        // (_q.size() > _consumer_water_line) pthread_cond_signal(&_p_cond);
        _q.pop();
        // pthread_mutex_unlock(&_mutex);
    }

    ~Blockqueue() {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_c_cond);
        pthread_cond_destroy(&_p_cond);
    }

private:
    queue<T> _q;
    size_t _capacity; // q.size == capacity 满
    pthread_mutex_t _mutex;
    pthread_cond_t _p_cond; // 给生产者的
    pthread_cond_t _c_cond; // 消费者
    // int _consumer_water_line; // capacity / 3 * 2
    // int _productor_water_line; // capacity / 3
};

对此为什么生产者消费者模型能提高数据处理的效率？

因为对于生产者消费者模型来说，我们不能只看内部他的生产和消费过程，这里是互斥的并没有效率的提升，但是从整体来看生产者线程获取数据的过程和消费者线程处理数据的过程也是需要时间的，他们在处理这些时间时，其他线程就能同步的去执行生产/消费过程，从而实现每个线程都能高效的执行其作用。

2.5 信号量

该方法同样也是实现同步的工具（只不过常用条件变量，所以这里就简略了）。

在之前文章中已经写过信号量的基本概念有：

1. 信号量的本质是一把计数器。
2. 申请信号的本质就是预定资源。

PV 操作是原子的！

把公共资源不当做整体，多线程不访问临界资源的同一个区域。 对此信号量为了防止分成的 n 份公共资源，分给了 n+k 个线程，信号量的作用就是：确定线程能否访问资源。 线程信号量申请成功后，当线程需要使用时就不需要再判断资源是否就绪，直接就能使用了（申请信号量时已经判断了）。

2.5.1 信号量的基本函数

1. 信号量初始化与销毁
   • 头文件：#include <semaphore.h>

// 初始化信号量
int sem_init(sem_t *sem, int pshared, unsigned int value);

• sem：返回定义的信号量（输出型）。
• pshared：在线程间共享（设置为 0），还是进程间。
• value：信号量初始的值。

// 销毁信号量
int sem_destroy(sem_t *sem);

信号量的 PV 操作

1. 申请信号量，P 操作–：

int sem_wait(sem_t *sem);

申请成功继续，失败则阻塞等待。

2. 释放信号量，V 操作++：

int sem_post(sem_t *sem);

上述函数的返回值都是：成功为 0，失败为非 0 错误码。

本章内容涵盖 Linux 下线程同步与互斥的核心机制，包括互斥锁原理、死锁避免、条件变量实现生产者 - 消费者模型及信号量基础。通过 C++ 代码示例展示了关键 API 的使用与封装技巧，帮助开发者构建安全高效的多线程程序。