Thread Çözümü için Lock kullanımı

Bir thread ancak aşağıdaki durumları sağlıyorsa iyi yapılandırılmıştır diyebiliriz:

1. Her kritik bölge unique bir Lock objesi ile ilişkilendirilmişse,
2. Kritik bölgeye girmek istediğinde objenin lock() metodunu çağırıyorsa
3. Kritik bölgeden çıkarken de unlock() metodunu kullanıyorsa. 

Lock lara girmeden önce Mutual Exclusion yani Karşılıklı Dışlamadan bahsetmek istiyorum. Karşılıklı dışlama Kritik Bölgeye bir thread'in işi bitmeden diğerlerinin girmesinin engellenmesi ile sağlanır. Alice ve Bob'un 2 evcil hayvanları olduğunu ve bunların ortak bir bahçeyi kullandıklarını ancak bu iki evcil hayvanın birbiri ile anlaşamadığını varsayacak olursak (Alice'in kedisi, Bob'un köpeği olsun) aynı zaman sınırları içerisinde yalnızca bir tanesinin bahçeyi kullanması gerekir.

• İlk olarak kedi yada köpekten birisi bahçeye çıkmak istediğinde bunu hemen yapabilmelidir.
• İkinci olarak iki hayvan da aynı anda bahçeye çıkmak istediğinde sadece biri bunu başarabilmelidir. Aksi halde ikisi de bahçeye çıkmak için bekleyecek ancak ikisi de başarılı olamayacak bu da deadlock oluşturacaktır. 
• Son olarak da hayvanlardan ikisi de bahçeye çıkmak istediğinde biz önceliği Alice'in kedisine verdiğimizi varsayarsak bu durum sürekli devam eder ve her defasında Alice'in kedisi bahçeyi kullanıp Bob'un köpeği beklerse bu durum starvation sorununa yol açar.

Karşılıklı dışlama yukarıda maddelendirdiğim tüm durumları sağlamalıdır. Lock kullanıyor olmamızın amaçları arasında Threadler'i senkronize bir şekilde kullanabilmek yatmaktadır. Bunun için başlangıçta 2 thread için sağlanan çözümlerden bahsedeceğim.

The LockOne

LockOne çözümünde threadlerden biri kritik bölgeye gireceği zaman bayrağı çekip diğer thread'e ben kritik bölgeye giriyorum haberini verir. Ancak LockOne çözümünde iki thread aynı anda bayrak çekerse deadlock kaçınılmazdır. 

class LockOne implements Lock{
 private boolean[] flag = new boolean[2];
 public void lock(){
  int i=ThreadID.get();
  int j=1-i;
  flag[i]=true; //bu noktada deadlock olabilir
  while(flag[j]){}
 }
 public void unlock(){
  int i=ThreadID.get();
  flag[i]=false;
 }
}

Başlangıçta iki flag'in de false atandığını kabul edecek olursak eğer  flag[i]=true atandığı noktada iki thread'in aynı anda atama yaptığını düşünecek olursak deadlock-free şartımız sağlanmamış oluyor, threadler deadlock'a giriyor ve karşılıklı dışlama hayal oluyor. Çözüm için LockTwo önerilmiştir.

The LockTwo

LockTwo çözümünün yaklaşımı öncelik atamak ile ilgilidir. Yani ilk ben gelmişsem kritik bölgeye ben bekleyeyim benden sonra gelecek olan ben lock'a geldim desin ben de ondan sonra kritik bölgeye gireyim mantığıyla çalışmaktadır ancak threadler eş zamanlı değil de sıralı çalışacak olurlarsa deadlock olacaktır. Aşağıdaki kodu inceleyecek olursak eğer önce A thread'i gelirse victim olarak kendisini atar ve while'ın içine girerek beklemeye başlayacaktır. Arkasından B thread'i geldiğinde A kritik bölgeye girebilecek B while'ın içinde dönüp duracak bu da deadlock'a sebep olacaktır. Bu yüzden LockTwo çözümü yalnızca iki thread'ın concurrent (eş zamanlı) çalıştığı durumlar için geçerlidir.

class LockTwo implements Lock{
 private volatile int victim; //volatile değişkenimin son halini korumasını istediği direk bellek adresinden erişmek istediğim zamanlarda kullandığım bir anahtar kelimedir.
 public void lock(){
  int i=ThreadID.get();
  int j=1-i;
  victim=i;
  while(victim==i){}
 }
 public void unlock(){
 }
}

The Peterson Lock

LockOne ve LockTwo'nun sorunları göz önüne alınıp, ikisinin çözümleri de birleştirerek bir algoritma üretilmiş ve Peterson'ın Algoritması adı verilmiştir. Algoritmayı inceleyecek olursak hem sıralı hem de eşzamanlılıkta oluşacak olan deadlock yada starvation sorunlarına büyük ölçüde çözüm getirerek karşılıklı dışlamayı sağlamaktadır.

class Peterson implements Lock{
 private boolean[] flag = new boolean[2];
 private volatile int victim;
 public void lock(){
  int i=ThreadID.get();
  int j=1-i;
  flag[i]=true;
  victim=i;
  while(flag[j] && victim==i){}
 }
 public void unlock(){
  int i=ThreadID.get();
  flag[i]=false;
 }

Kaynak: The Art of Multiprocessor Programming