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

逃离我推掉我的手 2023-06-06 10:47 16阅读 0赞

### 读者写者问题----读者优先(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

# 总结 #

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