PRODUCER CONSUMER PROBLEM

Dalam ilmu komputer, produsen-konsumen masalah (juga dikenal sebagai masalah bounded-buffer) adalah contoh klasik dari masalah sinkronisasi multi-proses. Masalahnya menggambarkan dua proses, produsen dan konsumen, yang berbagi bersama, tetap ukuran buffer. Tugas produsen adalah untuk menghasilkan sepotong data, memasukkannya ke buffer dan mulai lagi. Pada saat yang sama konsumen adalah mengkonsumsi data (yaitu mengeluarkannya dari buffer) salah satu bagian pada suatu waktu. Masalahnya adalah untuk memastikan bahwa produsen tidak akan mencoba untuk menambahkan data ke dalam buffer jika itu penuh dan bahwa konsumen tidak akan mencoba untuk menghapus data dari buffer kosong.

 Solusi untuk produsen adalah baik pergi untuk tidur atau membuang data jika buffer penuh. Kali berikutnya konsumen menghapus item dari buffer, ini akan memberitahu produsen yang mulai mengisi buffer lagi. Dengan cara yang sama, konsumen bisa tidur jika menemukan buffer yang akan kosong. Kali berikutnya produsen menempatkan data ke dalam buffer, maka konsumen bangun tidur. Solusi ini dapat dicapai melalui komunikasi antar-proses, biasanya menggunakan semaphores. Sebuah solusi tidak memadai bisa mengakibatkan kebuntuan dimana kedua proses sedang menunggu untuk dibangunkan.

Solusi ini memiliki kondisi lomba. Untuk mengatasi masalah tersebut, seorang programmer ceroboh bisa datang dengan solusi di bawah ini. Dalam larutan dua rutinitas perpustakaan digunakan, tidur dan bangun. Ketika tidur disebut, penelepon tersebut akan diblokir sampai proses lain membangunkannya dengan menggunakan rutin bangun. itemCount adalah jumlah item dalam buffer.

Masalah dengan solusi ini adalah bahwa ia mengandung kondisi lomba yang dapat mengarah ke jalan buntu. Pertimbangkan skenario berikut:
1. konsumen baru saja membaca itemCount variabel, melihat itu nol dan hanya akan bergerak di dalam blok-if.
2. Tepat sebelum memanggil tidur, konsumen terganggu dan produsen dilanjutkan.
3. Produsen menciptakan suatu item, meletakkannya ke dalam buffer, dan meningkatkan itemCount.
4. Karena buffer itu kosong sebelum penambahan terakhir, produsen mencoba untuk membangunkan konsumen.
 5. Sayangnya konsumen belum tidur, dan panggilan bangun hilang. Ketika konsumen kembali, ia pergi tidur dan tidak akan pernah terbangun lagi. Hal ini karena konsumen hanya terbangun oleh produsen ketika itemCount sama dengan 1.

Karena kedua proses akan tidur selamanya, kami telah lari ke jalan buntu. Solusi ini karena tidak memuaskan.
Analisis alternatif adalah bahwa jika bahasa pemrograman tidak mendefinisikan semantik dari pengaksesan konkuren terhadap variabel bersama (dalam hal ini itemCount kasus) tanpa menggunakan sinkronisasi, maka solusinya tidak memuaskan karena itu, tanpa perlu secara eksplisit menunjukkan kondisi lomba.

Semaphore memecahkan masalah panggilan bangun hilang. Dalam larutan di bawah ini kami menggunakan dua semaphores, fillCount dan emptyCount, untuk memecahkan masalah. fillCount bertambah dan emptyCount decremented ketika item baru telah dimasukkan ke dalam buffer. Jika produsen mencoba untuk pengurangan emptyCount sedangkan nilai adalah nol, produsen diletakkan untuk tidur. Kali berikutnya item dikonsumsi, emptyCount bertambah dan produser bangun. Konsumen bekerja analog.

Solusi diatas bekerja dengan baik ketika hanya ada satu produsen dan konsumen. Sayangnya, dengan beberapa produsen atau konsumen solusi ini berisi kondisi lomba yang serius yang dapat menghasilkan dua atau lebih proses membaca atau menulis ke dalam slot yang sama pada waktu yang sama. Untuk memahami bagaimana hal ini mungkin, bayangkan bagaimana prosedur putItemIntoBuffer () dapat diimplementasikan. Ini bisa berisi dua tindakan, salah menentukan slot yang tersedia berikutnya dan tulisan lain ke dalamnya. Jika prosedur tersebut dapat dijalankan secara bersamaan oleh beberapa produsen, maka skenario berikut ini mungkin:
1. Dua produsen emptyCount pengurangan
2. Salah satu produsen menentukan slot kosong berikutnya dalam buffer
3. Kedua produser menentukan slot kosong berikutnya dan mendapatkan hasil yang sama sebagai produsen pertama
4. Kedua produsen menulis ke slot yang sama
Untuk mengatasi masalah ini, kita membutuhkan suatu cara untuk memastikan bahwa hanya satu produsen yang mengeksekusi putItemIntoBuffer () pada suatu waktu. Dengan kata lain kita perlu cara untuk mengeksekusi critical section dengan pengecualian bersama. Untuk mencapai hal ini kami menggunakan semaphore mutex biner disebut. Karena nilai dari semaphore biner bisa hanya salah satu atau nol, hanya satu proses dapat mengeksekusi antara bawah (mutex) dan sampai (mutex). Solusi bagi produsen dan konsumen beberapa ditunjukkan di bawah ini.

Perhatikan bahwa urutan yang berbeda semaphores bertambah atau decremented sangat penting: mengubah urutan mungkin mengakibatkan deadlock.
[Sunting] Menggunakan monitor
Kode pseudo berikut menunjukkan solusi untuk masalah produsen-konsumen yang menggunakan monitor. Karena pengecualian reksa implisit dengan monitor, tidak ada usaha ekstra diperlukan untuk melindungi critical section. Dengan kata lain, solusi di bawah ini bekerja dengan sejumlah produsen dan konsumen tanpa modifikasi apapun. Perlu juga dicatat bahwa menggunakan monitor membuat kondisi balapan lebih sedikit mungkin dibandingkan ketika menggunakan semaphores.

Perhatikan penggunaan sementara pernyataan dalam kode di atas, baik ketika menguji apakah buffer penuh atau kosong. Dengan beberapa konsumen, ada kondisi lomba dimana satu konsumen mendapatkan diberitahukan bahwa item telah dimasukkan ke dalam buffer namun konsumen lain sudah menunggu pada monitor sehingga menghapusnya dari buffer sebagai gantinya. Jika saat itu bukan jika terlalu banyak item dapat dimasukkan ke buffer atau menghapus mungkin mencoba pada buffer kosong.