操作系统总结，写的很棒！

// entry section// critical section;// exit section

typedef int semaphore;semaphore mutex = 1;void P1() {    down(&mutex);    // 临界区    up(&mutex);}
void P2() {    down(&mutex);    // 临界区    up(&mutex);}

#define N 100typedef int semaphore;semaphore mutex = 1;semaphore empty = N;semaphore full = 0;
void producer() {    while(TRUE) {        int item = produce_item();        down(&empty);        down(&mutex);        insert_item(item);        up(&mutex);        up(&full);    }}
void consumer() {    while(TRUE) {        down(&full);        down(&mutex);        int item = remove_item();        consume_item(item);        up(&mutex);        up(&empty);    }}

monitor ProducerConsumer    integer i;    condition c;
    procedure insert();    begin        // ...    end;
    procedure remove();    begin        // ...    end;end monitor;

// 管程monitor ProducerConsumer    condition full, empty;    integer count := 0;    condition c;
    procedure insert(item: integer);    begin        if count = N then wait(full);        insert_item(item);        count := count + 1;        if count = 1 then signal(empty);    end;
    function remove: integer;    begin        if count = 0 then wait(empty);        remove = remove_item;        count := count - 1;        if count = N -1 then signal(full);    end;end monitor;
// 生产者客户端procedure producerbegin    while true do    begin        item = produce_item;        ProducerConsumer.insert(item);    endend;
// 消费者客户端procedure consumerbegin    while true do    begin        item = ProducerConsumer.remove;        consume_item(item);    endend;

#define N 5
void philosopher(int i) {    while(TRUE) {        think();        take(i);       // 拿起左边的筷子        take((i+1)%N); // 拿起右边的筷子        eat();        put(i);        put((i+1)%N);    }}

#define N 5#define LEFT (i + N - 1) % N // 左邻居#define RIGHT (i + 1) % N    // 右邻居#define THINKING 0#define HUNGRY   1#define EATING   2typedef int semaphore;int state[N];                // 跟踪每个哲学家的状态semaphore mutex = 1;         // 临界区的互斥，临界区是 state 数组，对其修改需要互斥semaphore s[N];              // 每个哲学家一个信号量
void philosopher(int i) {    while(TRUE) {        think(i);        take_two(i);        eat(i);        put_two(i);    }}
void take_two(int i) {    down(&mutex);    state[i] = HUNGRY;    check(i);    up(&mutex);    down(&s[i]); // 只有收到通知之后才可以开始吃，否则会一直等下去}
void put_two(i) {    down(&mutex);    state[i] = THINKING;    check(LEFT); // 尝试通知左右邻居，自己吃完了，你们可以开始吃了    check(RIGHT);    up(&mutex);}
void eat(int i) {    down(&mutex);    state[i] = EATING;    up(&mutex);}
// 检查两个邻居是否都没有用餐，如果是的话，就 up(&s[i])，使得 down(&s[i]) 能够得到通知并继续执行void check(i) {             if(state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] !=EATING) {        state[i] = EATING;        up(&s[i]);    }}

typedef int semaphore;semaphore count_mutex = 1;semaphore data_mutex = 1;int count = 0;
void reader() {    while(TRUE) {        down(&count_mutex);        count++;        if(count == 1) down(&data_mutex); // 第一个读者需要对数据进行加锁，防止写进程访问        up(&count_mutex);        read();        down(&count_mutex);        count--;        if(count == 0) up(&data_mutex);        up(&count_mutex);    }}
void writer() {    while(TRUE) {        down(&data_mutex);        write();        up(&data_mutex);    }}

int readcount, writecount;                   //(initial value = 0)semaphore rmutex, wmutex, readLock, resource; //(initial value = 1)
//READERvoid reader() { down(&readLock);                 //  reader is trying to enter down(&rmutex);                  //   lock to increase readcount  readcount++;                   if (readcount == 1)             down(&resource);              //if you are the first reader then lock  the resource up(&rmutex);                  //release  for other readers up(&readLock);                 //Done with trying to access the resource
//reading is performed
 down(&rmutex);                  //reserve exit section - avoids race condition with readers readcount--;                       //indicate you're leaving  if (readcount == 0)          //checks if you are last reader leaving   up(&resource);              //if last, you must release the locked resource up(&rmutex);                  //release exit section for other readers}
//WRITERvoid writer() {    down(&wmutex);                  //reserve entry section for writers - avoids race conditions  writecount++;                //report yourself as a writer entering  if (writecount == 1)         //checks if you're first writer   down(&readLock);               //if you're first, then you must lock the readers out. Prevent them from trying to enter CS  up(&wmutex);                  //release entry section
 down(&resource);                //reserve the resource for yourself - prevents other writers from simultaneously editing the shared resource  //writing is performed up(&resource);                //release file
  down(&wmutex);                  //reserve exit section  writecount--;                //indicate you're leaving  if (writecount == 0)         //checks if you're the last writer   up(&readLock);               //if you're last writer, you must unlock the readers. Allows them to try enter CS for reading  up(&wmutex);                  //release exit section}

int readCount;                  // init to 0; number of readers currently accessing resource
// all semaphores initialised to 1Semaphore resourceAccess;       // controls access (read/write) to the resourceSemaphore readCountAccess;      // for syncing changes to shared variable readCountSemaphore serviceQueue;         // FAIRNESS: preserves ordering of requests (signaling must be FIFO)
void writer(){     down(&serviceQueue);           // wait in line to be servicexs    //     down(&resourceAccess);         // request exclusive access to resource    //     up(&serviceQueue);           // let next in line be serviced
    //     writeResource();            // writing is performed    // 
    //     up(&resourceAccess);         // release resource access for next reader/writer    // }
void reader(){     down(&serviceQueue);           // wait in line to be serviced    down(&readCountAccess);        // request exclusive access to readCount    //     if (readCount == 0)         // if there are no readers already reading:        down(&resourceAccess);     // request resource access for readers (writers blocked)    readCount++;                // update count of active readers    //     up(&serviceQueue);           // let next in line be serviced    up(&readCountAccess);        // release access to readCount
    //     readResource();             // reading is performed    // 
    down(&readCountAccess);        // request exclusive access to readCount    //     readCount--;                // update count of active readers    if (readCount == 0)         // if there are no readers left:        up(&resourceAccess);     // release resource access for all    //     up(&readCountAccess);        // release access to readCount}

#include int pipe(int fd[2]);

#include int mkfifo(const char *path, mode_t mode);int mkfifoat(int fd, const char *path, mode_t mode);

7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，1

4，7，0，7，1，0，1，2，1，2，6

#include 
int main(){    printf("hello, world\n");    return 0;}

gcc -o hello hello.c