b'\n_START_ARTICLE_\nProblema productor-consumidor\n_START_PARAGRAPH_\nEn computaci\xc3\xb3n, el problema del productor-consumidor  es un ejemplo cl\xc3\xa1sico_NEWLINE_de problema de sincronizaci\xc3\xb3n de multiprocesos. El programa describe dos procesos, productor y_NEWLINE_consumidor, ambos comparten un buffer de tama\xc3\xb1o finito. La tarea del productor es generar un producto, almacenarlo y comenzar nuevamente; mientras que el consumidor toma (simult\xc3\xa1neamente) productos uno a uno. El problema consiste en que el productor no a\xc3\xb1ada m\xc3\xa1s productos que la capacidad del buffer y que el consumidor no intente tomar un producto si el buffer est\xc3\xa1 vac\xc3\xado._NEWLINE_La idea para la soluci\xc3\xb3n es la siguiente, ambos procesos (productor y consumidor) se ejecutan simult\xc3\xa1neamente y se \xe2\x80\x9cdespiertan\xe2\x80\x9d o \xe2\x80\x9cduermen\xe2\x80\x9d seg\xc3\xban el estado del buffer. Concretamente, el productor agrega productos mientras quede espacio y en el momento en que se llene el buffer se pone a \xe2\x80\x9cdormir\xe2\x80\x9d. Cuando el consumidor toma un producto notifica al productor que puede comenzar a trabajar nuevamente. En caso contrario si el buffer se vac\xc3\xada, el consumidor se pone a dormir y en el momento en que el productor agrega un producto crea una se\xc3\xb1al para despertarlo. Se puede encontrar una soluci\xc3\xb3n usando mecanismos de comunicaci\xc3\xb3n interprocesos, generalmente se usan sem\xc3\xa1foros. Una inadecuada implementaci\xc3\xb3n del problema puede terminar en un deadlock donde ambos procesos queden en espera de ser despertados. Este problema pude ser generalizado para m\xc3\xbaltiples consumidores y productores.\n_START_SECTION_\nHaciendo uso de monitores\n_START_PARAGRAPH_\nEl siguiente pseudoc\xc3\xb3digo muestra una soluci\xc3\xb3n al problema usando_NEWLINE_monitores. Como la exclusi\xc3\xb3n mutua est\xc3\xa1 impl\xc3\xadcita en los monitores no es necesario un_NEWLINE_esfuerzo extra para proteger la regi\xc3\xb3n cr\xc3\xadtica. En otras palabras, esta variante funciona con cualquier cantidad de productores y consumidores sin otra modificaci\xc3\xb3n. Es relevante el hecho de que el uso de monitores hace muchos menos probable la aparici\xc3\xb3n de conflictos que cuando se usan sem\xc3\xa1foros._NEWLINE_monitor ProducerConsumer {_NEWLINE_    int itemCount_NEWLINE_    condition full;_NEWLINE_    condition empty;_NEWLINE__NEWLINE_    procedure add(item) {_NEWLINE_        while (itemCount == BUFFER_SIZE) {_NEWLINE_            wait(full);_NEWLINE_        }_NEWLINE__NEWLINE_        putItemIntoBuffer(item);_NEWLINE_        itemCount = itemCount + 1;_NEWLINE__NEWLINE_        if (itemCount == 1) {_NEWLINE_            notify(empty);_NEWLINE_        }_NEWLINE_    }_NEWLINE_    procedure remove() {_NEWLINE_        while (itemCount == 0) {_NEWLINE_            wait(empty);_NEWLINE_        }_NEWLINE__NEWLINE_        item = removeItemFromBuffer();_NEWLINE_        itemCount = itemCount - 1;_NEWLINE__NEWLINE_        if (itemCount == BUFFER_SIZE - 1) {_NEWLINE_            notify(full);_NEWLINE_        }_NEWLINE__NEWLINE__NEWLINE_        return item;_NEWLINE_    }}procedure producer() {_NEWLINE_    while (true) {_NEWLINE_        item = produceItem()_NEWLINE_        ProducerConsumer.add(item)_NEWLINE_    }}procedure consumer() {_NEWLINE_    while (true) {_NEWLINE_        item = ProducerConsumer.remove()_NEWLINE_        consumeItem(item)_NEWLINE_    }}_NEWLINE_N\xc3\xb3tese el uso de la sentencia while cuando se comprueba si el buffer est\xc3\xa1 lleno o vac\xc3\xado. Con m\xc3\xbaltiples consumidores hay un race condition cuando un consumidor es notificado que un objeto ha sido puesto en el buffer pero otro consumidor que est\xc3\xa1 esperando en el monitor lo extrae del buffer antes. Si en vez de una sentencia while se usa un if muchos objetos pueden ser agregados a un buffer lleno o removidos de un buffer vac\xc3\xado.'