Problema productor-consumidor:
También conocido como el problema del búfer limitado, es un caso clásico de problemas de sincronización de múltiples subprocesos. Este problema describe lo que sucede cuando dos subprocesos que comparten un búfer de tamaño fijo, el llamado "productor" y el "consumidor", se ejecutan en realidad. La función principal del productor es generar una cierta cantidad de datos en el búfer y luego repetir el proceso. Al mismo tiempo, los consumidores consumen estos datos en el búfer. La clave de este problema es asegurarse de que los productores no agreguen datos cuando el búfer esté lleno y que los consumidores no consuman datos cuando el búfer esté vacío.
Estructura del modelo
Soluciones:
Este problema involucra dos conceptos importantes en la gestión de procesos del sistema operativo: sincronización y exclusión mutua.
La sincronización significa que los productores y los consumidores deben trabajar juntos, y los consumidores no pueden recoger productos en un búfer vacío; y los productores tampoco pueden colocar productos en un búfer que está lleno de productos y no se ha retirado.
La exclusión mutua significa que dos miembros cualesquiera del productor y el consumidor, el productor y el productor, y el consumidor y el consumidor deben utilizar la zona de amortiguamiento exclusivamente. Cuando un miembro ingresa al búfer para almacenar / tomar productos, otros miembros serán bloqueados afuera de la puerta y esperarán en la fila (bloqueados); cuando termine, se notificará al líder del equipo para ingresar.
Código falso:
De acuerdo con la teoría del sistema operativo, necesitamos tres semáforos, denominados lleno, vacío y mutex respectivamente, para representar el número de recursos disponibles del consumidor, el número de recursos disponibles del productor y si el búfer está disponible. Valor inicial: lleno = 0 (el consumidor no tiene recursos disponibles), vacío = n (el productor tiene n recursos disponibles, n representa el tamaño del búfer), mutex = 1 (el búfer está disponible).
semaphore mutex=1, empty=n, full=0;
item buffer[n] ;
int in=0,out=0;
void producer(){
//生产者进程
do{
producer an item nextp; //产一个产品
…
wait(empty); //empty减1
wait(mutex);//加锁
buffer[in]=nextp;
in=(in+1)% n; //移动生产指针
signal(mutex);//解锁
signal(full); //full增1
}while(TRUE);
}
void consumer(){
//消费者进程
do{
wait(full);
wait(mutex);
nextc=buffer[out];
out= (out+1)%n;
signal(mutex);
signal(empty);
consumer the item in nextc;
...
}while(TRUE);
}
Implementación multiproceso
La capacidad de producción del productor fijo y el consumo del consumidor cada vez son 1 o se puede establecer en un valor aleatorio.
Parte 1: Consumidor
class Consumer(threading.Thread):
def run(self):
#全局变量
global Resources
global UseTime
global ProduceTime
while True:
# resource2 = random.randint(100,1000) #随机产生一个消耗资源量
resource2 = 1
Lock.acquire() #开启线程锁
if resource2 <= Resources:
Resources -= resource2
print("{}消费者目前拥有的资源量为{},使用了{}资源量，还剩余{}资源量".format(threading.current_thread(),Resources+resource2, resource2, Resources))
else:
if UseTime >= ProduceTime: #如果消费者拥有的资源小于消耗的资源，则退出
Lock.release() #释放线程锁
break
print("{}消费者需要使用{}的资源,目前拥有的资源量为{},所以资源不足".format(threading.current_thread(),Resources,resource2))
Lock.release()
time.sleep(0.3)
Parte 2: Clase de productor
class Producer(threading.Thread):
def run(self):
#全局变量
global Resources
global UseTime
global ProduceTime
while True:
# resource1 = random.randint(100,1000) #随机产生一个生产的资源量
resource1 = 1
Lock.acquire() #开启线程锁
if UseTime >= ProduceTime:
Lock.release() #释放线程锁
break
UseTime += 1
Resources += resource1 #生产者增加资源
print("%s生产者生产了%d的使用资源，现在总共还有%d的可用资源量"%(threading.current_thread(),resource1,Resources))
Lock.release()
time.sleep(0.3)
La tercera parte: la parte de la función principal
import time
import random
import threading
Resources = 0 #初始可用资源量
Lock = threading.Lock() #创建线程锁
ProduceTime = 30 #定义一个生产次数
UseTime = 0 #初始化使用次数
def main():
for i in range(4):
t=Consumer(name='消费者%d'%(i))
t.start()
for x in range(4):
y = Producer(name='生产者%d'%(x))
y.start()
if __name__ == '__main__':
main()
resultado de la operación
