🏷️ 知识点：同步问题设计

// 限制哲学家能同时拿到盘子的数量
semaphore fork[n] = {1};
// 并发盘子数量 < n
semaphore plate = min(m, n-1);
philosopher(int i) {
  while (1) {
    think();
    P(plate);
    P(fork[i]);
    P(fork[(i + 1) % n]);
    eat();
    V(fork[i]);
    V(fork[(i + 1) % n]);
    V(plate);
  }
}

cobegin
{
    process 顾客 i 
    {
        从取号机获得一个号码;
        等待叫号;
        获得服务;
    }
    process 营业员
    {
        while (TRUE) {
            叫号;
            为顾客服务;
        }
    }
    }coend

semaphore empty   = 10;       // 空座位的数量
semaphore mutex   = 1;        // 互斥使用取号机
semaphore full    = 0;        // 已占座位的数量
semaphore service = 0;        // 等待叫号

process 顾客 i {
    P(empty);                 // 等空位
    P(mutex);                 // 申请使用取号机
    从取号机上取号;
    V(mutex);                 // 取号完毕
    V(fu11);                  // 通知营业员有新顾客
    P(service);               // 等待营业员叫号
    接受服务;
}

process 营业员 {
    while(True) (
        P(fu11);              // 没有顾客则休息
        叫号;
        V(empty);             // 离开座位
        V(service);           // 叫号
        为顾客服务;
    }
}

cobegin
参观者进程 i:
{
    ...
    进门；
    ...
    参观；
    ...
    出门；
    ...
}
coend

semaphore empty = 500;
semaphore mutex = 1;

visitor() {
    P(empty);
    P(mutex);
    进门;
    V(mutex);
    参观;
    P(mutex);
    出门;
    V(mutex);
    V(empty);
}

A {
    while (true) {
        从 A 的信箱中取出一个邮件；
        回答问题并提出一个新问题；
        将新邮件放入 B 的信箱；
    }
}

B {
    while (true) {
        从 B 的信箱中取出一个邮件；
        回答问题并提出一个新问题；
        将新邮件放入 A 的信箱；
    }
}

semaphore A_full = x;        // A 信箱中已有的邮件个数
semaphore A_empty = M - x;   // A 信箱还可以放多少个邮件
semaphore B_full = y;        // B 信箱中已有的邮件个数
semaphore B_empty = N - y;   // B 信箱中还能放多少个邮件
semaphore A_mutex = 1;       // 互斥访问 A 信箱
semaphore B_mutex = 1;       // 互斥访问 B 信箱

A() {
  while (1) {
    P(A_full);
    P(A_mutex);
    从A信箱中取出一个邮件;
    V(A_mutex);
    V(A_empty);
    回答问题并提出新问题;
    P(B_empty);
    P(B_mutex);
    将信件放入B邮箱;
    V(B_mutex);
    V(B_full);
  }
}

B() {
  while (1) {
    P(B_full);
    P(B_mutex);
    从B信箱中取出一个邮件;
    V(B_mutex);
    V(B_empty);
    回答问题并提出新问题;
    P(A_empty);
    P(A_mutex);
    将信件放入A邮箱;
    V(A_mutex);
    V(A_full);
  }
}

semaphore SAC = 0; // 实现 A 是 C 的前驱关系
semaphore SBC = 0; // 实现 B 是 C 的前驱关系
semaphore SCE = 0; // 实现 C 是 E 的前驱关系
semaphore SDE = 0; // 实现 D 是 E 的前驱关系

A() {
  操作A;
  V(SAC);
}

B() {
  操作B;
  V(SBC);
}

C() {
  P(SAC);
  P(SBC);
  操作C;
  V(SCE);
}

D() {
  操作D;
  V(SDE);
}

E() {
  P(SCE);
  P(SDE);
  操作E;
}

Semaphore S;

wait(S) {
    while (S <= 0);
    S = S-1;
}






signal(S) {
    S = S+1;
}

Semaphore S;


wait(S) {
    关中断；
    while(S <= 0);
    S = S-1;
    开中断；
}


signal(S) {
    关中断；
    S = S+1;
    开中断；
}

Semaphore S;

wait(S) {
    关中断；
    while(S <= 0) {
        开中断；
        关中断；
    }
    S = S-1;
    开中断；
}

signal(S) {
    关中断；
    S = S+1;
    开中断；
}

semaphore mutex = 1;  // 对铁锹的使用需要互斥
semaphore pits  = 3;  // 甲还能挖洞的数量
sempahore empty = 0;  // 可以使用的树坑数量
sempahore water = 0;  // 需要浇水的水苗数量

甲() {
    while (1) {
        wait(pits);     // 最多只能挖三个未被乙使用的坑
        wait(mutex);    // 占用铁锹
        挖树坑；
        signal(mutex);  // 释放铁锹
        signal(empty);       // 通知乙可以放树苗和填土了
    }
}

乙() {
    while (1) {
        wait(empty);     // 等待到有树坑为止
        wait(mutex);     // 占用铁锹
        放树苗、填土；
        signal(mutex);   // 释放铁锹
        signal(pits);    // 通知甲可以继续挖坑了
        signal(water);  // 通知丙可以浇水了
    }
}

丙() {
    while (1) {
        wait(water);
        浇水；
    }
}

semaphore AC = 0 ; 
semaphore CE = 0 ; 
T1 () { 
    A ; 
    signal ( AC ); 
    wait ( CE ); 
    E ; 
    F ; 
} 
T2 () { 
    B ; 
    wait ( AC ); 
    C ; 
    signal ( CE ); 
    D ; 
}

semaphore consumer_mutex = 1;
semaphore buffer_mutex = 1;
semaphore full = 0;
semaphore empty = 1000;

Consumer() {
    while (1) {
        P(consumer_mutex);
        for (int i = 0; i < 10; i++) {
            P(full);
            P(buffer_mutex);
            // 从缓冲区取出产品
            V(buffer_mutex);
            V(empty);
            // 消费产品
        }
        V(consumer_mutex);
    }
}

Producer() {
    while (1) {
        P(empty);
        // 生产产品
        P(buffer_mutex);
        // 将产品放入缓冲区
        V(buffer_mutex);
        V(full);
    }
}