管程机制

管程（Monitor）是一种高级同步机制，将共享数据和操作封装在一起，提供互斥访问。由 Brinch Hansen 和 Hoare 提出。

为什么需要管程

• 信号量使用困难：P/V 操作分散，容易出错
• 管程将同步操作封装，降低编程复杂度

┌─────────────────────────────────────┐
│              管程 (Monitor)          │
│                                     │
│  ┌─────────────────────────────┐   │
│  │   共享数据 (Shared Data)     │   │
│  └─────────────────────────────┘   │
│                                     │
│  ┌─────────────────────────────┐   │
│  │   操作过程 (Procedures)      │   │
│  │   procedure1()              │   │
│  │   procedure2()              │   │
│  └─────────────────────────────┘   │
│                                     │
│  ┌─────────────────────────────┐   │
│  │   初始化代码 (Init Code)     │   │
│  └─────────────────────────────┘   │
│                                     │
│  入口队列: [P1] [P2] [P3] ...      │
│                                     │
│  条件变量:                          │
│    x: [等待队列]                    │
│    y: [等待队列]                    │
└─────────────────────────────────────┘

四个组成部分

1. 共享数据：管程内部的数据结构
2. 操作过程：对共享数据的操作函数
3. 初始化代码：对共享数据的初始化
4. 条件变量：用于同步的条件等待机制

1. 互斥性

• 任一时刻，最多只有一个进程在管程内执行
• 编译器自动添加互斥锁（不需要程序员手动加锁）

2. 封装性

• 共享数据只能通过管程的过程访问
• 外部无法直接访问管程内部数据

3. 条件等待

• 进程在管程内可以等待某个条件成立
• 使用条件变量（condition variable）

wait 操作

x.wait();  // 阻塞当前进程，将其放入条件x的等待队列
           // 同时释放管程的互斥锁

signal 操作

x.signal();  // 唤醒条件x等待队列中的一个进程
             // 被唤醒进程从wait处继续执行

与信号量 P/V 的区别

monitor ProducerConsumer {
    condition notFull, notEmpty;
    int buffer[N];
    int count = 0;

    procedure produce(item) {
        if (count == N)
            notFull.wait();   // 缓冲区满，等待
        buffer[count++] = item;
        notEmpty.signal();    // 通知消费者
    }

    procedure consume() returns item {
        if (count == 0)
            notEmpty.wait();  // 缓冲区空，等待
        item = buffer[--count];
        notFull.signal();     // 通知生产者
        return item;
    }
}

// 生产者进程
ProducerConsumer.produce(item);

// 消费者进程
item = ProducerConsumer.consume();

管程和信号量在表达能力上是等价的，可以互相模拟。

用信号量实现管程

• 用一个互斥信号量实现管程入口互斥
• 用信号量模拟条件变量的 wait/signal

用管程实现信号量

monitor Semaphore {
    int value;
    condition cv;

    procedure P() {
        if (value == 0) cv.wait();
        value--;
    }

    procedure V() {
        value++;
        cv.signal();
    }
}

优点

1. 封装性好，隐藏同步细节
2. 减少程序员犯错机会
3. 易于验证正确性
4. 代码更清晰可读

缺点

1. 依赖编译器支持
2. 管程内不能做阻塞 I/O
3. 不如信号量灵活

• Java synchronized：类似 Mesa 管程
• Pascal Concurrent Pascal：Brinch Hansen 实现
• Python threading.Condition：条件变量实现

Java 示例

class Monitor {
    private int sharedData;

    public synchronized void method1() {
        while (条件不满足) wait();
        // 操作共享数据
        notify();  // signal
    }
}