操作系统问题一、模拟三个进程对底层缓冲区的读写功能实现（Python）

正好在学习操作系统，几个小问题做一下
这种底层问题用Python做得少，Python多线程又是假的多线程。但是用作学习的话，不讲究那么多了。

题目 1 ：
有三个并发进程 R ， M ， P ，它们共享了一个可循
环使用的缓冲区 B ，缓冲区 B 共有 N 个单元。进程 R 负责从
输入设备读信息，每读一个字符后，把它存放在缓冲区 B
的一个单元中；进程 M 负责处理读入的字符，若发现读入
的字符中有空格符，则把它改成“ , ”；进程 P 负责把处理
后的字符取出并打印输出。当缓冲区单元中的字符被进程
P 取出后，则又可用来存放下一次读入的字符。要求：

① 请用 PV 操作为同步机制写出它们能正确并发执行的伪代码；
② 请用你熟悉的线程库编程实现此并发程序，并输入一段包含多个空格
符的 500 字左右的文段进行测试。

答案在这=》

import threading
import time

'''
:信号量设置：
互斥信号量 mutex，互斥访问队列缓冲
整形信号量 Raw，未经过预处理的信息数量
整形信号量 Processed，经过处理后的信息数量
整形信号量 Empty，队列空闲数量（其实不用这个都，直接在队列类里面写就行）
'''
Mutex = threading.Lock()
Raw = threading.Semaphore(0)
Processed = threading.Semaphore(0)
Empty = threading.Semaphore(16)

# 基本线程类
class BasicThread(threading.Thread):
    def __init__(self, func, args):
        '''
        :param func: 调用的对象
        :param args: 调用对象的参数
        '''
        threading.Thread.__init__(self)
        self.func = func
        self.args = args
        self.result = None

    def run(self):
        self.func(*self.args)

# 缓冲队列类
class Queue_Buffer(object):
    def __init__(self, size):
        self.queue = [None] * size
        self.maxsize = size
        self.front = 0
        self.rear = 0

    # 返回当前队列的长度
    def QueueLength(self):
        return (self.rear - self.front + self.maxsize) % self.maxsize

    # 如果队列未满，则在队尾插入元素
    def EnQueue(self, data):
        if (self.rear + 1) % self.maxsize == self.front:
            print("The queue is full!")
        else:
            self.queue[self.rear] = data
            self.rear = (self.rear + 1) % self.maxsize
            self.ShowQueue()

    # 返回队首元素
    def ShowHead(self):
        if self.rear == self.front:
            return None
        else:
            data = self.queue[self.front]
            return data

    # 如果队列不为空，则删除队头的元素,时间复杂度O(1)
    def DeQueue(self):
        if self.rear == self.front:
            print("The queue is empty!")
        else:
            data = self.queue[self.front]
            self.queue[self.front] = None
            self.front = (self.front + 1) % self.maxsize
            self.ShowQueue()
            return data

    # 输出队列中的元素
    def ShowQueue(self):
        for i in range(self.maxsize):
            print(self.queue[i],end=',')
        print(' ')

def R_thread(buffer):
    File_index = 0
    while(True):
        # 每次读取一个字符，然后将文件更新
        File = open("./origin.txt","a+")
        File.seek(File_index, 0)
        File_index += 1
        String = File.read(1)
        print(String)
        if String == "":
            return 0
        File.close()
        # 放入缓冲区
        Empty.acquire()
        print("EMPTY被拿到！")
        Mutex.acquire()
        buffer.EnQueue(String)
        Mutex.release()
        Raw.release()
        print("Raw被释放！")


def M_thread(buffer):
    while (True):
        time.sleep(1)
        Raw.acquire()
        print("Raw被拿到！")
        buffer.queue = [',' if i ==' ' else i for i in buffer.queue]
        Processed.release()
        print("processed被释放！")


def P_thread(buffer):
    while (True):
        time.sleep(1)
        Processed.acquire()
        print("processed被拿到！")
        Mutex.acquire()
        if buffer.QueueLength()==0:
            return 0
        String = None
        while String==None:
            String = buffer.DeQueue()

        Mutex.release()
        File = open("./Target.txt","a+")
        Temp = File.read()
        File.seek(0,0)
        File.write(String+Temp)
        File.close()
        Empty.release()
        print("Empty被释放！")

if __name__ == "__main__":
    Buffer = Queue_Buffer(15)
    TR = BasicThread(func=R_thread, args=(Buffer,))
    TM = BasicThread(func=M_thread, args=(Buffer,))
    TP = BasicThread(func=P_thread, args=(Buffer,))
    TR.start()
    TM.start()
    TP.start()
    TR.join()
    TM.join()
    TP.join()