从单片机到Linux下的锁机制

原创于 2025-10-22 14:00:00 发布 · 936 阅读

23 ·

CC 4.0 BY-SA版权

文章标签：

#锁机制 #互斥锁 #自旋锁 #原子锁 #中断锁

嵌入式专栏收录该内容

15 篇文章

订阅专栏

🌟 关注「嵌入式软件客栈」公众号 🌟，解锁实战技巧！💻🚀

在并发编程的开发中，锁机制是确保数据一致性和线程安全的核心技术。无论是资源受限的单片机环境，还是功能丰富的Linux系统，锁机制都扮演着至关重要的角色。

锁机制

什么是锁机制？

锁机制是一种同步原语，用于控制多个执行单元对共享资源的访问。它确保在任意时刻只有一个执行单元能够访问被保护的资源，从而避免数据竞争和不一致状态。

锁的分类

在这里插入图片描述

单片机下的锁机制

特点与约束

单片机环境具有以下特点：

资源受限：内存和CPU资源有限
实时性要求：需要保证响应时间
单核架构：通常只有一个CPU核心
中断驱动：需要处理硬件中断

常用锁机制

1. 关中断锁

最基本的锁机制，通过关闭中断来保证原子性：

// 关中断锁示例
typedef struct {
    uint32_t saved_irq_state;
} irq_lock_t;

void irq_lock_acquire(irq_lock_t *lock) {
    lock->saved_irq_state = __get_PRIMASK();
    __disable_irq();
}

void irq_lock_release(irq_lock_t *lock) {
    if (!lock->saved_irq_state) {
        __enable_irq();
    }
}

2. 原子操作锁

利用CPU的原子指令实现轻量级锁：

// 原子操作锁示例
typedef volatile uint32_t atomic_lock_t;

#define ATOMIC_LOCK_INIT 0
#define ATOMIC_LOCK_LOCKED 1

static inline int atomic_lock_try_acquire(atomic_lock_t *lock) {
    return __sync_bool_compare_and_swap(lock, ATOMIC_LOCK_INIT, ATOMIC_LOCK_LOCKED);
}

static inline void atomic_lock_release(atomic_lock_t *lock) {
    __sync_lock_test_and_set(lock, ATOMIC_LOCK_INIT);
}

3. FreeRTOS互斥锁

在RTOS环境下的标准互斥锁：

#include "FreeRTOS.h"
#include "semphr.h"

// FreeRTOS互斥锁示例
SemaphoreHandle_t xMutex;

void init_mutex(void) {
    xMutex = xSemaphoreCreateMutex();
}

void critical_section(void) {
    if (xSemaphoreTake(xMutex, pdMS_TO_TICKS(100)) == pdTRUE) {
        // 临界区代码
        xSemaphoreGive(xMutex);
    }
}

单片机锁机制流程图

Linux下的锁机制

特点与优势

Linux环境具有以下特点：

多核架构：支持真正的并行执行
丰富的系统调用：提供多种同步原语
进程隔离：需要进程间通信机制
内存管理：虚拟内存和页面管理

常用锁机制

1. POSIX线程锁

基于pthread库的互斥锁：

#include <pthread.h>

// POSIX互斥锁示例
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *thread_function(void *arg) {
    pthread_mutex_lock(&mutex);
    // 临界区代码
    pthread_mutex_unlock(&mutex);
    return NULL;
}

2. 自旋锁

适用于短时间持有的锁：

#include <pthread.h>

// 自旋锁实现
typedef struct {
    volatile int locked;
} spinlock_t;

void spin_lock(spinlock_t *lock) {
    while (__sync_lock_test_and_set(&lock->locked, 1)) {
        // 自旋等待
        __asm__ volatile("pause");
    }
}

void spin_unlock(spinlock_t *lock) {
    __sync_lock_release(&lock->locked);
}

3. 文件锁

用于进程间同步：

#include <sys/file.h>
#include <fcntl.h>

// 文件锁示例
int acquire_file_lock(const char *filename) {
    int fd = open(filename, O_RDWR | O_CREAT, 0644);
    if (fd == -1) return -1;
    
    if (flock(fd, LOCK_EX | LOCK_NB) == -1) {
        close(fd);
        return -1;
    }
    return fd;
}

void release_file_lock(int fd) {
    flock(fd, LOCK_UN);
    close(fd);
}

4. 信号量

用于资源计数和同步：

#include <semaphore.h>

// 信号量示例
sem_t semaphore;

void init_semaphore(void) {
    sem_init(&semaphore, 0, 1); // 初始值为1的二进制信号量
}

void producer(void) {
    // 生产资源
    sem_post(&semaphore); // 增加信号量
}

void consumer(void) {
    sem_wait(&semaphore); // 等待资源
    // 消费资源
}

Linux锁机制架构图

共同点与差异分析

共同点

在这里插入图片描述

差异对比

特性	单片机环境	Linux环境
资源约束	严格受限	相对宽松
并发模型	中断驱动	多线程/多进程
锁粒度	粗粒度	细粒度
实现复杂度	简单直接	复杂多样
性能开销	最小化	可接受
调试难度	困难	相对容易

实战案例分析

共享计数器保护

问题描述

多个线程/任务需要安全地访问和修改一个共享计数器。

单片机实现

// 单片机环境下的计数器保护
typedef struct {
    volatile uint32_t counter;
    irq_lock_t lock;
} safe_counter_t;

void counter_increment(safe_counter_t *counter) {
    irq_lock_acquire(&counter->lock);
    counter->counter++;
    irq_lock_release(&counter->lock);
}

uint32_t counter_get_value(safe_counter_t *counter) {
    uint32_t value;
    irq_lock_acquire(&counter->lock);
    value = counter->counter;
    irq_lock_release(&counter->lock);
    return value;
}

Linux实现

// Linux环境下的计数器保护
typedef struct {
    volatile uint32_t counter;
    pthread_mutex_t mutex;
} safe_counter_t;

void counter_init(safe_counter_t *counter) {
    counter->counter = 0;
    pthread_mutex_init(&counter->mutex, NULL);
}

void counter_increment(safe_counter_t *counter) {
    pthread_mutex_lock(&counter->mutex);
    counter->counter++;
    pthread_mutex_unlock(&counter->mutex);
}

uint32_t counter_get_value(safe_counter_t *counter) {
    uint32_t value;
    pthread_mutex_lock(&counter->mutex);
    value = counter->counter;
    pthread_mutex_unlock(&counter->mutex);
    return value;
}

生产者-消费者模式

单片机实现（FreeRTOS）

#include "FreeRTOS.h"
#include "queue.h"

#define QUEUE_SIZE 10
QueueHandle_t xQueue;

void producer_task(void *pvParameters) {
    int data = 0;
    while (1) {
        if (xQueueSend(xQueue, &data, pdMS_TO_TICKS(100)) == pdTRUE) {
            data++;
        }
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void consumer_task(void *pvParameters) {
    int received_data;
    while (1) {
        if (xQueueReceive(xQueue, &received_data, pdMS_TO_TICKS(1000)) == pdTRUE) {
            // 处理数据
            printf("Received: %d\n", received_data);
        }
    }
}

Linux实现

#include <pthread.h>
#include <semaphore.h>

#define BUFFER_SIZE 10

typedef struct {
    int buffer[BUFFER_SIZE];
    int in, out;
    sem_t empty, full;
    pthread_mutex_t mutex;
} circular_buffer_t;

void producer(circular_buffer_t *cb, int item) {
    sem_wait(&cb->empty);
    pthread_mutex_lock(&cb->mutex);
    
    cb->buffer[cb->in] = item;
    cb->in = (cb->in + 1) % BUFFER_SIZE;
    
    pthread_mutex_unlock(&cb->mutex);
    sem_post(&cb->full);
}

int consumer(circular_buffer_t *cb) {
    int item;
    
    sem_wait(&cb->full);
    pthread_mutex_lock(&cb->mutex);
    
    item = cb->buffer[cb->out];
    cb->out = (cb->out + 1) % BUFFER_SIZE;
    
    pthread_mutex_unlock(&cb->mutex);
    sem_post(&cb->empty);
    
    return item;
}

常见陷阱处理

优先级反转

解决方案：优先级继承

// 使用优先级继承的互斥锁
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
pthread_mutex_init(&mutex, &attr);

ABA问题

// ABA问题示例
typedef struct node {
    int value;
    struct node *next;
} node_t;

// 错误的CAS操作
node_t *head = NULL;

void push(int value) {
    node_t *new_node = malloc(sizeof(node_t));
    new_node->value = value;
    
    do {
        new_node->next = head;
    } while (!__sync_bool_compare_and_swap(&head, new_node->next, new_node));
}

// 解决方案：使用版本号或标记位
typedef struct node {
    int value;
    struct node *next;
    uint32_t version;  // 版本号
} node_t;

锁竞争

解决方案：锁分离

// 锁分离示例
typedef struct {
    pthread_mutex_t read_mutex;
    pthread_mutex_t write_mutex;
    int reader_count;
    pthread_mutex_t count_mutex;
} rw_lock_t;

void read_lock(rw_lock_t *rw) {
    pthread_mutex_lock(&rw->count_mutex);
    rw->reader_count++;
    if (rw->reader_count == 1) {
        pthread_mutex_lock(&rw->write_mutex);
    }
    pthread_mutex_unlock(&rw->count_mutex);
}

void write_lock(rw_lock_t *rw) {
    pthread_mutex_lock(&rw->write_mutex);
}