1
// 共享变量
2
int counter = 0;
3

4
// 任务A和任务B都执行这段代码
5
void increment(void) {
6
    counter++;  // 这不是原子操作！
7
}

1
时间 | 任务A              | 任务B
2
-----|-------------------|-------------------
3
T1   | 读取 counter=0    |
4
T2   |                   | 读取 counter=0
5
T3   | 寄存器+1 (=1)     |
6
T4   |                   | 寄存器+1 (=1)
7
T5   | 写回 counter=1    |
8
T6   |                   | 写回 counter=1

1
typedef struct
2
{
3
    volatile uint32_t lock;           // 0: 未锁定, 1: 锁定
4
    volatile uint32_t interrupt_mask; // 保存中断状态（用于中断安全版本）
5
} spinlock_t;
6

7
#define LOCKED_YES 1
8
#define LOCKED_NO 0

1
/**
2
 * spinlock_lock - 纯线程间抢锁（不能在 ISR 里使用）
3
 * @splock: 锁对象
4
 *
5
 * 使用原子交换操作实现忙等待锁获取
6
 */
7
void spinlock_lock(spinlock_t *splock)
8
{
9
  /* 如果锁已被占用，会一直空转直到持有者释放 */
10
  while (atomic_exchange(&splock->lock, LOCKED_YES) != LOCKED_NO)
11
  {
12
    /* 单核空转时不需要 pause，因为不会有第二个核释放锁 */
13
  }
14
}
15

16
/**
17
 * spinlock_unlock - 释放锁（纯线程版本）
18
 * @splock: 锁对象
19
 *
20
 * 单核下可以直接赋值，因为关中断后唯一执行流就是当前代码
21
 */
22
void spinlock_unlock(spinlock_t *splock)
23
{
24
  splock->lock = LOCKED_NO;
25
}

1
/**
2
 * spinlock_lock_irqsave - 带"关中断"功能的抢锁
3
 * @splock: 锁对象
4
 *
5
 * 执行步骤：
6
 * 1. 保存当前 EFLAGS 的 IF 位
7
 * 2. 执行 cli 关闭本地中断
8
 * 3. 用原子交换抢锁
9
 * 4. 解锁时根据 interrupt_mask 决定是否重新 sti
10
 */
11
void spinlock_lock_irqsave(spinlock_t *splock)
12
{
13
  uint32_t eflags = get_eflags();               /* 读取进入前的完整标志寄存器 */
14
  disable_interrupts();                         /* cli：本地 CPU 不再响应 IRQ */
15
  splock->interrupt_mask = (eflags & (1 << 9)); /* 只保留 IF 位 */
16

17
  /* 下面与 spinlock_lock 完全相同 */
18
  while (atomic_exchange(&splock->lock, LOCKED_YES) != LOCKED_NO)
19
  {
20
  }
21
}
22

23
/**
24
 * spinlock_unlock_irqrestore - 释放锁并恢复中断状态
25
 * @splock: 锁对象
26
 *
27
 * 恢复顺序：先放锁 → 再恢复中断，防止在临界区里被中断插进来
28
 */
29
void spinlock_unlock_irqrestore(spinlock_t *splock)
30
{
31
  splock->lock = LOCKED_NO; /* 放锁 */
32
  if (splock->interrupt_mask)
33
  {                      /* 如果进锁前 IF==1，才重新开中断 */
34
    enable_interrupts(); /* sti */
35
  }
36
}

1
typedef struct mutex
2
{
3
    volatile uint32_t hold;                 // 0: 未锁定, 1: 锁定
4
    volatile struct linked_list_node *thread_node; // 持有者（未来可用于调试）
5
    linked_list_t waiting_task_queue;       // 等待队列
6
    yieldlock_t ydlock;                     // 保护内部状态的锁
7
} mutex_t;

1
/**
2
 * mutex_lock - 获取互斥锁
3
 * @mp: 互斥锁对象
4
 *
5
 * 如果锁被占用，将当前任务加入等待队列并阻塞
6
 */
7
void mutex_lock(mutex_t *mp)
8
{
9
    while (1) {
10
        yieldlock_lock(&mp->ydlock);
11

12
        if (atomic_exchange(&mp->hold, LOCKED_YES) == LOCKED_NO) {
13
            /* 成功获取锁 */
14
            yieldlock_unlock(&mp->ydlock);
15
            return;
16
        }
17

18
        /* 获取失败：将当前任务加入等待队列并阻塞 */
19
        task_t *self = current_task();
20
        linked_list_node_t *node = (linked_list_node_t *)kmalloc(sizeof(linked_list_node_t));
21
        if (node != NULL) {
22
            node->ptr = (type_t)self;
23
            node->prev = NULL;
24
            node->next = NULL;
25
            linked_list_append(&mp->waiting_task_queue, node);
26
        }
27

28
        yieldlock_unlock(&mp->ydlock);
29

30
        /* 阻塞当前任务，schedule() 会切换到其他任务 */
31
        task_block(self);
32

33
        /* 被唤醒后重新尝试获取锁 */
34
    }
35
}
36

37
/**
38
 * mutex_unlock - 释放互斥锁
39
 * @mp: 互斥锁对象
40
 *
41
 * 如果有等待者，唤醒队列中的第一个
42
 */
43
void mutex_unlock(mutex_t *mp)
44
{
45
    yieldlock_lock(&mp->ydlock);
46

47
    mp->hold = LOCKED_NO;
48
    mp->thread_node = NULL;
49

50
    /* 如果有等待者，唤醒第一个 */
51
    if (mp->waiting_task_queue.size != 0) {
52
        linked_list_node_t *head = mp->waiting_task_queue.head;
53
        task_t *waiter = (task_t *)head->ptr;
54
        linked_list_remove(&mp->waiting_task_queue, head);
55
        kfree(head);
56

57
        yieldlock_unlock(&mp->ydlock);
58

59
        task_unblock(waiter);
60
    } else {
61
        yieldlock_unlock(&mp->ydlock);
62
    }
63
}

1
typedef struct semaphore {
2
    volatile int count;            // 可用资源数量
3
    linked_list_t wait_queue;      // 等待队列
4
    spinlock_t lock;              // 保护内部状态
5
} semaphore_t;

1
/**
2
 * sem_init - 初始化信号量
3
 * @sem: 信号量对象
4
 * @initial_count: 初始资源数量
5
 */
6
void sem_init(semaphore_t *sem, int initial_count)
7
{
8
    sem->count = initial_count;
9
    linked_list_init(&sem->wait_queue);
10
    spinlock_init(&sem->lock);
11
}
12

13
/**
14
 * sem_wait - P 操作：等待/获取资源
15
 * @sem: 信号量对象
16
 *
17
 * 如果有资源可用，递减计数；否则阻塞当前任务
18
 */
19
void sem_wait(semaphore_t *sem)
20
{
21
    spinlock_acquire(&sem->lock);
22

23
    if (sem->count > 0) {
24
        /* 有资源可用，直接获取 */
25
        sem->count--;
26
        spinlock_release(&sem->lock);
27
        return;
28
    }
29

30
    /* count == 0：将当前任务加入等待队列并阻塞 */
31
    task_t *self = current_task();
32
    linked_list_node_t *node = (linked_list_node_t *)kmalloc(sizeof(linked_list_node_t));
33
    if (node != NULL) {
34
        node->ptr = (type_t)self;
35
        node->prev = NULL;
36
        node->next = NULL;
37
        linked_list_append(&sem->wait_queue, node);
38
    }
39

40
    spinlock_release(&sem->lock);
41
    task_block(self);
42
}
43

44
/**
45
 * sem_signal - V 操作：释放/增加资源
46
 * @sem: 信号量对象
47
 *
48
 * 如果有等待者，唤醒一个；否则递增计数
49
 */
50
void sem_signal(semaphore_t *sem)
51
{
52
    spinlock_acquire(&sem->lock);
53

54
    if (sem->wait_queue.size > 0) {
55
        /* 有等待者，唤醒第一个 */
56
        linked_list_node_t *head = sem->wait_queue.head;
57
        task_t *waiter = (task_t *)head->ptr;
58
        linked_list_remove(&sem->wait_queue, head);
59
        kfree(head);
60

61
        spinlock_release(&sem->lock);
62
        task_unblock(waiter);
63
    } else {
64
        /* 没有等待者，增加资源计数 */
65
        sem->count++;
66
        spinlock_release(&sem->lock);
67
    }
68
}

1
semaphore_t empty;  // 空槽位数量
2
semaphore_t full;   // 已填充槽位数量
3
mutex_t mutex;      // 保护缓冲区
4

5
// 初始化
6
sem_init(&empty, BUFFER_SIZE);  // 初始有 BUFFER_SIZE 个空槽位
7
sem_init(&full, 0);             // 初始没有已填充的槽位
8
mutex_init(&mutex);
9

10
void producer(void) {
11
    while (1) {
12
        item = produce_item();
13
        sem_wait(&empty);   // 等待空槽位
14
        mutex_lock(&mutex);
15
        buffer_put(item);
16
        mutex_unlock(&mutex);
17
        sem_post(&full);    // 增加已填充槽位
18
    }
19
}
20

21
void consumer(void) {
22
    while (1) {
23
        sem_wait(&full);    // 等待数据
24
        mutex_lock(&mutex);
25
        item = buffer_get();
26
        mutex_unlock(&mutex);
27
        sem_post(&empty);   // 增加空槽位
28
        consume_item(item);
29
    }
30
}