Perbedaan Bounded-Buffer, Readers and Writers, and Dining-Philosophers Problem dalam Konsep Sinkronisasi Sistem Operasi

1. The Bounded Buffer Problem
Masalah produsen menghasilkan barang dan konsumen yang akan menggunakannya. Ada beberapa batasan yang harus dipenuhi, antara lain :
- Barang yang dihasilkan oleh produsen terbatas
- Barang yang dipakai konsumen terbatas
- Konsumen hanya boleh menggunakan barang yang dimaksud setelah produsen menghasilkan barang dalam jumlah tertentu
- Produsen hanya boleh memproduksi barang jika konsumen sudah kehabisan barang

Semaphore empty=N, full=0, mutex=1;

process producer {
   while (true) {
      empty.acquire();
      mutex.acquire();
      // produce
      mutex.release();
      full.release();
   }
}


process consumer {

   while (true) {
      full.acquire();
      mutex.acquire();
      // consume
      mutex.release();
      empty.release();
}

Untuk penyelesaian permasalahan bounded buffer menggunakan semaphore
Semafor mutex memberikan eksklusi bersama untuk akses ke buffer.

2. The Readers-Writers Problem
Item data seperti file dibagi di antara beberapa proses.Setiap proses diklasifikasikan sebaggai pembaca atau penulis.Beberapa pembaca dapat mengakses file secara bersamaan. Seorang penulis harus memiliki akses eksklusif (yaitu, tidak dapat berbagi dengan pembaca atau penulis lain).
        Terdapat dua variasi pada masalah ini, yaitu :
- Seorang reader tidak perlu menuggu reader lain untuk selesai hanya karena ada writer menunggu (reader memiliki prioritas lebih tinggi disbanding dengan writer)
- Jika ada writer yang sedang menunggu maka tidak boleh ada reader lain yang bekerja (writer memiliki prioritas yang lebih tinggi)

Dalam versi prioritas pembaca, penulis mungkin kelaparan
Dalam versi prioritas penulis, pembaca mungkin kelaparan
Solusi semafor untuk versi prioritas pembaca (tanpa mengatasi kelaparan):

Semaphore mutex = 1;
Semaphore db = 1;
int readerCount = 0;

process writer {

   db.acquire();
   // write
   db.release();
}
  
process reader {

   // protecting readerCount
   mutex.acquire();
   ++readerCount;
   if (readerCount == 1)
      db.acquire();
   mutex.release();

   // read

   // protecting readerCount
   mutex.acquire();
   --readerCount;
   if (readerCount == 0)
      db.release();
   mutex.release();
}

ReaderCount adalah <cs> di mana kita harus mempertahankan kontrol dan kita menggunakan mutex untuk melakukannya.

Dalam hal ini : mengatasi kelaparan dalam larutan ini, dan kemudian mengembangkan solusi semafor prioritas penulis, dan kemudian mengatasi kelaparan di dalamnya.

3. The Dining Philosophers Problem
Permasalahan dining-philosophers digambarka pada dimana terdapat 5 filosof yang akan makan. Di sana disediakan 5 supit. Jika filosof lapar, ia akan mengambil 2 supit yaitu di tangan kanan dan kiri. Namun adakalanya hanya diambil supit satu saja. Jika ada filosof yang mengambil 2 supit, maka ada filosof yang harus menunggu sampai supit tersebut diletakkan. Hal ini dapat diimplementasikan dengan wait dan signal.



Solusi semaphore :

// represent each chopstick with a semaphore
Semaphore chopstick[] = new Semaphore[5]; // all = 1 initially

process philosopher_i {

    while (true) {
      // pick up left chopstick
      chopstick[i].acquire();

      // pick up right chopstick
      chopstick[(i+1) % 5].acquire();

      // eats

      // put down left chopstick
      chopstick[i].release();

      // put down right chopstick
      chopstick[(i+1) % 5].release();

      // think
    }
}

Solusi ini menjamin tidak ada dua filsuf tetangga yang makan bersamaan, namun memiliki kemungkinan untuk menciptakan jalan buntu. kembangkan solusi semafor bebas kebuntuan. Lalu mainkan bagaimana jika permainan skenario dengan semua masalah ini.


Sumber :
https://ayuewiejayantie.wordpress.com/sinkronisasi-proses/
http://perugini.cps.udayton.edu/teaching/courses/cps346/lecture_notes/classical.html