C语言：2.5同步与死锁
利用信号量机制解决哲学家进餐的问题c语言
利用信号量机制解决哲学家进餐的问题c语言哲学家进餐问题是经典的并发编程问题，主要是模拟多个哲学家同时在桌子上进行吃饭和思考。
由于每个哲学家都需要同时拿起左右两边的餐叉才能进餐，如果不加以控制，容易导致死锁的情况发生。
为了解决这个问题，可以利用信号量机制来确保每个哲学家同时只能拿到一把餐叉，从而避免死锁的发生。
首先，我们需要定义一些全局变量和信号量来表示哲学家和餐叉的状态。
```c#include <stdio.h>#include <stdlib.h>#include <pthread.h>#include <semaphore.h>#define N 5 // 哲学家的数量pthread_t philosophers[N]; // 哲学家的线程pthread_mutex_t forks[N]; // 餐叉的互斥锁sem_t room; // 哲学家就餐的信号量void *philosopher(void *arg) {int id = *(int *)arg;int right = id;int left = (id + 1) % N;while (1) {// 思考sleep(rand() % 3 + 1);// 请求餐叉sem_wait(&room);pthread_mutex_lock(&forks[right]);pthread_mutex_lock(&forks[left]);// 进餐sleep(rand() % 3 + 1);printf("Philosopher %d is eating\n", id + 1);// 放下餐叉pthread_mutex_unlock(&forks[left]);pthread_mutex_unlock(&forks[right]);sem_post(&room);}}int main() {int i, id[N];// 初始化互斥锁和信号量sem_init(&room, 0, N - 1); // 初始信号量为N-1，表示有N-1个座位可供就餐for (i = 0; i < N; i++) {pthread_mutex_init(&forks[i], NULL);}// 创建哲学家线程for (i = 0; i < N; i++) {id[i] = i;pthread_create(&philosophers[i], NULL, philosopher, &id[i]); }// 等待哲学家线程结束for (i = 0; i < N; i++) {pthread_join(philosophers[i], NULL);}// 销毁互斥锁和信号量for (i = 0; i < N; i++) {pthread_mutex_destroy(&forks[i]);}sem_destroy(&room);return 0;}```在主函数中，我们首先定义了哲学家和餐叉的线程以及信号量。
c语言 锁原理
c语言锁原理在计算机领域，锁是一种常用的同步机制，用于保护共享资源的访问。
在并发编程中，多个线程同时操作共享资源时，如果没有合适的同步机制，就会导致数据不一致或者资源竞争的问题。
而锁的作用就是确保在同一时刻只有一个线程能够访问共享资源，从而避免竞争条件的发生。
锁的实现原理可以分为两大类：互斥锁和读写锁。
互斥锁是一种最常见的锁机制，它保证在同一时刻只有一个线程能够执行被锁定的代码段。
互斥锁的实现依赖于操作系统提供的原子操作，一般是通过硬件层面的原子指令来实现的。
当一个线程尝试获取互斥锁时，如果锁已经被其他线程占用，那么该线程就会进入阻塞状态，直到锁被释放。
互斥锁的实现可以使用各种算法，例如Peterson算法、TAS（Test-And-Set）、TTAS（Test-And-Test-And-Set）等。
读写锁是一种更加复杂的锁机制，它允许多个线程同时读取共享资源，但是只有一个线程能够进行写操作。
读写锁的实现通常包括一个读锁和一个写锁。
当一个线程获取读锁时，如果没有线程持有写锁，则可以立即获取锁；如果有线程持有写锁，则需要等待写锁释放。
而当一个线程获取写锁时，需要等待所有的读锁和写锁都释放后才能获取锁。
读写锁的实现可以使用各种算法，例如读者优先、写者优先、公平锁等。
锁的实现原理与具体的编程语言和操作系统有关。
在C语言中，可以使用标准库中提供的互斥锁（pthread_mutex_t）和读写锁（pthread_rwlock_t）来实现锁机制。
这些锁的实现通常依赖于操作系统提供的底层原语，例如互斥锁可以使用操作系统提供的互斥量（Mutex）机制来实现。
除了互斥锁和读写锁，还有其他一些锁机制，例如自旋锁、条件变量等。
自旋锁是一种比较简单的锁机制，它不会使线程进入阻塞状态，而是通过循环不断地尝试获取锁，直到成功为止。
条件变量是一种用于线程间通信的机制，它可以使线程在某个条件满足时进入等待状态，并在条件满足时被唤醒。
进程间同步的几种方法
进程间同步的几种方法进程间同步是指两个或多个进程之间进行协调，以确保它们能够正确地执行。
这是多任务操作系统中的重要问题，因为进程之间共享资源，包括内存、文件和网络连接等。
进程同步的关键是确保一组进程在处理共享资源时，能够避免发生竞态条件（Race Condition）和死锁（Deadlock）。
竞态条件指多个进程同时访问共享资源，导致不正确的结果。
死锁指多个进程互相等待，导致它们都无法继续执行。
1. 互斥锁互斥锁是最常见的同步方法之一，它被用来保护共享资源，确保同一时刻只有一个进程可以访问它。
当一个进程获取了锁，其他进程必须等待，直到锁被释放。
在 POSIX 系统中，互斥锁可以通过 pthread_mutex_t 数据类型实现。
我们可以使用pthread_mutex_init() 函数初始化锁，使用 pthread_mutex_lock() 函数获取锁，使用pthread_mutex_unlock() 函数释放锁。
下面是一个例子，展示了如何使用互斥锁同步两个进程对共享变量的访问：```c#include <pthread.h>#include <stdio.h>int count = 0;pthread_mutex_t lock;void *increment(void *arg) {for (int i = 0; i < 1000000; i++) {pthread_mutex_lock(&lock); // 获取锁count++;pthread_mutex_unlock(&lock); // 释放锁}return NULL;}在上面的例子中，我们创建了两个线程，它们分别对共享变量 count 进行了一百万次的递增操作。
我们使用了互斥锁来保护 count 变量，确保同一时刻只有一个线程可以访问它。
2. 信号量3. 条件变量条件变量可以被用来支持更高级的同步机制，如互斥锁和信号量。
什么是死锁以及避免死锁
什么是死锁以及避免死锁⼀、定义 线程死锁是指由于两个或者多个线程互相持有对⽅所需要的资源，导致这些线程处于等待状态，⽆法前往执⾏。
当线程进⼊对象的synchronized代码块时，便占有了资源，直到它退出该代码块或者调⽤wait⽅法，才释放资源，在此期间，其他线程将不能进⼊该代码块。
当线程互相持有对⽅所需要的资源时，会互相等待对⽅释放资源，如果线程都不主动释放所占有的资源，将产⽣死锁。
当然死锁的产⽣是必须要满⾜⼀些特定条件的：1.互斥条件：进程对于所分配到的资源具有排它性，即⼀个资源只能被⼀个进程占⽤，直到被该进程释放2.请求和保持条件：⼀个进程因请求被占⽤资源⽽发⽣阻塞时，对已获得的资源保持不放。
3.不剥夺条件：任何⼀个资源在没被该进程释放之前，任何其他进程都⽆法对他剥夺占⽤4.循环等待条件：当发⽣死锁时，所等待的进程必定会形成⼀个环路（类似于死循环），造成永久阻塞。
package com.sxy.thread;/*** 线程Thread1率先占有了resource1, 继续运⾏时需要resource2, 但此时resource2却被线程Thread2占有了，* 因此只能等待Thread2释放resource2才能够继续运⾏；同时，Thread2也需要resource1,* 它只能等待Thread1释放resource1才能够继续运⾏，因此，Thread1和Thread2都处于等待状态，* 谁也⽆法继续运⾏，即产⽣了死锁。
** @author sunxy*/public class DeadLock {public static void main(String[] args) {dead_lock();}private static void dead_lock() {// 两个资源final Object resource1 = "resource1";final Object resource2 = "resource2";// 第⼀个线程，想先占有resource1,再尝试着占有resource2Thread t1 = new Thread() {public void run() {// 尝试占有resource1synchronized (resource1) {// 成功占有resource1System.out.println("Thread1 1:locked resource1");// 休眠⼀段时间try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}// 尝试占有resource2，如果不能占有，该线程会⼀直等到synchronized (resource2) {System.out.println("Thread1 1:locked resource2");}}}};// 第⼆个线程，想先占有resource2，再占有resource1Thread t2 = new Thread() {public void run() {// 尝试占有resource2synchronized (resource2) {// 成功占有resource2System.out.println("Thread 2 :locked resource2");// 休眠⼀段时间try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}// 尝试占有resource1，如果不能占有，该线程会⼀直等到synchronized (resource1) {System.out.println("Thread1 2:locked resource1");}}}};// 启动线程t1.start();t2.start();}}死锁的另⼀种：递归死锁，举例：所谓递归函数就是⾃调⽤函数，在函数体内直接或间接的调⽤⾃⼰，即函数的嵌套是函数本⾝。
c语言调试中出现的典型问题及解决方法
c语言调试中出现的典型问题及解决方法
在C语言调试过程中，常见的典型问题包括：
1. 程序运行崩溃或卡死：
- 检查内存越界访问，确保不会越界读写数组或指针；
- 验证动态内存分配的正确性；
- 检查函数调用的逻辑错误，如无限递归调用或死循环等；
- 使用断点调试，逐步跟踪程序执行过程，找到导致崩溃的
代码行。
2. 输出结果与预期不符：
- 检查变量的初始化和赋值是否正确；
- 使用printf语句输出变量的值，以便观察中间变量和计算
结果；
- 对比程序的期望输出和实际输出，找到差异。
3. 逻辑错误：
- 检查条件判断语句是否正确，确保程序根据预期逻辑执行； - 检查循环语句的终止条件，避免无限循环；
- 使用printf语句输出中间变量的值，观察程序执行过程中
的变化。
4. 内存泄漏：
- 检查动态内存的申请和释放是否配对使用；
- 使用内存检测工具，如Valgrind，检测内存泄漏和非法内
存访问；
- 注意释放动态内存的时机，在不再使用该内存时及时释放。
5. 多线程问题：
- 确保线程同步正确，避免数据竞争和死锁现象；
- 使用线程调试工具，如GDB，跟踪线程的执行和状态变化； - 检查线程之间的通信和同步机制是否正确使用。
总体而言，解决问题的方法主要包括：仔细检查代码逻辑、使用断点调试、输出中间结果、使用调试工具等。
对于复杂的问题，可以采用分而治之的思路，逐步排查问题所在。
此外，阅读官方文档和相关参考资料也是解决问题的好方法。
操作系统中的死锁问题及解决方法讨论
操作系统中的死锁问题及解决方法讨论在计算机科学中，死锁是指两个或多个进程互相等待对方释放资源，从而导致它们都无法继续执行的情况。
死锁是多道程序系统中常见的问题，如果不及时解决，会导致系统资源占用不当，影响系统的稳定性和性能。
死锁通常发生在进程之间相互竞争有限的资源时，例如内存、文件、网络连接等。
当一个进程持有一些资源并等待另一个进程持有的资源时，就可能发生死锁。
为了避免死锁问题，操作系统设计者提出了多种解决方法：1. 预防死锁：通过合理地设计系统资源分配算法，尽量避免进程发生死锁。
例如，可以使用银行家算法来保证资源请求序列是安全的，从而避免死锁的发生。
2. 避免死锁：在资源分配之前，系统可以根据当前的资源状态来判断是否分配资源会导致死锁，如果是，则不分配资源。
常用的避免死锁算法有资源分配图算法和银行家算法。
3. 检测死锁：系统可以周期性地检测系统中是否存在死锁情况，一旦检测到死锁，就采取相应的措施进行恢复。
常用的检测死锁算法有图论算法、银行家算法等。
4. 解除死锁：一旦系统检测到死锁的存在，就需要解除死锁。
解除死锁的常用方法包括资源剥夺和进程终止。
资源剥夺是指系统剥夺一些进程的资源，以解除死锁；进程终止是指系统终止一些进程，以释放资源。
死锁问题是操作系统中一个重要且常见的问题，在设计和使用操作系统时，需要重视死锁问题并采取相应的预防和解决措施。
合理地设计系统资源分配策略、优化进程调度算法、定期检测死锁情况等都可以帮助系统避免死锁，提高系统的可靠性和稳定性。
操作系统的死锁问题及解决方法一直是计算机科学领域的研究热点，希望未来能够提出更加有效的死锁预防和解决方案，为操作系统的稳定性和性能提供更好的保障。
多线程编程中的同步和并发问题解析
多线程编程中的同步和并发问题解析在多线程编程中，同步和并发是两个关键的概念，主要涉及到多个线程之间的协同工作和共享资源的管理。
了解和解决同步和并发问题是保证多线程程序正确执行的关键。
一、同步问题同步问题是指多个线程之间的协作和按照一定的顺序执行。
在多线程编程中，可能会遇到以下几种同步问题：1.竞态条件（Race Condition）：竞态条件是指多个线程竞争共享资源导致的问题。
当多个线程对同一共享资源进行读写操作时，可能会出现不可预期的结果。
例如，一个线程在读取共享资源的同时，另一个线程可能在修改这个资源，导致读取的结果不正确。
解决竞态条件的常见方法是使用互斥锁（Mutex）来保证对共享资源的排他访问，确保同一时间只有一个线程能够对共享资源进行操作。
2.死锁（Deadlock）：死锁是指多个线程互相等待对方释放资源导致的无法继续执行的情况。
当多个线程都在等待对方释放资源时，将无法继续执行下去，形成死锁。
解决死锁问题的方法可以使用资源分级策略，即按照一定的顺序请求资源，释放资源也按照相反的顺序进行。
这样能够避免多个线程同时请求相同的资源，从而降低死锁的可能性。
3.饥饿（Starvation）：饥饿是指某个线程由于资源被其他优先级高的线程占用而无法获得所需的资源，无法继续执行的情况。
解决饥饿问题的方法可以使用公平调度策略，即按照请求的先后顺序分配资源，避免某个线程长时间无法获得资源的情况。
二、并发问题并发问题是指多个线程同时执行，可能会导致不可预期的结果。
在多线程编程中，可能会遇到以下几种并发问题：1.数据竞争（Data Race）：数据竞争是指多个线程同时读写共享数据导致的问题。
当多个线程对同一数据进行读写操作时，可能会出现不一致的结果。
例如，一个线程正在写入数据，同时另一个线程正在读取这个数据，导致读取的结果不正确。
解决数据竞争问题的常见方法是使用原子操作（Atomic Operation）或者互斥锁来保证对共享数据的原子性操作，确保多个线程对数据的访问不会出现冲突。
c语言同步的实现方式
c语言同步的实现方式C语言中，同步（synchronization）是一种用来协调不同线程或进程之间执行顺序的技术。
同步的实现方式可以通过以下几种机制：1. 互斥锁（Mutex）：互斥锁是最常用的同步机制之一。
它允许线程通过获取锁将自己排他地访问共享资源，其他线程必须等待锁释放后才能访问该资源。
C语言提供了互斥锁相关的函数，如`pthread_mutex_init`、`pthread_mutex_lock`、`pthread_mutex_unlock`等。
2. 信号量（Semaphore）：信号量是一种计数器，用于控制对资源的访问。
当信号量的值大于零时，线程可以访问资源，访问后将信号量值减一；当信号量的值等于零时，线程必须等待。
C语言提供了信号量相关的函数，如`sem_init`、`sem_wait`、`sem_post`等。
3. 条件变量（Condition Variable）：条件变量用于在某些条件满足时才允许线程继续执行。
线程可以通过条件变量等待某个条件的发生，当条件满足时，其他线程可以通过条件变量通知等待的线程继续执行。
C语言提供了条件变量相关的函数，如`pthread_cond_init`、`pthread_cond_wait`、`pthread_cond_signal`等。
4. 屏障（Barrier）：屏障用于让多个线程在某个点上等待，直到所有线程都到达该点后才能继续执行。
屏障可以用于同步多个线程的执行流程，以便它们在某个共享状态达到一致后再继续执行。
C语言提供了屏障相关的函数，如`pthread_barrier_init`、`pthread_barrier_wait`等。
这些同步机制可以根据具体的应用场景选择使用。
在使用这些同步机制时，需要注意避免死锁（Deadlock）和竞态条件（Race Condition）等常见的同步问题，确保线程可以正确、安全地协作。
同时，还可以使用线程和进程间的通信机制，如管道、消息队列、共享内存等，来实现更复杂的同步和数据共享需求。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
千锋3G嵌入式移动互联网技术研发中心
信号量
• • • • • 计数信号量：1----N 二进制信号量(互斥锁)： 0，1 二进制信号量可用于解决临界区问题 计数信号量用于解决多个进程访问数量有限的资源 解决同步问题，进程1的某语句先执行，进程程2后执行
千锋3G嵌入式移动互联网技术研发中心
生产者与消费者
• • • • • 多个进程并发操作公共变量 公共变量的结果取决于执行顺序，出现竞争 并发时执行顺序不确定 解决办法：使得同时只有一个进程访问公共变量 进程同步或协调使得运行结果不会互相干扰
千锋3G嵌入式移动互联网技术研发中心
信号量
• 缺点：需要忙等，浪费CPU周期 • 优点：不需要上下文切换 • 消除忙等：
– 把等待信号量的进程转入挂起状态 – 等信号量大于零时唤醒 – 每个信号量有一个等待队列
千锋3G嵌入式移动互联网技术研发中心
监视器
• • • • • • • • • 信号量要求各个进程都符合使用规范 一个进程编程错误就会导致数据出错或死锁 一种抽象数据类型：私有数据和公共方法绑定 操作在监视器内部互斥 监视器保证进入的进程同时只能有一个处于活动状态 使用者提供条件变量用于同步 condition x x.wait 调用进程挂起 x.signal 恢复一个调用进程，若没有处于挂起的进程， 就什么效果都不发生，与信号量不同
千锋3G嵌入式移动互联网技术研发中心
临界区问题
• • • • • • • 临界区代码：修改公共变量，更新表格，写文件…... 一个进程进入临界区执行时 其它进程不能进入临界区 内核内部：打开文件列表 非抢占式内核不严重: winxp,win2000 抢占式内核问题严重:linux, solaries 解决办法应满足
千锋3G嵌入式移动互联网技术研发中心
读者写者问题
千锋3G嵌入式移动互联网技术研发中心
哲学家就餐
– P等Q离开监视器或等待另一条件变量
• signal and continue
– Q等P离开监视器或等待另一条件变量
千锋3G嵌入式移动互联网技术研发中心
监视器实现
• • • • 对每一个监视器使用一个信号量mutex,初始为1 想进入监视器进程需要先wait(mutex) 离开监视器的进程必须signal(mutex) 执行signal(mutex)的进程需要等待激 活的进程 • next(初始为0)，执行signal的进程可 以在next挂起 • next_count表示在next上挂起的进程数 • 每个外部函数里都要先等待mutex
千锋3G嵌入式移动互联网技术研发中心
读者写者问题
• • • • • • • 多个并发的进程共享一个数据库 读者：只读数据库的进程 写者：更新数据库的进程 两个或多个读者同时访问，结果正确 一个写者和另外的进程去同时访问，出现混乱 变种1：读者不会因为有写者在等待而等待别的读者 变种2：写者优先，写者需要更新数据时尽快访问
Linux进程同步
• preempt_enable • preempt_disable • 处于内核态的任务持有锁时抢占是不安全的， preempt_count用于记录持有锁的数量
千锋3G嵌入式移动互联网技术研发中心
pthread同步
千锋3G嵌入式移动互联网技术研发中心
互斥锁
• • • • • • • 用锁来保护临界区 进入临界之前先申请锁 出临界区时释放锁 构造互斥锁很复杂 单处理机通过关中断实现 非抢占式内核使用 多处理机上关中断花时间
千锋3G嵌入式移动互联网技术研发中心
pthread互斥锁
• • • • 互斥锁属性pthread_mutexattr_t int pthread_mutexattr_init(pthread_mutexattr_t *attr); int pthread_mutexattr_destroy(pthread_mutexattr_t *attr); 进程间共享属性
千锋3G嵌入式移动互联网技术研发中心
生产者与消费者
• 两个进程并发，经打断和调度后，底层的指令乱序执行
• 执行前counter 的值是5 • 执行完成后，生产者进程出错: counter ++ 得到了4 • 若T4和T5的执行顺序调换一下，消费者进程出错： counter -- 得到了6
千锋3G嵌入式移动互联网技术研发中心
死锁
• 两个或多个进程在待一个事件 • 而这个事件需要某个处于等待的进程执行signal操作
千锋3G嵌入式移动互联网技术研发中心
生产消费者问题
• int full; /* 当前缓冲区内数据个数 */ • int empty; /* 当前缓冲区内空闲的个数 */ • int mutex; /* 提供对缓冲区的互斥操作，初始化为1 */
硬件锁
• 使用交换原子操作构造锁
千锋3G嵌入式移动互联网技术研发中心
硬件锁
• 实现了有限等待的算法
千锋3G嵌入式移动互联网技术研发中心
信号量
• 锁使用复杂，多处理机上硬件实现困难 • 信号量是一个整数，有两个原子操作P和V • P(wait) V(increament)
千锋3G嵌入式移动互联网技术研发中心
监视器
千锋3G嵌入式移动互联网技术研发中心
监视器
• 为保证监视器内部同时只能一个进程处于活动状态 • 假如进程P对 x 执行 signal时， 进程Q处于挂起状态等x • signal and wait
千锋3G嵌入式移动互联网技术研发中心
Linux进程同步
• 提供了信号量和spinlock • 多处理机上是spinlock, 只能短期的持有 • 单处理机上使用信号量，通过使能内核抢占实现
千锋3G嵌入式移动互联网技术研发中心
千锋3G嵌入式移动互联网技术研发中心
生产者与消费者
• 公共变量 counter 用来记录当前缓冲区中数据个数 • 生产者填充数据后，执行 counter ++
• 消费者取出数据后，执行 counter --
千锋3G嵌入式移动互联网技术研发中心
信号量
千锋3G嵌入式移动互联网技术研发中心
信号量实现
• • • • 回归到一个临界区问题 单处理机上关中断 多处理机上忙等(spinlock) 临界区很短
– PTHREAD_PROCESS_PRIVATE – PTHREAD_PROCESS_SHARED
• int pthread_mutexattr_getpshared(const pthread_mutexattr_t * restrict attr, int *restrict pshared); • int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared);
千锋3G嵌入式移动互联网技术研发中心
欢迎您到（千锋学院）来学 习!
同步与死锁
主讲老师：欧阳坚
千锋3G嵌入式移动互联网技术研发中心
生产者与消费者
• 两个进程共享缓冲区 • 生产者进程只要发现缓冲区不满，就填充数据 • 消费者进程只要发现缓冲区内有数据，就向外取
千锋3G嵌入式移动互联网技术研发中心
pthread互斥锁
• 使用之前获得锁 int pthread_mutex_lock(pthread_mutex_t *mutex); • 不阻塞接口 int pthread_mutex_trylock(pthread_mutex_t *mutex); 正确返回0，否则返回EBUSY • 使用完释放互斥锁 int pthread_mutex_unlock(pthread_mutex_t *mutex); • 演示lockdemo
千锋3G嵌入式移动互联网技术研发中心
硬件锁
• • • • 通过原子操作TestAndSet构造锁 把lock置成true，并返回原值 返回true说明锁被人持有 返回false同时得到锁
千锋3G嵌入式移动互联网技术研发中心
• • • • • 互斥锁 条件变量 读写锁 有些实现提供了信号量 有些实现提供了spi网技术研发中心
pthread互斥锁
• pthread_mutex_t • 静态分配初始化PTHREAD_MUTEX_INITIALIZER • 动态分配初始化 int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr); • 动态销毁 int pthread_mutex_destroy(pthread_mutex_t *mutex);
千锋3G嵌入式移动互联网技术研发中心
生产者
千锋3G嵌入式移动互联网技术研发中心
消费者
– 互斥 – 前进 – 有限等待
千锋3G嵌入式移动互联网技术研发中心
软件解决办法
• i 和 j 两个进程共享变量
• turn 表示允许进程进入临界区 • flag[t] 为真表示进程 t 准备进入 • 思想：两个进程互相谦让，先 谦让的先行，后让者后走 • 只是一个算法思路，无法保证 在不同架构机器上运行
千锋3G嵌入式移动互联网技术研发中心
监视器实现
• 条件变量的实现使用信号量 • 对每个信号量x提供信号量 x_sem和整数 x_count • x.wait x.signal