经典的IPC问题

Inter-Process Communication的缩写，含义是进程间通信，是指两个进程间交换数据的过程。

哲学家进餐问题

概述

• 哲学家进餐/思考
• 进餐需要两把叉子
• 每次拿一把叉子
• 如何预防死锁

问题简介

哲学家的生活包括两个不同的阶段：吃饭和思考

当一个哲学家觉得饿时，他就试图去取他左边和右边的叉子，每次拿一把，但是部分次序，如果成功地获得了两把叉子，他就吃一会儿，然后放下叉子继续思考。

关键的问题就是：为每个哲学家写一段程序来描述其行为而且不能思索，你可以做到吗？

一种不正确的解法

#define N 5		//哲学家的数目
void philosopher(int i) {		//i是哲学家的编号，从0到4
    while (true) {
        think();				//哲学家正在思考
        take_fork(i);			//取左边的叉子
        take_fork((i + 1) % N);	//取右面叉子：%表示取模运算
        eat();					//空心粉味道不错
        put_fork(i);			//把左面叉子放回桌子
        put_fork((i + 1) % N)	//把右面叉子放回桌子
    }
}

但是当所有哲学家同时拿起左边的叉子，无法得到右边的叉子——死锁

程序稍作修改：所有的哲学家都同时拿起左叉，看到右叉不可用，又都放下左叉，等一会儿，又同时拿起左叉，如此这般，永远重复。对于这种情况，即所有的程序都在无限期地运行，但是都无法取得任何进展，就成为饥饿（starvation）。

对上例算法可做一点改进，它既不会死锁也不会饥饿：即，使用一个二进制信号量对五个think之后的语句进行保护。在开始拿叉子之前，哲学家先对信号量mutex执行down操作。在放回叉子后，他要对mutex执行up操作。

从理论上讲，该解法是可行的。但是从实力角度来看，有性能上的缺陷：任意时刻只能有一个哲学家进餐。而五把叉子实际上允许有两位哲学将同时进餐。

解法

#define N  5                        /* 哲学家数目 */
#define LEFT  (i+N-1)%N             /* i的左邻编号 */
#define RIGHT  (i+1)%N              /* i的右邻编号 */
#define THINKING  0                 /* 哲学家在思考 */
#define HUNGRY  1                   /* 哲学家试图拿起叉子 */
#define EATING  2                   /* 哲学家进餐 */
typedef int semaphore;              /* 信号量 */
int state[N];                       /* 记录每位哲学家状态 */
semaphore mutex = 1;                /* 临界区的互斥 */
semaphore s[N];                     /* 每位哲学家一个信号量 */

/* i: 哲学家编号，从0到N-1 */
void philosopher(int i) {
    while (TRUE) {                  /* 无限循环 */
        think();                    /* 哲学家思考 */
        take_forks(i);              /* 需要两个叉子， */
        eat();                      /* 哲学家进餐 */
        put_forks(i);               /* 将叉子放回到桌子上 */
    }
}

void take_forks(int i) {
    down(&mutex);                   /* 进入临界区 */
    state[i] = HUNGRY;              /* 记录哲学家i处于饥饿状态 */
    test(i);                        /* 尝试获取两把叉子 */
    up(&mutex);                     /* 退出临界区 */
    down(&s[i]);                    /* 如果得不到需要的叉子则阻塞 */
}

void put_forks(i) {
    down(&mutex);                   /* 进入临界区 */
    state[i] = THINKING;            /* 哲学家进餐完毕 */
    test(LEFT);                     /* 测试左邻是否可以吃 */
    test(RIGHT);                    /* 测试右邻是否可以吃 */
    up(&mutex);                     /* 离开临界区 */
}

void test(i) {
    //我是饥饿的但是左右都不再吃的时候
    if (state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] != EATING) {
        state[i] = EATING;
        up(&s[i]);
    }
}

上面给出的解法是没有死锁的，而且对于任意多位哲学家的情况都能获得最大的并行度。它使用一个数组state来记录哲学家是在吃饭、思考还是饿了。一个哲学家只有在两个邻座都不在进餐时，才允许转换到进餐状态。哲学家i的邻居是由宏LEFT和RIGHT定义。

该程序使用了一个信号量数组，每个信号量对应于一位哲学家，这样，所需的叉子被占用时，饥饿的哲学家就可以被阻塞。注意每个进程将历程philosopher作为朱代码运行，而其他例程，如take_forks、put_forks和test都只是普通的例程，而不是单独的进程。

读者/写者问题

另一个著名的问题是读者—写者问题，它建模了对数据库的访问。

例如，设想一个飞机定票系统，其中有许多竞争的进程试图读写其中的数据。多个进程同时读是可以接受的，但如果一个进程正在更新数据库，则所有其他进程都不能访问数据库，即使读操作也不行。这里的问题是：如何对读者和写者进行编程？

进程Ａ操作	进程B操作	是否允许
读	读	允许
读	写	互斥
写	写	互斥

typedef int semaphore;
semaphore mutex = 1;    	/* 控制对RC的访问 */
semaphore db = 1;       	/* 控制对数据库的访问 */
int rc = 0;        			/* 正在读或想要读的进程数 */

void reader(void) {
    while (TRUE) {        	/* 无限循环 */
        down(&mutex);    	/* 排斥对RC的访问*/
        rc = rc + 1;    	/* 又多了一个读者 */
        /*如果这是第一个读者，那么......*/
        if (rc == 1)
            //只要有一个读者在读书编者就不能编书
            //当前有进程在读取数据库
            down(&db);
        up(&mutex);    		/*恢复对RC的访问*/
        read_data_base(); 	/*访问数据*/
        down(&mutex);    	/*排斥对RC的访问*/
        rc = rc - 1;    	/*读者又少了一个*/
        /*如果这是最后一个读者，那么......*/
        if (rc == 0)
            up(&db);
        use_data_read();    /*非临界区操作*/
    }
}

void writer(void) {
    while (TRUE) {
        think_up_data();    /*非临界区操作*/
        down(&db);    		/*排斥访问*/
        write_data_base();  /*修改数据*/
        up(&db);        	/*恢复访问*/
    }
}

第一个读者对信号量db执行DOWN。随后的读者给计数器rc加1。当读者离开时，它们递减这个计数器，而最后一个读者则对db执行UP，这样就允许一个阻塞的写者可以访问数据库。

设想当一个读者在使用数据库时，另一个读者也来访问数据库，由于同时允许多个读者同时进行读操作，所以第二个读者也被允许进入，同理第三个及随后更多的读者都被允许进入。