嵌入式系统死锁防御: 从有序锁到无锁架构的工程实践

橘色的喵
0 阅读15分钟

在多任务并发系统中，不当的锁管理是导致系统死锁或永久阻塞的根本原因。本文从死锁原理出发，先介绍经典的有序锁获取与超时回退策略，再结合 newosp 工业级嵌入式框架的真实代码，深入解析无锁 MPSC 总线、Wait-Free SPSC 队列、自旋锁指数退避、Collect-Release-Execute 回调模式、LIFO 有序关停等工程实践，构建从设计层面根除死锁的完整方法论。

相关文章:

1. 死锁原理与应对策略

1.1 死锁的四个必要条件

只有当以下四个条件同时满足时，死锁才会发生:

  1. 互斥使用 (Mutual Exclusion): 资源 (如硬件外设) 一次只能被一个任务占用。
  2. 持有并等待 (Hold and Wait): 一个任务已经持有了至少一个资源，并且正在请求另一个被其他任务占用的资源。
  3. 不可抢占 (No Preemption): 资源只能由持有它的任务主动释放，不能被强制剥夺。
  4. 循环等待 (Circular Wait): 存在一个任务等待链 T1->T2->...->Tn->T1，形成闭环。

场景模拟: 死锁是如何发生的?

  • 任务A: lock(I2C) 成功 -> 尝试 lock(SPI) (等待任务B释放)
  • 任务B: lock(SPI) 成功 -> 尝试 lock(I2C) (等待任务A释放)

此时，A和B互相持有对方需要的资源，并等待对方释放，形成了循环等待，系统死锁。

1.2 核心破坏策略

策略破坏的条件适用场景
全局锁顺序循环等待多锁共存的 RTOS 系统
超时与回退持有并等待需要容错的工业控制
无锁数据结构互斥使用高吞吐量消息通信
单消费者架构循环等待消息总线、事件分发
LIFO 有序释放持有并等待系统关停、资源清理

2. 策略一: 全局锁获取顺序 (经典方案)

2.1 锁优先级设计与编号

typedef enum {
    LOCK_ID_I2C   = 10,
    LOCK_ID_SPI   = 20,
    LOCK_ID_UART  = 30,
    LOCK_ID_NVM   = 40,
    // 新增锁时继续按升序编号
} LockID_t;
  • ID 唯一且全局可见。
  • 按升序获取，打破循环等待。

2.2 带优先级 ID 的锁结构

typedef struct {
    const LockID_t id;  // 锁的全局唯一 ID
    Mutex_t        mtx; // 底层 RTOS 互斥量句柄
} OrderedLock_t;

将 ID 与互斥量句柄绑定，便于统一管理。

2.3 按序获取与逆序释放的实现

/**
 * @brief 对锁指针数组按其 ID 进行升序排序
 */
static void sort_locks_by_id(OrderedLock_t *arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            if (arr[i]->id > arr[j]->id) {
                OrderedLock_t *tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
            }
        }
    }
}

/**
 * @brief 按 ID 升序获取多个锁 (阻塞式)
 */
void lock_multiple(OrderedLock_t *locks[], int count) {
    OrderedLock_t *local_locks[count];
    memcpy(local_locks, locks, sizeof(OrderedLock_t*) * count);
    sort_locks_by_id(local_locks, count);
    for (int i = 0; i < count; i++) {
        mutex_lock(&local_locks[i]->mtx);
    }
}

/**
 * @brief 按 ID 降序释放多个锁 (LIFO 原则)
 */
void unlock_multiple(OrderedLock_t *locks[], int count) {
    OrderedLock_t *local_locks[count];
    memcpy(local_locks, locks, sizeof(OrderedLock_t*) * count);
    sort_locks_by_id(local_locks, count);
    for (int i = count - 1; i >= 0; i--) {
        mutex_unlock(&local_locks[i]->mtx);
    }
}

3. 策略二: 超时与回退

3.1 带超时的尝试锁函数

#define DEFAULT_LOCK_TIMEOUT_MS 100

bool try_lock_with_timeout(OrderedLock_t *lock, uint32_t timeout_ms) {
    if (mutex_timed_lock(&lock->mtx, timeout_ms) == true) {
        return true;
    }
    log_warning("Locking timeout for lock ID: %d", lock->id);
    return false;
}

3.2 批量获取与原子回退

在批量获取过程中，一旦有任何一个锁超时失败，必须立即释放所有已经成功获取的锁:

bool lock_multiple_with_timeout(OrderedLock_t *locks[], int count,
                                uint32_t timeout_ms) {
    OrderedLock_t *local_locks[count];
    memcpy(local_locks, locks, sizeof(OrderedLock_t*) * count);
    sort_locks_by_id(local_locks, count);

    for (int i = 0; i < count; i++) {
        if (!try_lock_with_timeout(local_locks[i], timeout_ms)) {
            // 获取失败，执行回退: 逆序释放已持有的锁
            for (int j = i - 1; j >= 0; j--) {
                mutex_unlock(&local_locks[j]->mtx);
            }
            return false;
        }
    }
    return true;
}

3.3 指数退避 + 随机抖动

void complex_task(void) {
    OrderedLock_t *req[] = { &g_spi_lock, &g_nvm_lock, &g_i2c_lock };
    int cnt = sizeof(req) / sizeof(req[0]);
    int retry_count = 0;
    const int MAX_RETRIES = 3;

    while (retry_count < MAX_RETRIES) {
        if (lock_multiple_with_timeout(req, cnt, DEFAULT_LOCK_TIMEOUT_MS)) {
            /* 临界区 */
            access_spi();
            access_nvm();
            access_i2c();

            unlock_multiple(req, cnt);
            return;
        } else {
            retry_count++;
            log_warning("Failed to lock resources, retry %d/%d...",
                        retry_count, MAX_RETRIES);

            /* 指数退避 + 随机抖动，避免活锁 */
            uint32_t backoff_delay = (1 << retry_count) * 10 + (rand() % 10);
            task_delay_ms(backoff_delay);
        }
    }

    log_error("Failed to lock resources after %d retries.", MAX_RETRIES);
    /* 降级或报警逻辑 */
}

4. 策略三: 无锁数据结构 (newosp 实践)

经典的有序锁方案虽然正确，但在高吞吐量场景下，锁本身的开销成为瓶颈。newosp 采用无锁 (Lock-Free) 和无等待 (Wait-Free) 数据结构，从架构层面消除互斥条件。

4.1 无锁 MPSC 消息总线 (CAS 原子操作)

newosp 的 AsyncBus 是系统的核心通信枢纽，采用 CAS (Compare-And-Swap) 环形缓冲区实现无锁多生产者单消费者 (MPSC) 模式:

// newosp bus.hpp -- 无锁 MPSC 发布 (简化)
template <typename PayloadVariant>
bool AsyncBus<PayloadVariant>::PublishInternal(/* ... */) noexcept {
    uint32_t prod_pos;
    Slot* target;

    do {
        prod_pos = producer_pos_.load(std::memory_order_relaxed);
        target = &ring_buffer_[prod_pos & kBufferMask];

        // 检查 slot 是否可用 (消费者已释放)
        uint32_t seq = target->sequence.load(std::memory_order_acquire);
        if (seq != prod_pos) {
            return false;  // 缓冲区满，非阻塞返回
        }
    } while (!producer_pos_.compare_exchange_weak(
        prod_pos, prod_pos + 1,
        std::memory_order_acq_rel,
        std::memory_order_relaxed));

    // CAS 成功，填充数据并发布
    target->envelope = MessageEnvelope{/* ... */};
    target->sequence.store(prod_pos + 1, std::memory_order_release);
    return true;
}

为何不会死锁:

  • 无互斥: 生产者之间通过 CAS 竞争，失败者重试而非阻塞，不满足"互斥使用"条件。
  • 单消费者: 只有一个线程调用 ProcessBatch()，消除了消费者之间的循环等待。
  • 非阻塞返回: 缓冲区满时直接返回 false，不满足"持有并等待"条件。
  • 固定容量: 编译期确定的环形缓冲区大小，避免动态分配引发的资源耗尽。

4.2 Wait-Free SPSC 队列

对于已知只有一个生产者和一个消费者的场景，newosp 使用 Wait-Free SPSC 环形缓冲区，提供最强的无死锁保证:

// newosp spsc_ringbuffer.hpp -- Wait-Free SPSC (简化)
template <typename T, size_t BufferSize = 16, bool FakeTSO = false>
class SpscRingbuffer {
    struct alignas(kCacheLineSize) PaddedIndex {
        std::atomic<IndexT> value{0};
    };

    PaddedIndex head_;  // 仅生产者写入
    PaddedIndex tail_;  // 仅消费者写入
    std::array<T, BufferSize> data_buff_{};

    bool Push(T&& data) noexcept {
        const IndexT cur_head = head_.value.load(std::memory_order_relaxed);
        const IndexT cur_tail = tail_.value.load(AcquireOrder());

        if ((cur_head - cur_tail) == BufferSize) {
            return false;  // 满
        }

        data_buff_[cur_head & kMask] = std::forward<T>(data);
        head_.value.store(cur_head + 1, ReleaseOrder());
        return true;
    }

    bool Pop(T& data) noexcept {
        const IndexT cur_tail = tail_.value.load(std::memory_order_relaxed);
        const IndexT cur_head = head_.value.load(AcquireOrder());

        if (cur_tail == cur_head) {
            return false;  // 空
        }

        data = std::move(data_buff_[cur_tail & kMask]);
        tail_.value.store(cur_tail + 1, ReleaseOrder());
        return true;
    }
};

设计要点:

特性说明
Wait-FreePush/Pop 均为有界操作，不存在无限循环
缓存行隔离head_ 和 tail_ 各占独立缓存行 (64B)，消除 False Sharing
FakeTSO 模式单核 MCU 可用 relaxed 替代 acquire/release，减少内存屏障开销
Power-of-2 掩码BufferSize 必须为 2 的幂，用位与替代取模

4.3 无锁与有锁方案对比

                有锁方案                          无锁方案
         ┌─────────────────┐             ┌──────────────────┐
  线程A  │  lock(mutex)    │      线程A  │  CAS(pos, pos+1) │
         │  临界区操作      │             │  写入数据         │
         │  unlock(mutex)  │             │  release store    │
         └────────┬────────┘             └────────┬─────────┘
                  │                               │
  线程B  ┌────────▼────────┐      线程B  ┌────────▼─────────┐
  (阻塞) │  lock(mutex)    │      (重试) │  CAS(pos, pos+1) │
         │  等待A释放...   │             │  CAS失败则重试    │
         │  [死锁风险]     │             │  [无死锁可能]     │
         └─────────────────┘             └──────────────────┘

5. 策略四: 自旋锁与指数退避 (冷路径保护)

对于无法完全避免互斥的场景 (如回调注册)，newosp 使用自旋锁配合指数退避，将临界区限制在极短的非嵌套操作中:

5.1 独占自旋锁

// newosp bus.hpp -- SpinLock with exponential backoff
class SpinLock {
    std::atomic_flag flag_ = ATOMIC_FLAG_INIT;
    static constexpr uint32_t kMaxBackoff = 1024U;

    void lock() noexcept {
        uint32_t backoff = 1;
        while (flag_.test_and_set(std::memory_order_acquire)) {
            // 指数退避: 1 -> 2 -> 4 -> ... -> 1024
            for (uint32_t i = 0; i < backoff; ++i) {
                CpuRelax();  // x86: PAUSE, ARM: YIELD
            }
            if (backoff < kMaxBackoff) {
                backoff <<= 1;
            }
        }
    }

    void unlock() noexcept {
        flag_.clear(std::memory_order_release);
    }
};

5.2 读写自旋锁

回调分发场景中，读多写少 (发布消息时读回调表，注册回调时写)，newosp 使用读写自旋锁优化:

// newosp bus.hpp -- SharedSpinLock (Reader-Writer)
class SharedSpinLock {
    std::atomic<int32_t> state_{0};  // >= 0: 读者数, -1: 写者

    void lock_shared() noexcept {     // 读锁 (多个读者并发)
        uint32_t backoff = 1;
        for (;;) {
            int32_t s = state_.load(std::memory_order_relaxed);
            if (s >= 0 &&
                state_.compare_exchange_weak(
                    s, s + 1,
                    std::memory_order_acquire,
                    std::memory_order_relaxed)) {
                return;
            }
            Backoff(backoff);
        }
    }

    void lock() noexcept {            // 写锁 (独占)
        uint32_t backoff = 1;
        for (;;) {
            int32_t expected = 0;
            if (state_.compare_exchange_weak(
                    expected, -1,
                    std::memory_order_acquire,
                    std::memory_order_relaxed)) {
                return;
            }
            Backoff(backoff);
        }
    }
};

为何不会死锁:

  • 非嵌套: 自旋锁仅保护单一短操作 (回调表读写)，不存在嵌套获取。
  • 有限等待: 指数退避确保其他线程获得 CPU 时间，最终释放锁。
  • CAS 竞争: 读写锁基于原子操作，不会出现优先级反转。

6. 策略五: 架构级死锁消除

newosp 最核心的死锁防御不在于某个具体的锁策略，而在于架构层面的单向数据流设计:

6.1 单消费者总线架构

生产者 (任意线程)                消费者 (唯一)
    │                              │
    ▼ [lock-free CAS]              │
┌───────────────────────┐          │
│  AsyncBus MPSC        │          │
│  Ring Buffer          │──────────▶ Dispatcher 线程
└───────────────────────┘          │
                                   │ [round-robin 分发]
                        ┌──────────┼──────────┐
                        ▼          ▼          ▼
                    Worker[0]  Worker[1]  Worker[2]
                       │          │          │
                       ▼          ▼          ▼
                     SPSC       SPSC       SPSC
                   RingBuffer  RingBuffer  RingBuffer
                       │          │          │
                       ▼          ▼          ▼
                    工作线程    工作线程    工作线程

关键不变量:

  1. 总线单消费者: 只有 Dispatcher 线程调用 ProcessBatch()，消除消费者间竞争。
  2. 工作队列单生产者: Round-Robin 分发确保每条消息只进入一个 SPSC 队列。
  3. 工作队列单消费者: 每个 Worker 线程独占一个 SPSC 队列。
  4. 热路径零互斥: 整条数据通路仅使用原子操作 (CAS / load / store)。

6.2 三阶段自适应退避 (WorkerPool)

Worker 线程在无消息时的等待策略直接影响系统的响应延迟和 CPU 利用率:

// newosp worker_pool.hpp -- AdaptiveBackoff
class AdaptiveBackoff {
    uint32_t spin_count_{0};
    static constexpr uint32_t kSpinLimit  = 6;   // 2^6 = 64 次 CPU Relax
    static constexpr uint32_t kYieldLimit = 4;    // 4 次 yield

    void Wait() noexcept {
        if (spin_count_ < kSpinLimit) {
            // Phase 1: 自旋 (最低延迟, 消耗 CPU)
            const uint32_t iters = 1U << spin_count_;
            for (uint32_t i = 0U; i < iters; ++i) {
                CpuRelax();
            }
            ++spin_count_;
        } else if (spin_count_ < kSpinLimit + kYieldLimit) {
            // Phase 2: 让出时间片 (中等延迟)
            std::this_thread::yield();
            ++spin_count_;
        } else {
            // Phase 3: 休眠 50us (最低 CPU 占用)
            std::this_thread::sleep_for(std::chrono::microseconds(50));
        }
    }
};
阶段操作延迟CPU 占用适用场景
Phase 1CPU Relax (PAUSE/YIELD指令)~ns 级高消息密集的热路径
Phase 2std::this_thread::yield()~us 级中短暂空闲
Phase 3sleep_for(50us)~50us低持续空闲

7. 策略六: Collect-Release-Execute 回调模式

当需要在锁保护的数据结构上触发回调时，最常见的死锁场景是: 回调函数内部又尝试获取同一把锁 (Re-entrancy)。newosp 的 Watchdog 模块通过 Collect-Release-Execute 模式彻底避免此问题:

// newosp watchdog.hpp -- Collect-Release-Execute pattern
uint32_t ThreadWatchdog::Check() noexcept {
    PendingCallback timeout_pending[MaxThreads];
    uint32_t timeout_count = 0U;

    // Phase 1: Collect -- 在锁内收集超时信息
    {
        std::lock_guard<std::mutex> lock(mutex_);
        for (uint32_t i = 0U; i < MaxThreads; ++i) {
            if (!slots_[i].active.load(std::memory_order_acquire)) {
                continue;
            }
            const uint64_t last_beat = slots_[i].heartbeat.LastBeatUs();
            if (IsTimedOut(last_beat)) {
                slots_[i].timed_out = true;
                timeout_pending[timeout_count++] = {/* 拷贝回调信息 */};
            }
        }
    }
    // Phase 2: Release -- 锁已自动释放 (RAII)

    // Phase 3: Execute -- 在锁外执行回调
    for (uint32_t i = 0U; i < timeout_count; ++i) {
        timeout_pending[i].fn(/* ... */);  // 回调可安全获取任意锁
    }

    return timeout_count;
}

模式本质: 将"数据读取"和"回调执行"解耦，回调在锁外执行，天然免疫 Re-entrancy 死锁。

同时，热路径 (工作线程喂狗) 仅执行一次原子 store，零锁开销:

// 工作线程热路径: 单原子操作，无锁
void Feed(WatchdogSlotId id) noexcept {
    slots_[id].heartbeat.Beat();  // relaxed atomic store
}

8. 策略七: LIFO 有序关停

系统关停是另一个死锁高发区。如果资源释放顺序不当，后释放的模块可能依赖已释放的模块，导致悬挂引用或死锁。newosp 的 ShutdownManager 强制 LIFO (后注册先执行) 释放顺序:

// newosp shutdown.hpp -- LIFO graceful shutdown
class ShutdownManager final {
    std::atomic<bool> shutdown_flag_{false};
    int pipe_fd_[2];                        // 异步信号安全唤醒
    ShutdownFn callbacks_[kMaxCallbacks];   // 栈分配，固定容量

    // 信号处理函数: 仅使用 async-signal-safe 操作
    static void SignalHandler(int signo) {
        self->shutdown_flag_.store(true);    // 原子写
        const uint8_t byte = 1;
        (void)::write(self->pipe_fd_[1], &byte, 1);  // pipe write
    }

    void WaitForShutdown() noexcept {
        // 阻塞等待信号
        uint8_t buf = 0;
        (void)::read(pipe_fd_[0], &buf, 1);

        // LIFO 顺序执行清理回调
        for (uint32_t i = callback_count_; i > 0U; --i) {
            if (callbacks_[i - 1U] != nullptr) {
                callbacks_[i - 1U](signo);
            }
        }
    }
};

注册顺序 A -> B -> C，执行顺序 C -> B -> A:

注册阶段:                        关停阶段:
  Register(A) -- 基础设施         Execute(C) -- 应用逻辑 (依赖 B, A)
  Register(B) -- 中间件           Execute(B) -- 中间件 (依赖 A)
  Register(C) -- 应用逻辑         Execute(A) -- 基础设施 (无依赖)

为何不会死锁:

  • Pipe 唤醒: write() 是 POSIX 异步信号安全函数，信号处理函数中无锁操作。
  • 单线程执行: 所有清理回调在主线程串行执行，不存在并发竞争。
  • 逆序释放: 符合依赖关系的自然顺序，避免"已释放资源被访问"。

9. ARM 内存序与死锁预防

在 ARM 平台上，与 x86 的 TSO (Total Store Ordering) 不同，ARM 允许写操作重排序。如果内存序不正确，可能导致生产者的数据写入对消费者不可见，造成消费者无限等待 (类似死锁的活锁):

// newosp shm_transport.hpp -- ARM memory ordering for shared memory IPC

// 生产者端: 确保 memcpy 在 sequence 发布之前完成
std::memcpy(slot.data, payload, size);
std::atomic_thread_fence(std::memory_order_release);  // DMB on ARM
slot.sequence.store(prod_pos + 1, std::memory_order_release);

// 消费者端: 确保看到生产者的所有写入
uint32_t seq = slot.sequence.load(std::memory_order_acquire);
std::atomic_thread_fence(std::memory_order_acquire);  // DMB on ARM
std::memcpy(data, slot.data, size);
内存序x86 行为ARM 行为使用场景
relaxed无额外开销无额外开销计数器、标志位 (单核/信号)
acquire无额外开销 (TSO 保证)插入 DMB 屏障消费者读取共享数据前
release无额外开销 (TSO 保证)插入 DMB 屏障生产者发布共享数据后
seq_cstMFENCE 全屏障DMB + DSB最强保证，通常应避免

在单核 MCU 上，newosp 的 SPSC 队列支持 FakeTSO 模式: 使用 relaxed + atomic_signal_fence 替代硬件屏障，因为单核不存在跨核可见性问题，仅需防止编译器重排序。

10. 实时调度与优先级反转防御

在实时系统中，优先级反转是另一种形式的"准死锁": 高优先级任务被低优先级任务间接阻塞。newosp 的 RealtimeExecutor 通过以下手段防御:

// newosp executor.hpp -- RealtimeExecutor configuration
static void ApplyRealtimeConfig(const RealtimeConfig& cfg) noexcept {
    // 1. 锁定内存: 防止页面换出导致的不确定延迟
    if (cfg.lock_memory) {
        mlockall(MCL_CURRENT | MCL_FUTURE);
    }

    // 2. CPU 亲和性: 绑定核心，减少上下文切换
    if (cfg.cpu_affinity >= 0) {
        cpu_set_t cpuset;
        CPU_ZERO(&cpuset);
        CPU_SET(cfg.cpu_affinity, &cpuset);
        pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
    }

    // 3. SCHED_FIFO: 严格优先级调度，避免优先级反转
    if (cfg.sched_policy != 0) {
        struct sched_param param;
        param.sched_priority = cfg.sched_priority;
        pthread_setschedparam(pthread_self(), cfg.sched_policy, &param);
    }
}

关键: 实时调度路径完全无锁。 Dispatcher 线程使用 SCHED_FIFO + CPU 绑定，通过 AsyncBus 的无锁 CAS 接收消息，整条路径不持有任何 mutex，从根本上免疫优先级反转。

11. 嵌入式系统集成要点与最佳实践

11.1 设计阶段

  • 锁的作用域最小化: 仅在必要时持有锁，临界区代码应尽可能简短高效。
  • 优先无锁: 对高频通信路径，优先选择 SPSC/MPSC 无锁队列，将 mutex 保留给低频冷路径。
  • 资源预算: 编译期确定队列深度、回调数量等上限，避免运行时资源耗尽。

11.2 实现阶段

  • 初始化: 在系统启动的单线程阶段，完成所有锁和队列的初始化。
  • 超时参数调优: 应根据该锁保护的临界区代码的最大正常执行时间来评估。一个好的起点是: Timeout > (最大执行时间 * 1.5) + 系统抖动。
  • 活锁规避: 采用带有随机抖动的指数退避 (Exponential Backoff with Jitter) 策略，有效错开不同任务的重试高峰。
  • 回调解耦: 凡是在锁内触发的回调，一律采用 Collect-Release-Execute 模式。

11.3 验证阶段

  • Thread Sanitizer (TSan): 检测数据竞争和锁顺序违规。
  • Address Sanitizer (ASan): 检测内存越界，间接发现因错误释放导致的锁损坏。
  • 代码审查: 将"遵守全局锁顺序"和"回调不在锁内执行"作为必检项。
  • Watchdog 联动: 超时失败是系统异常的明确信号。累计超时次数，达到阈值后主动进入安全模式或计划性复位。

12. 总结: 死锁防御技术矩阵

技术破坏的条件适用层次性能开销newosp 应用
全局锁顺序循环等待RTOS/MCU 多锁场景排序开销--
超时回退持有并等待容错要求高的工业系统超时检测--
无锁 MPSC (CAS)互斥使用高吞吐量消息通信CAS 重试AsyncBus
Wait-Free SPSC互斥使用单生产者-单消费者零额外开销SpscRingbuffer, WorkerPool
自旋锁 + 退避循环等待 (限单锁)短临界区冷路径退避等待回调注册
单消费者架构循环等待事件分发系统架构约束Bus + Executor
Collect-Release-Execute持有并等待回调通知场景临时缓冲区Watchdog
LIFO 有序关停持有并等待系统生命周期管理无额外开销ShutdownManager
ARM 内存序(防活锁)跨核/跨进程通信内存屏障ShmTransport
SCHED_FIFO + 无锁(防优先级反转)实时调度路径CPU 绑定RealtimeExecutor

核心原则: 最好的锁是不需要锁。 通过架构层面的单向数据流、生产者-消费者分离、固定容量资源预算，在设计阶段就消除死锁的结构性条件，而非在实现阶段通过锁策略去"修补"。

原文链接: CSDN 参考实现: newosp -- ARM-Linux 工业级嵌入式 C++17 基础设施库

avatar
文章
阅读
粉丝