哲学家就餐-同步问题解析-python

五个哲学家吃五盘通心粉，由于通心粉很滑，所以必须要拿起左右两边的叉子才能吃到。

叉子的摆放如图所示。

那么问题来了：能为每一个哲学家写一段描述其行为的程序，保证不会出现死锁。

解法1:让他等待能够使用的时候，然后去叉子用餐

　　这种方法很显然行不通，如果所有人都去拿左边的叉子，就没有人能够拿到右边的叉子

解法2：在拿到左叉的时候，然后检查右边的叉子是否可用，如果可用就拿起右叉，如果不行就放下左叉。

　　这种方法也是不行的，可能在某一个瞬间，可能在某一时刻哲学家一起拿起左叉然后看到右叉不可用，就都放下左叉，周而复始，进入"饥饿状态"。

解法3:我们忽略左右叉子的问题，讲每个哲学家的状态记录下来，然后只有当自己左右都为饥饿状态的时候 才能拿到叉子吃饭，否则进入阻塞状态。

那么一开始总有两个人能拿到叉子吃饭，吃了一些，放下叉子，然后问问左右的哲学家是否想吃。

#!/usr/bin/env python

#coding:utf-8

import threading

import time

mutex = threading.RLock()

state = [0,0,0,0,0]

rlock0 = threading.RLock()

rlock1 = threading.RLock()

rlock2 = threading.RLock()

rlock3 = threading.RLock()

rlock4 = threading.RLock()

class Phd():

    def __init__ (self,key,left,right,lock):

        self.key = key

        self.left = left

        self.right = right

        self.lock = lock

z1 = Phd(0,1,4,rlock0)

z2 = Phd(1,0,2,rlock1)

z3 = Phd(2,1,3,rlock2)

z4 = Phd(3,2,4,rlock3)

z5 = Phd(4,3,0,rlock4)

obj_Phd_list = [z1,z2,z3,z4,z5]

inter = 0

def take_forks(zname):

    global inter

    while 1:

        inter += 1

        key =  zname.key

        mutex.acquire()

        state[key] = 1

        res = test(zname)

        mutex.release()

        if res == 1:

            print ("----",zname.key,"hava eating----")

            print ("----" ,zname.key,"put forks")

            put_forks(zname)

        else:

            print("----",zname.key,"no forks")

            zname.lock.acquire()

        if (inter >= 30):

            break

def test(i):

    print(i.key,"--in the test")

    if (state[i.key] == 1 & state[i.left] !=2 & state[i.right] != 2):

        state[i.key] = 2

        try:

            i.lock.release()

        except:

            pass

        return 1

    return 0

def put_forks(i):

    mutex.acquire()

    state[i.key] = 0

    test(obj_Phd_list[i.right])

    test(obj_Phd_list[i.left])

    mutex.release()

for i in range(5):

    s =  threading.Thread(target=take_forks,args=(obj_Phd_list[i],))

    s.start()