读者写者问题----读者优先(python测试）

问题描述

一个数据对象若被多个并发进程所共享，且其中一些进程只要求读该数据对象的内容，而另一些
进程则要求写操作，对此，把只想读的进程称为“读者”，而把要求写的进程称为“写者”。在
读者–写着问题中，任何时刻要求“写者”最多只允许有一个，而读者则允许有多个。因为多个
读者的行为互不干扰，他们只是读数据，而不改变数据对象的内容，而写者则不同，他们要改变数据对象的内容，如果他们同时操作，则数据对象的内容将会改变的不可知。

限制条件

• 允许任意多的读进程同时读；
• 一次只允许一个写进程写操作；
• 如果有一个写进程正在进行写操作，禁止任何读进程进行读操作。

利用读者优先策略

当读者进行读时，后续的写者必须等待，直到所有的读者均离开后，写着才可进入。
为了解决“写着与写着”和“写着与第一个读者”的互斥问题即可，为此引入互斥信号量Wmutex。为了记录谁是第一个读者，可以用一个全局整型变量Rcount做一个计数器。而在解决问题的过程中，由于使用了全局变量Rcount，该变量又是一个临界资源，对于他的访问仍需互斥进行，所以需要一个互斥信号量Rmutex。

测试

import time
import threading
from threading import Semaphore
import random


Wmutex = Semaphore(1)
Rmutex = Semaphore(1)
Rcount = 0
sleept = 1

def reader(i):
    print('reader'+str(i)+' waiting to read\n', end='')
    Rmutex.acquire()
    global Rcount
    if Rcount == 0:
        Wmutex.acquire()
    Rcount += 1
    Rmutex.release()
    print('reader'+str(i)+' reading\n', end='')
    time.sleep(sleept)
    print('reader'+str(i)+' finish read\n', end='')
    Rmutex.acquire()
    Rcount -= 1
    if Rcount == 0:
        Wmutex.release()
    Rmutex.release()


def writer(i):
    print('writer'+str(i)+' waiting to write\n', end='')
    Wmutex.acquire()
    print('writer'+str(i)+' writing\n', end='')
    time.sleep(sleept)
    print('writer'+str(i)+' finish write\n', end='')
    Wmutex.release()


if __name__ == '__main__':
    times = 10
    rwlist = []
    for _ in range(times):
        rwlist.append(random.randint(0, 1))
    print(rwlist)
    rindex = 1
    windex = 1
    for i in rwlist:
        if i == 1:
            t = threading.Thread(target=reader, args=(rindex, ))
            rindex += 1
            t.start()
        else:
            t = threading.Thread(target=writer, args=(windex, ))
            windex += 1
            t.start()

输出

[1, 1, 0, 1, 1, 1, 1, 1, 1, 1]
reader1 waiting to read
reader1 reading
reader2 waiting to read
reader2 reading
writer1 waiting to write
reader3 waiting to read
reader3 reading
reader4 waiting to read
reader4 reading
reader5 waiting to read
reader5 reading
reader6 waiting to read
reader6 reading
reader7 waiting to read
reader7 reading
reader8 waiting to read
reader8 reading
reader9 waiting to read
reader9 reading
reader2 finish read
reader1 finish read
reader4 finish read
reader3 finish read
reader7 finish read
reader8 finish read
reader6 finish read
reader5 finish read
reader9 finish read
writer1 writing
writer1 finish write

Process finished with exit code 0

总结

当一个写着后面读者比较多的时候，读的操作比较频繁的时候，写者可能处于较长的
时间等待，使得写者处于‘饿死’现象中