内核同步机制：那些你不知道的事儿？

原创于 2024-11-18 16:28:13 发布 · 1.1k 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#物联网 #linux #嵌入式硬件 #系统架构 #面试

Linux+内核同时被 2 个专栏收录

235 篇文章

订阅专栏

BSP

29 篇文章

订阅专栏

在 Linux 内核中，多线程和多核处理器环境的普及使得并发控制和数据一致性问题变得尤为重要。内核需要通过一系列同步机制，确保多个执行流在访问共享资源时能够正确且高效地运行。本篇文章将详细探讨内核中的主要同步机制，包括信号量、互斥锁和 RCU（Read-Copy-Update），从原理到使用场景，逐一剖析其作用和实现。
在这里插入图片描述

为什么需要内核同步机制

在操作系统中，内核负责管理共享资源，例如内存、文件系统、网络连接等。当多个线程或进程尝试同时访问这些资源时，可能会引发以下问题：

竞争条件（Race Condition）：多个线程对共享资源的访问顺序未加控制，导致数据异常。
死锁（Deadlock）：线程之间相互等待资源释放，导致系统无法继续运行。
数据不一致（Data Inconsistency）：线程的并发操作导致数据状态混乱。

为了解决这些问题，内核提供了一系列同步原语，帮助开发者实现线程间的协调。

在这里插入图片描述

信号量（Semaphore）

信号量的基本概念

信号量是一种计数器，用于限制对共享资源的访问。它可以分为两种类型：

二值信号量（Binary Semaphore）：计数值只能是 0 或 1，类似于互斥锁。
计数信号量（Counting Semaphore）：计数值可以大于 1，允许多个线程同时访问。

信号量的实现原理

Linux 内核中的信号量由 struct semaphore 表示，其核心字段包括：

count：信号量的计数值。
wait_list：等待信号量的线程队列。

信号量的操作主要有以下两种：

down()：尝试获取信号量。如果 count 大于 0，减 1 并继续执行；否则，阻塞线程，直到信号量可用。
up()：释放信号量，将 count 加 1。如果有线程在等待，则唤醒其中一个线程。

使用场景

信号量适用于以下场景：

资源池管理：限制对固定数量资源（例如连接池、内存块）的访问。
多生产者多消费者问题：通过信号量协调生产者和消费者之间的资源交互。

示例代码

#include <linux/semaphore.h>

struct semaphore sem;

void init(void) {
    sema_init(&sem, 1); // 初始化信号量，计数值为 1
}

void access_resource(void) {
    down(&sem); // 获取信号量
    // 临界区代码
    up(&sem);   // 释放信号量
}

互斥锁（Mutex）

互斥锁的基本概念

互斥锁是一种简单的同步机制，用于保护临界区资源，确保在任意时刻只有一个线程能够访问共享资源。

互斥锁的实现原理

Linux 内核使用 struct mutex 来表示互斥锁，其操作包括：

mutex_lock()：获取锁。如果锁已被持有，当前线程将被阻塞。
mutex_unlock()：释放锁，允许其他线程获取。
mutex_trylock()：尝试获取锁，如果锁被持有，则立即返回失败，而不会阻塞线程。

与信号量相比，互斥锁更加轻量化，专为单线程访问设计，不支持计数功能。

使用场景

互斥锁主要用于以下场景：

保护临界区：确保共享数据的原子性操作。
简单的线程同步：在不需要复杂计数逻辑时优先使用互斥锁。

示例代码

#include <linux/mutex.h>

struct mutex my_mutex;

void init(void) {
    mutex_init(&my_mutex); // 初始化互斥锁
}

void access_resource(void) {
    mutex_lock(&my_mutex); // 获取互斥锁
    // 临界区代码
    mutex_unlock(&my_mutex); // 释放互斥锁
}

RCU（Read-Copy-Update）

RCU 的基本概念

RCU 是一种高效的读写同步机制，允许读者在不阻塞的情况下访问共享数据，同时写者可以安全地更新数据。

RCU 的核心思想是：

读取阶段：读者直接访问共享数据，不需要加锁。
更新阶段：写者在更新数据时，创建新副本，并在合适的时间替换旧数据。
回收阶段：当所有读者完成对旧数据的访问后，旧数据才会被释放。

RCU 的实现原理

RCU 的关键组件包括：

rcu_read_lock() 和 rcu_read_unlock()：标记读者的临界区。
call_rcu()：注册回调函数，用于延迟回收旧数据。
synchronize_rcu()：等待所有读者完成对旧数据的访问。

使用场景

RCU 适用于以下场景：

读多写少：在读操作远多于写操作的场景下，RCU 的性能优势尤为显著。
内核子系统：RCU 广泛应用于 Linux 内核的网络栈、文件系统等模块。

示例代码

#include <linux/rcupdate.h>

struct my_data {
    int value;
};

struct my_data *rcu_pointer;

void reader(void) {
    rcu_read_lock();
    struct my_data *data = rcu_dereference(rcu_pointer);
    // 使用 data
    rcu_read_unlock();
}

void updater(void) {
    struct my_data *new_data = kmalloc(sizeof(*new_data), GFP_KERNEL);
    new_data->value = 42;
    rcu_assign_pointer(rcu_pointer, new_data);
    synchronize_rcu();
    // 释放旧数据
    kfree(old_data);
}

内核同步机制的选择

在实际应用中，根据场景选择合适的同步机制至关重要：

单线程访问：优先使用互斥锁，简单高效。
多线程访问，带计数需求：选择信号量。
读多写少场景：采用 RCU，提升性能。

以下是一个简单的对比表：

同步机制	优势	劣势	使用场景
信号量	支持多个线程访问	开销较大	资源池管理，多生产者消费者问题
互斥锁	简单高效，专注单线程访问	不适合复杂场景	保护临界区，简单同步
RCU	高效读性能，无需加锁	写操作复杂，内存占用较多	读多写少的内核子系统