生产者-消费者模型Python(操作系统实验)

最新推荐文章于 2023-04-17 00:50:47 发布
最新推荐文章于 2023-04-17 00:50:47 发布
阅读量1.5k 收藏 27
点赞数 2
分类专栏： 操作系统 文章标签： python 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_49005782/article/details/121623775
版权

实验五： 生产者-消费者模型

实验内容

模拟操作系统中进程同步和互斥。

实验目的

• 熟悉临界资源、信号量及PV操作的定义与物理意义

• 了解进程通信的方法

• 掌握进程互斥与进程同步的相关知识

• 掌握用信号量机制解决进程之间的同步与互斥问题

• 实现生产者－消费者问题，深刻理解进程同步问题

实验题目

在Linux操作系统下用C实现经典同步问题：生产者— 消费者，具体要求如下：

  1. 一个大小为10的缓冲区，初始状态为空。

  2. 2个生产者，随机等待一段时间，往缓冲区中添加数据，若缓冲区已满，等待消费者取走数据之后再添加，重复10次。

  3. 2个消费者，随机等待一段时间，从缓冲区中读取数据，若缓冲区为空，等待生产者添加数据之后再读取，重复10次。

  • 提示

    本实验的主要目的是模拟操作系统中进程同步和互斥。在 系统进程并发执行异步推进的过程中，由于资源共享和进程间 合作而造成进程间相互制约。进程间的相互制约有两种不同的方式。

    1. 间接制约。这是由于多个进程共享同一资源（如CPU 、共享输入/输出设备）而引起的，即共享资源的多个进程因系统协调使用资源而相互制约。
    2. 直接制约。只是由于进程合作中各个进程为完成同一 任务而造成的，即并发进程各自的执行结果互为对方的执行条 件，从而限制各个进程的执行速度。

    生产者和消费者是经典的进程同步问题，在这个问题中，生产者不断的向缓冲区中写入数据，而消费者则从缓冲区中读取数据。生产者进程和消费者对缓冲区的操作是互斥，即当前只能有一个进程对这个缓冲区进行操作，生产者进入操作缓冲区之前，先要看缓冲区是否已满，如果缓冲区已满，则它必须等待消费者进程将数据取出才能写入数据，同样的，消费者进程从缓冲区读取数据前，也要判断缓冲区是否为空，如果为空，则必须等待生产者进程写入数据才能读取数据。

    在本实验中，进程之间要进行通信来操作同一缓冲区。一般来说，进程间的通信根据通信内容可以划分为两种：即控制信息的传送与大批量数据传送。有时，也把进程间控制信息的交换称为低级通信，而把进程间大批量数据的交换称为高级通信。
    目前，计算机系统中用得比较普遍的高级通信机制可分为 3 大类：共享存储器系统、消息传递系统及管道通信系统。

  • 共享存储器系统

    共享存储器系统为了传送大量数据，在存储器中划出一块共享存储区，诸进程可通过对共享存储区进行读数据或写数据以实现通信。进程在通信之前，向系统申请共享存储区中的一个分区，并为它指定一个分区关键字。

  • 消息传递系统
    在消息传递系统中，进程间的数据交换以消息为单位，在计算机网络中被称为报文。消息传递系统的实现方式又可以分为以下两种：

    1. 直接通信方式：发送进程可将消息直接发送给接收进程，即将消息挂在接收进程的消息缓冲队列上，而接收进程可从自己的消息缓冲队列中取得消息。
    2. 间接通信方式：发送进程将消息发送到指定的信箱中，而接收进程从信箱中取得消息。这种通信方式又称信箱通信方式，被广泛地应用于计算机网络中。相应地，该消息传递系统被称为电子邮件系统。

  • 管道通信系统

    向管道提供输入的发送进程，以字符流方式将大量的数据送入管道，而接收进程从管道中接收数据。由于发送进程和接收进程是利用管道进行通信的，故称为管道通信。

    为了协调发送和接收双方的通信，管道通信机制必须提供以下3方面的协调功能。

    1. 互斥：当一个进程正在对 pipe 文件进行读或写操作时，另一个进程必须等待。
    2. 同步：当写进程把一定数量的数据写入 pipe 文件后，便阻塞等待，直到读进程取走数据后，再把写进程唤醒。
    3. 确认对方是否存在：只有确定对方已存在时，才能进行管道通信，否则会造成因对方不存在而无限制地等待。

    在这个问题当中，我们采用信号量机制进行进程之间的通信，设置两个信号量，空的信号量和满的信号量。
    在 Linux 系统中，一个或多个信号量构成一个信号量集合。使用信号量机制可以实现进程之间的同步和互斥，允许并发进程一次对一组信号量进行相同或不同的操作。每个 P、V 操作不限于减 1 或加 1，而是可以加减任何整数。在进程终止时，系统可根据需要自动消除所有被进程操作过的信号量的影响

    ① 缓冲区采用循环队列表示，利用头、尾指针来存放、读取数据，以及判断队列是否为空。缓冲区中数组大小为 10；
    ② 利用随机函数 rand()得到 A～Z 的一个随机字符，作为生产者每次生产的数据，存放到缓冲区中；
    ③ 使用 shmget()系统调用实现共享主存段的创建， shmget()返回共享内存区的 ID。对于已经申请到的共享段，进程需把它附加到自己的虚拟空间中才能对其进行读写。
    ④ 信号量的建立采用 semget()函数，同时建立信号量的数量。在信号量建立后，调用 semctl()对信号量进行初始化，例如本实验中，可以建立两个信号量 SEM_EMPTY、 SEM_FULL，初始化时设置 SEM_EMPTY 为 10， SEM_FULL 为 0。使用操作信号的函数 semop()做排除式操作，使用这个函数防止对共享内存的同时操作。对共享内存操作完毕后采用 shmctl() 函数撤销共享内存段。
    ⑤ 使用循环，创建 2 个生产者以及 2 个消费者，采用函数 fork()创建一个新的进程。
    ⑥ 一个进程的一次操作完成后，采用函数 fflush()刷新缓冲区。
    ⑦ 程序最后使用 semctl()函数释放内存。

    模拟程序的程序流程图如下所示：

    1. 主程序流程图

      在这里插入图片描述

    2. 生产者进程流程图

      在这里插入图片描述

    3. 消费者流程图

      在这里插入图片描述

    4. P操作流程图

      在这里插入图片描述

    5. V操作流程图

      在这里插入图片描述

实验总结

  • 引入需要使用的库
"""生产者-消费者模型"""
import time
import random
from multiprocessing import Process, Semaphore, Manager
import multiprocessing
import argparse
import os
import pandas as pd

其中multiprocessing是Python提供的一个进程库，能够创建新进程，argparse是命令行解析工具，作用是方便程序在命令行的调用，os是调用终端执行命令的工具包，能够做一些想清屏等操作，pandas是数据处理工具，可以将数据到处xlsx表格.

  • 使用命令行解析工具构建需要的参数
    # 创建一个命令行解析器对象
    parser = argparse.ArgumentParser(description='Producer-Consumer-Model')
    # 添加参数
    parser.add_argument('buffer_size', type=int, default=10,
                        help='The size of buffer area.')
    parser.add_argument('--exe', action='store_true',
                        help="Execute the Producer-Consumer-Model with the user's <input argument> or default <10>")
    # 参数解析到agrs中
    args = parser.parse_args()
  • 接着在主程序中定义一些变量，比如缓冲区大小，索引下标，互斥/同步信号量
        # 缓冲区大小
        buffer_size = args.buffer_size

        # 缓冲区下一个存放/取出的索引
        fin = fot = 0
        buffer = [chr(48) for _ in range(buffer_size)]

        # 互斥信号量
        mutex = Semaphore(1)

        # 同步信号量
        empty = Semaphore(buffer_size)
        full = Semaphore(0)
  • 然后将一些数据通过multiprocess.Manager()进行共享
        # 将有关buffer缓冲区的内容通过Manager的方法进行共享
        mydict = Manager().dict()
        mylist = Manager().list(buffer)
        output = Manager().list()
        mydict['buffer_size'] = buffer_size
        mydict['fin'] = fin
        mydict['fot'] = fot
  • 创建消费者和生产者进程对象
        # 创建消费者进程
        consumer1 = Process(target=consumer, args=(mydict, mylist, mutex, empty, full, output))
        consumer2 = Process(target=consumer, args=(mydict, mylist, mutex, empty, full, output))

        # 创建生产者进程
        producer1 = Process(target=producer, args=(mydict, mylist, mutex, empty, full, output))
        producer2 = Process(target=producer, args=(mydict, mylist, mutex, empty, full, output))
  • 进程开始执行，调用start()运行
        # 进程开始运行，相当于fork()
        producer1.start()
        producer2.start()
        consumer1.start()
        consumer2.start()
  • 等待进程结束，通过join()实现
        # 等待进程结束
        producer1.join()
        producer2.join()
        consumer1.join()
        consumer2.join()
  • 程序的最后是将数据进行输出到xlsx表格当中
        df = pd.DataFrame(list(output), columns=['Executing Time', 'Buffer Data', 'Process Name', 'Consume/Produce'])
        df.to_excel('./output.xlsx')
  • 以下是生产者模型的代码
def producer(mydict: dict, mylist: list, Mutex, Empty, Full, Out):
    # 生产者的生产操作的次数
    cnt = 0
    # 每个生产者生产十次产品
    while cnt < 10:
        # 首先进行同步信号的判断，看有没有空位供存放
        if Empty.get_value() <= 0:
            Nothing = None  # Do nothing
            # print(f"{time.strftime('%H:%M:%S')} seconds | Buffer full! Producer: {multiprocessing.current_process().name} is waiting...")
        Empty.acquire()
        if Mutex.get_value() <= 0:
            Nothing = None  # Do nothing
            # print(f"{time.strftime('%H:%M:%S')} seconds | A process is executing! Producer: {multiprocessing.current_process().name} is waiting...")
        Mutex.acquire()
        # 随机一个生产时间，一般长于消费时间
        time.sleep(random.randint(2, 4))
        # 随机产生一个A~Z的字符
        element = chr(random.randint(0, 25) + 65)
        # print(f"{time.strftime('%H:%M:%S')} seconds | Producer: {multiprocessing.current_process().name} has produced a product ({element}) that put in the {mydict['fin']}th position of the buffer.")

        # 更新mylist, cnt, fin等等
        mylist[mydict['fin']] = element

        # print('Executing Time\t\tBuffer Data\t\t\t\t\t\t\tProcess Name\t\tConsume/Produce')
        print(f"{time.strftime('%H:%M:%S')}\t\t{mylist}\t\t{multiprocessing.current_process().name}-P\t\t{element}")
        Out.append([time.strftime('%H:%M:%S'), list(mylist), multiprocessing.current_process().name + '-P', element])

        cnt += 1
        mydict['fin'] = (mydict['fin'] + 1) % mydict['buffer_size']
        # 最后做V操作，没有顺序
        Mutex.release()
        Full.release()
        
        # 在下次操作前，随机等待一段时间
        time.sleep(random.randint(1, 4))

外循环是while cnt < 10:是因为每个进程需要进行十次操作，然后是对同步信号和互斥信号的P操作，需要注意的是首先需要对同步信号量进行P操作然后再是互斥信号量，在执行完P操作之后，就是进行生产这行为，包括一系列的更新工作等，最后在执行完生产操作之后就相对应的执行V操作.

  • 消费者模型的代码
def consumer(mydict: dict, mylist: list, Mutex, Empty, Full, Out):
    # cnt统计消费者的消费次数
    cnt = 0
    # 每个消费者，进行十次的消费行为
    while cnt < 10:
        # 这个变量的意义是为了防止while打印非常多次的提示语句，一次就行了
        if Full.get_value() <= 0:
            Nothing = None  # Do nothing
            # 如果是因为同步信号量，输出：{} seconds | Buffer empty! Consumer: {} is waiting...
            # print(f"{time.strftime('%H:%M:%S')} seconds | Buffer empty! Consumer: {multiprocessing.current_process().name} is waiting...")
        Full.acquire()
        if Mutex.get_value() <= 0:
            Nothing = None  # Do nothing
            # 如果是因为互斥信号量，输出：{} seconds | A process is executing! Consumer: {} is waiting...
            # print(f"{time.strftime('%H:%M:%S')} seconds | A process is executing! Consumer: {multiprocessing.current_process().name} is waiting...")
        Mutex.acquire()
        # 随机一个消费操作的耗时
        time.sleep(random.randint(1, 2))
        # print(f"{time.strftime('%H:%M:%S')} seconds | Consumer: {multiprocessing.current_process().name} has consumed a product ({mylist[mydict['fot']]}) that located in the {mydict['fot']}th position of the buffer.")

        # print('Executing Time\t\tBuffer Data\t\t\t\t\t\t\tProcess Name\t\tConsume/Produce')
        print(
            f"{time.strftime('%H:%M:%S')}\t\t{mylist}\t\t{multiprocessing.current_process().name}-C\t\t{mylist[mydict['fot']]}")
        Out.append([time.strftime('%H:%M:%S'), list(mylist), multiprocessing.current_process().name + '-C', mylist[mydict['fot']]])
        # 对消费后的内容重置，同时cnt自增一表示消费者执行一次消费操作，另外更新fot即out的位置
        mylist[mydict['fot']] = chr(48)

        cnt += 1
        mydict['fot'] = (mydict['fot'] + 1) % mydict['buffer_size']
        # 最后一步做V操作，没有顺序
        Mutex.release()
        Empty.release()
      
        # 在下次操作前，随机等待一段时间
        time.sleep(random.randint(1, 4))

外循环是while cnt < 10:也是因为每个进程需要进行十次操作，然后是对同步信号和互斥信号的P操作，、在执行完P操作之后，就是进行消费的行为，包括一系列的更新工作等，最后在执行完生产操作之后就相对应的执行V操作，流程和生产者一致.

下面是整体的程序代码：

"""生产者-消费者模型"""
import time
import random
from multiprocessing import Process, Semaphore, Manager
import multiprocessing
import argparse
import os
import pandas as pd

"""消费者模型"""


def consumer(mydict: dict, mylist: list, Mutex, Empty, Full, Out):
    # cnt统计消费者的消费次数
    cnt = 0
    # 每个消费者，进行十次的消费行为
    while cnt < 10:
        # 这个变量的意义是为了防止while打印非常多次的提示语句，一次就行了
        if Full.get_value() <= 0:
            Nothing = None  # Do nothing
            # 如果是因为同步信号量，输出：{} seconds | Buffer empty! Consumer: {} is waiting...
            # print(f"{time.strftime('%H:%M:%S')} seconds | Buffer empty! Consumer: {multiprocessing.current_process().name} is waiting...")
        Full.acquire()
        if Mutex.get_value() <= 0:
            Nothing = None  # Do nothing
            # 如果是因为互斥信号量，输出：{} seconds | A process is executing! Consumer: {} is waiting...
            # print(f"{time.strftime('%H:%M:%S')} seconds | A process is executing! Consumer: {multiprocessing.current_process().name} is waiting...")
        Mutex.acquire()
        # 随机一个消费操作的耗时
        time.sleep(random.randint(1, 2))
        # print(f"{time.strftime('%H:%M:%S')} seconds | Consumer: {multiprocessing.current_process().name} has consumed a product ({mylist[mydict['fot']]}) that located in the {mydict['fot']}th position of the buffer.")

        # print('Executing Time\t\tBuffer Data\t\t\t\t\t\t\tProcess Name\t\tConsume/Produce')
        print(
            f"{time.strftime('%H:%M:%S')}\t\t{mylist}\t\t{multiprocessing.current_process().name}-C\t\t{mylist[mydict['fot']]}")
        Out.append([time.strftime('%H:%M:%S'), list(mylist), multiprocessing.current_process().name + '-C', mylist[mydict['fot']]])
        # 对消费后的内容重置，同时cnt自增一表示消费者执行一次消费操作，另外更新fot即out的位置
        mylist[mydict['fot']] = chr(48)

        cnt += 1
        mydict['fot'] = (mydict['fot'] + 1) % mydict['buffer_size']
        # 最后一步做V操作，没有顺序
        Mutex.release()
        Empty.release()
        
        # 在下次操作前，随机等待一段时间
        time.sleep(random.randint(1, 4))


"""生产者模型"""


def producer(mydict: dict, mylist: list, Mutex, Empty, Full, Out):
    # 生产者的生产操作的次数
    cnt = 0
    # 每个生产者生产十次产品
    while cnt < 10:
        # 首先进行同步信号的判断，看有没有空位供存放
        if Empty.get_value() <= 0:
            Nothing = None  # Do nothing
            # print(f"{time.strftime('%H:%M:%S')} seconds | Buffer full! Producer: {multiprocessing.current_process().name} is waiting...")
        Empty.acquire()
        if Mutex.get_value() <= 0:
            Nothing = None  # Do nothing
            # print(f"{time.strftime('%H:%M:%S')} seconds | A process is executing! Producer: {multiprocessing.current_process().name} is waiting...")
        Mutex.acquire()
        # 随机一个生产时间，一般长于消费时间
        time.sleep(random.randint(2, 4))
        # 随机产生一个A~Z的字符
        element = chr(random.randint(0, 25) + 65)
        # print(f"{time.strftime('%H:%M:%S')} seconds | Producer: {multiprocessing.current_process().name} has produced a product ({element}) that put in the {mydict['fin']}th position of the buffer.")

        # 更新mylist, cnt, fin等等
        mylist[mydict['fin']] = element

        # print('Executing Time\t\tBuffer Data\t\t\t\t\t\t\tProcess Name\t\tConsume/Produce')
        print(f"{time.strftime('%H:%M:%S')}\t\t{mylist}\t\t{multiprocessing.current_process().name}-P\t\t{element}")
        Out.append([time.strftime('%H:%M:%S'), list(mylist), multiprocessing.current_process().name + '-P', element])

        cnt += 1
        mydict['fin'] = (mydict['fin'] + 1) % mydict['buffer_size']
        # 最后做V操作，没有顺序
        Mutex.release()
        Full.release()
        
        # 在下次操作前，随机等待一段时间
        time.sleep(random.randint(1, 4))


if __name__ == '__main__':
    # 创建一个命令行解析器对象
    parser = argparse.ArgumentParser(description='Producer-Consumer-Model')
    # 添加参数
    parser.add_argument('buffer_size', type=int, default=10,
                        help='The size of buffer area.')
    parser.add_argument('--exe', action='store_true',
                        help="Execute the Producer-Consumer-Model with the user's <input argument> or default <10>")
    # 参数解析到agrs中
    args = parser.parse_args()
    if args.exe:
        os.system('cls')
        print(f'\n{args}\n')
        # 打印以下详细信息，这个consumer_producerModel.py是该程序的文件名，可自行修改
        os.system('python consumer_producerModel.py -h')
        print()
        # 缓冲区大小
        buffer_size = args.buffer_size

        # 缓冲区下一个存放/取出的索引
        fin = fot = 0
        buffer = [chr(48) for _ in range(buffer_size)]

        # 互斥信号量
        mutex = Semaphore(1)

        # 同步信号量
        empty = Semaphore(buffer_size)
        full = Semaphore(0)

        # 将有关buffer缓冲区的内容通过Manager的方法进行共享
        mydict = Manager().dict()
        mylist = Manager().list(buffer)
        output = Manager().list()
        mydict['buffer_size'] = buffer_size
        mydict['fin'] = fin
        mydict['fot'] = fot

        # 创建消费者进程
        consumer1 = Process(target=consumer, args=(mydict, mylist, mutex, empty, full, output))
        consumer2 = Process(target=consumer, args=(mydict, mylist, mutex, empty, full, output))

        # 创建生产者进程
        producer1 = Process(target=producer, args=(mydict, mylist, mutex, empty, full, output))
        producer2 = Process(target=producer, args=(mydict, mylist, mutex, empty, full, output))

        print('Executing Time\t\tBuffer Data\t\t\t\t\t\t\tProcess Name\t\tConsume/Produce')
        # 进程开始运行，相当于fork()
        producer1.start()
        producer2.start()
        consumer1.start()
        consumer2.start()

        # 等待进程结束
        producer1.join()
        producer2.join()
        consumer1.join()
        consumer2.join()

        df = pd.DataFrame(list(output), columns=['Executing Time', 'Buffer Data', 'Process Name', 'Consume/Produce'])
        df.to_excel('./output.xlsx')

以下是运行结果截图(含表格的截图)：

在这里插入图片描述

在这里插入图片描述

对于思考题，无非就是将进程库换成线程库，但是要注意的是线程可进程的区别，对于同一个进程的线程，它们是会有独立的寄存器和栈空间的，但是会共享其他的大部分数据空间. 由于原理是一样的，我们可以使用一种更加简单的方式实现，即队列，另外使用的是线程，具体代码如下：

import threading
import queue
import time
import random

buffer = queue.Queue()


def Producer(name):
    cnt = 0
    while cnt < 10:
        while buffer.qsize() < 10:
            element = chr(random.randint(0, 25) + 65)
            buffer.put(element)
            print(f"{name} has put '{element}' in the buffer\n")
            cnt += 1
            time.sleep(1)


def Consumer(name):
    cnt = 0
    while cnt < 10:
        while buffer.qsize():
            print(f'{name} get {buffer.get()} from buffer\n')
            time.sleep(1)
            cnt += 1


t1 = threading.Thread(target=Producer, args=("p1",))
t2 = threading.Thread(target=Producer, args=("p2",))
t3 = threading.Thread(target=Consumer, args=("c1",))
t4 = threading.Thread(target=Consumer, args=("c2",))

t1.start()
t2.start()
t3.start()
操作系统------生产者消费者模型
sandmm112的博客
04-24 5207
        在“进程间通信----信号量”一文中，有简单介绍过生产者消费者模型的基本概念。在下文中将使用有关线程的互斥与同步的相关概念来实现两种不同类型的生产者消费者模型。在本文中侧重于线程间同步的实现。有关线程互斥与同步的相关概念见线程的互斥与同步一文：        首先介绍该模型的背景知识：生产者消费者问题        该问题是一个著名的同步问题。它描述的是：一群生产者进程正在生产产品...
生产者消费者图形化演示
06-03
操作系统实验课实现的生产者消费者模型图形化演示。通过“企鹅吃苹果”这个小故事吧，苹果是生产者生产出来的，而企鹅是消费者。可以调节生产和消费的速度，也可以暂停程序方便演示。用C++实现的，使用的是纯粹的API，不想使用MFC~~
Python编程实验-使用SimPy模拟简单“生产者-消费者”模型
jialChen的博客
02-25 1365
描述 使用基于Python的SimPy仿真工具，实现《操作系统原理》课程中较为简单的进程同步问题——“生产者-消费者”模型 准备工作 Python：2.7版本以上即可 SimPy：本实验基于2.3.1版本 pip install SimPy==2.3.1 学习SimPy中 yield waituntil 语法 参考程序 import SimPy.Simulation as Simulation import random ls=[] #本程序模拟了一个进程同步问题，“生产者-消费者”问题。一个生
生产者消费者模型-c++实现
u011926899的专栏
08-08 1235
笔者最近在修改client的scan逻辑，用到了生产消费模型，因此写来写了中这个示例代码。
编程模拟实现生产者-消费者进程
11-04
生产者-消费者问题描述的是：有一群生产者进程在生产产品，并将这些产品提供给消费者进程去消费。为使生产者进程与消费者进程能够并发执行，在两者之间设置了一个具有n个缓冲区的缓冲池，生产者进程将它所生产的产品放入一个缓冲区中；消费者进程可以从一个缓冲区中取走产品去消费。尽管所有的生产者和消费者进程都是以异步方式运行的，但它们之间必须保持同步，即不允许消费者进程到一个空缓冲区去取产品；也不允许生产者进程向一个已经装满产品的缓冲区中投放产品。
生产者-消费者模型模拟进程调度
11-05
内含多个实验文档与可运行的代码 内容：编程实现生产者-消费者问题的模拟。 基本要求： 1. 生产者消费者对缓冲区进行互斥操作。 2. 缓冲区大小为10，缓冲区满则不允许生产者生产数据，缓冲区空则不允许消费者消费数据。 3. 生产者消费者各循环操作10次。
生产者消费者问题实验报告和代码实现
01-07
在生产者消费者模型中，生产者和消费者线程并发运行，但它们对共享资源的访问必须受到控制，这就涉及到了线程间的同步。 3. **同步对象与相关函数**：在大多数编程语言中，如Java、C++、Python等，都有提供内置的...
生产者-消费者模拟实现及进程调度
7. **线程编程**：在多线程环境下模拟生产者-消费者问题，通常会使用线程（Thread）来实现生产者和消费者的并发执行。线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。 8....
Python 实现CNN-RNN深度学习模型的项目示例（含完整的程序，GUI设计和代码详解）
最新发布
01-08
其他说明：文中涉及的技术涵盖了前沿的神经网络架构和训练技巧，并附带完整的Python代码实例，有助于学习者快速入门并掌握这项技术的实际操作技能。同时讨论了一些高级主题，如模型压缩优化，以及对未来发展方向进行...
电子科技大学操作系统进程与资源管理实验代码（python）.zip
04-21
`exp.py`中可能会有生产者消费者模型、哲学家就餐问题等经典同步问题的实现。 5. **I/O操作**：在操作系统中，进程通常需要进行I/O操作，如读写文件。Python的`open()`函数和`os`模块提供了文件操作接口，同时，非...
操作系统实验报告_进程同步与互斥.doc
07-13
操作系统实验报告《进程同步与互斥》实验的主要目的是掌握基本的进程同步与互斥算法，了解生产者-消费者问题，并学习使用 Windows 2000/XP 中基本的同步对象，掌握相关 API 的使用方法。实验中，设计了一个控制台...
c语言操作系统进程调度模拟代码
04-19
用c语言编写的代码。模拟的操作系统进程调度的小实验。学习操作系统课程时，为了加强对进程调度算法的理解而做的小实验。
模拟仿真“生产者-消费者”问题的解决过程及方法
07-03
本课程设计的目的是通过设计一个消费者进程与生产者进程的同步模拟系统，认识进程间的同步机制生产者消费者问题是一个著名的进程同步问题。 （1） 有一群生产者进程在生产消息, 并将消息提供给消费者进程去消费。为使生产者进程和消费者进程能并发执行, 在它们之间设置了一个具有n个缓冲区的缓冲池, 生产者进程可将它所生产的消息放入一个缓冲区中, 消费者进程可从一个缓冲区中取得一个消息消费。 （2） 尽管所有的生产者进程和消费者进程都以异步方式运行, 但它们之间必须保持同步, 即不允许消费进程者到一个空缓冲区去取消息, 也不允许生产者进程向一个已装有消息且尚未被取走消息的缓冲区中投放消息。 （3） 任何时刻只能有一个进程可对共享缓冲区进行操作 这是一个用Eclipse为工具、java为编程语言而实现模拟消费者进程与生产者进程的同步。
使用多线程程序模拟实现单生产者/多消费者问题（Linux下C语言）。
11-25
使用多线程程序模拟实现单生产者/多消费者问题。 要求“生产者”随机产生一个整数，“消费者 1”将这个整数加 1 后输出，“消 费者 2”将这个整数加 2 后输出，“消费者 3”将这个整数加 3 后输出，“消 费者 4”将这个整数加 4 后输出。当程序接收到键盘输入“q”或“Q”时退 出。
python多线程实现生产者消费者_用Python实现多线程“生产者-消费者”模型的简单例子...
weixin_39713805的博客
12-03 314
用Python实现多线程“生产者-消费者”模型的简单例子生产者消费者问题是一个著名的线程同步问题，该问题描述如下：有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个具有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓冲区中取走产品进行消费，显然生产者和消费者之间必须保持同步，即不允许消费者到一个空的缓冲区中取产品，...
Python-多线程及生产者与消费者
新阿巴阿巴
01-13 2092
一. 前置知识 1. 队列基础 如果不指定队列是什么，请自行查阅 在Python中，队列是最常用的线程间的通信方法，因为它是线程安全的 from queue import Queue # 创建队列 # -- 限制队中最多有 maxsize 个元素 # -- 如果省略参数，默认元素个数无限制 q = Queue(100) q1 = Queue() # 元素入队 q.put(1) q.put(True) q.put('abc') # 队列的大小 print(q.qsize()) # 判断队满
生产者消费者模式【Linux】
Man9o
04-17 1686
当Blocking Queue已满时，生产者线程将会被阻塞；当Blocking Queue为空时，消费者线程将会被阻塞。图片来源于：https://math.hws.edu/eck/cs124/javanotes7/c12/producer-consumer.pngBlocking Queue 与普通队列的主要区别在于它具有阻塞功能。当管道中没有数据可读时，从管道中读取数据的操作将会被阻塞，直到有新的数据可用；当管道已满时，向管道中写入数据的操作将会被阻塞，直到管道中有空闲位置可用。
生产者与消费者模型Linux下C语言的实现
深海蓝的技术随笔
09-01 4161
文章出自：http://page.renren.com/600235506/note/492983524 学习了信号量以及共享内存后，我们就可以实现进程的同步与互斥了。说到这里，最经典的例子莫过于生产者和消费者模型。下面就和大家一起分析，如何一步步实现这个经典模型。 下面程序，实现的是多个生产者和多个消费者对N个缓冲区（N个货架）进行访问的例子。现在先想想我们以前的伪代码是怎么写的？是不是这样
java 生产者消费者_一看就懂！Java 代码解决生产者/消费者问题（编程实例 ）
weixin_39816062的博客
12-02 188
生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，如下图所示，生产者向空间里存放数据，而消费者取用数据，如果不加以协调可能会出现以下情况：存储空间已满，而生产者占用着它，消费者等着生产者让出空间从而去除产品，生产者等着消费者消费产品，从而向空间中添加产品。互相等待，从而发生死锁。以下实例演示了如何通过线程解决生产者/消费者问题：/* author by 程序...
Python线程实现生产者-消费者系统实验
在这个IT知识点的解读中，我们将会分析和扩展给定...它涉及了操作系统中的生产者消费者模型、Python的线程和同步机制、以及OpenCV在视频处理中的应用。通过实现这个项目，可以加深对并发编程和计算机视觉处理的理解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

call me Patrick

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值