• n süreç {P0, P1, …, Pn-1}; her birinin paylaşılan veriye eriştiği bir kritik bölgesi vardır: global değişkene yazmak, tablo güncellemek, dosyaya yazmak…
• Kural: bir süreç kritik bölgedeyken başka hiçbir süreç kendi kritik bölgesinde olmamalıdır.
• Her süreç girmek için giriş bölümünde izin ister, çıkarken çıkış bölümünde bunu duyurur.
• Yarış durumu: sonucun yürütme sırasına bağlı olması. Karşılıklı dışlama: paylaşılan veriye aynı anda tek erişim.

while (true) {
    /* giriş bölümü  (entry)     */
        /* kritik bölge          */
    /* çıkış bölümü  (exit)      */
        /* kalan bölüm (remainder) */
}

/* paylaşılan */
bool flag[2] = { false, false };
int  turn;

/* P_i  (j = 1 - i) */
while (true) {
  flag[i] = true;    /* girmek istiyorum */
  turn = j;          /* önce sen buyur  */
  while (flag[j] && turn == j)
    ;                /* meşgul bekle    */
  /* kritik bölge */
  flag[i] = false;
  /* kalan bölüm */
}

G. L. Peterson, 1981. Yalnız iki süreç içindir; n süreç için fırıncı (bakery) algoritması vardır.

/* x = y = 0 */
/* T1 */        /* T2 */
x = 1;          y = 1;
r1 = y;         r2 = x;

/* r1 == 0 && r2 == 0 ?  */

Sezgiye göre en az biri 1 görmeli. Ama x86, ARM ve RISC-V'de r1 = r2 = 0 gözlenebilir (store-buffer testi).

• Sunumdaki eski örnekte üç hata vardı:
  • volatile boolean[] flag yalnız dizi referansını volatile yapar, elemanları değil.
  • getId() % N iki iş parçacığına aynı i'yi verebilir.
  • Kritik bölgedeki print ölçümü bozar.
• Java'da volatile okuma/yazmaları sıralı tutarlıdır; ayrı volatile alanlarla Peterson doğru çalışır.
• Thread.onSpinWait() (Java 9+) CPU'ya “meşgul bekliyorum” ipucu verir (x86 pause).

sayac = 200000
sayac = 200000
sayac = 200000

var b = new CyclicBarrier(3,
  () -> System.out.println(
          "faz " + faz[0]++ + " tamam"));
/* 3 iş parçacığı, her biri:
   for (f = 0; f < 2; f++) {
     hesapla(f); b.await();
   } */

faz 0 tamam
faz 1 tamam

/* tümü TEK atomik komuttur */
bool test_and_set(bool *hedef) {
  bool eski = *hedef;
  *hedef = true;
  return eski;
}

/* kullanım: basit spinlock */
bool lock = false;
while (test_and_set(&lock))
  ;            /* meşgul bekle */
/* kritik bölge */
lock = false;

• Yazılım çözümlerinin sorunu: oku ve yaz ayrı adımlar. Donanım, bir bellek sözcüğünü kesintisiz test edip değiştiren komutlar sunar.
• Atomiklik çok çekirdekte de geçerlidir: önbellek tutarlılığı protokolü o satırı komut boyunca tek çekirdeğe ayırır (eskiden bellek veriyolu kilitlenirdi).

enter_region:
  MOVE REGISTER,#1    | yazmaca 1 koy
  XCHG REGISTER,LOCK  | yazmaç ile LOCK'u takas et
  CMP REGISTER,#0     | LOCK 0 mıydı?
  JNE enter_region    | değilse: döngü
  RET                 | kritik bölgeye girildi
leave_region:
  MOVE LOCK,#0        | LOCK = 0
  RET

• İki işlenenin içeriğini tek adımda değiştirir; etkisi TSL ile aynıdır.
• Intel x86'da kilitleme için kullanılan komuttur: bellek işlenenli XCHG örtük olarak LOCK önekli, yani atomiktir.
• C11 karşılığı: atomic_exchange(&lock, 1).

C11 <stdatomic.h>

#include <stdatomic.h>
atomic_int sayac = 0;     /* _Atomic int */

void *is(void *arg) {
  for (int n = 0; n < 100000; n++)
    atomic_fetch_add(&sayac, 1);
  return NULL;
}
/* 2 iş parçacığı + join → 200000 */

_Atomic türde sayac++ de atomiktir (varsayılan seq_cst). x86'da lock xadd, ARMv8.1'de ldadd olur.

Java AtomicInteger

static AtomicInteger atom = new AtomicInteger();
/* iki iş parçacığı, her biri 100_000 kez: */
atom.incrementAndGet();

var v = new AtomicInteger(5);
v.compareAndSet(5, 6);   /* true,  v = 6 */
v.compareAndSet(5, 7);   /* false, v = 6 */

AtomicInteger = 200000
synchronized  = 200000
true 6
false 6

mutex_lock:
  TSL REGISTER,MUTEX | eskisini al, 1 yap
  CMP REGISTER,#0    | boş muydu?
  JZE ok             | evet: alındı
  CALL thread_yield  | hayır: CPU'yu ver
  JMP mutex_lock     | sonra yine dene
ok: RET
mutex_unlock:
  MOVE MUTEX,#0
  RET

• Tanenbaum Şekil 2-29: enter_region'dan farkı döngü yerine thread_yield; kullanıcı düzeyi iş parçacıklarında meşgul beklemeyi önler.
• Linux futex (fast userspace mutex): çekişme yoksa sistem çağrısı yapılmaz; glibc pthread_mutex, Java kilitleri ve Go bunun üstüne kuruludur.

typedef struct {
  int value;
  struct process *list;
} semaphore;

Yaygın hatalar

Semafor güçlüdür ama yapısal değildir: doğruluk her wait/signal çiftine bağlıdır. Monitörler bu yüzden geliştirildi.

/* Downey: açlıksız çözüm */
/* yazar */
wait(turnike);
wait(odaBos);
  yaz();
signal(turnike);
signal(odaBos);

/* okur */
wait(turnike); signal(turnike);
/* ilk okur odaBos'u alır,
   son okur bırakır (rc ile) */
  oku();

semaphore catal[5];        /* hepsi 1 */

void filozof(int i) {
  while (true) {
    dusun();
    wait(&catal[i]);             /* sol */
    wait(&catal[(i + 1) % 5]);   /* sağ */
    ye();
    signal(&catal[(i + 1) % 5]);
    signal(&catal[i]);
  }
}

• Dijkstra (1965): her filozof düşünür, acıkınca iki komşu çatalı alıp yer.
• Kısıtlı kaynakların süreçler arasında kilitlenmesiz ve açlıksız paylaştırılmasının modelidir.

• Hoare (1974) ve Brinch Hansen (1975): veri, prosedürler ve başlangıç kodunu bir arada tutan dil düzeyinde soyut veri türü.
• Süreçler monitörün prosedürlerini çağırabilir ama iç verisine doğrudan erişemez.
• Aynı anda monitör içinde yalnız bir süreç etkin olabilir; giriş kilidini derleyici ekler, programcı unutamaz.
• Monitör dolu ise çağıran giriş kuyruğunda bekler. Bir koşulu beklemek için koşul değişkenleri kullanılır.
• Semaforda down sırasını karıştırmak kilitlenme yaratıyordu; monitör bu hata sınıfını azaltır.

monitor ornek
  integer i;
  condition c;
  procedure uretici(); … end;
  procedure tuketici(); … end;
end monitor;

• sem_init'in ikinci argümanı 1 ise semafor süreçler arası paylaşılan bellekte olmalıdır.
• macOS adsız semaforları desteklemez (sem_init kullanımdan kalktı); adlandırılmış semafor ya da dispatch_semaphore kullanılır.
• Java: java.util.concurrent.Semaphore — acquire(), release(), isteğe bağlı adil kip.

• Her Java nesnesi bir monitördür: içsel kilit + tek bir bekleme kümesi (wait set).
• synchronized metot/blok kilidi alır, çıkışta (istisnada bile) bırakır; kilit yeniden girilebilir.
• wait() kilidi bırakıp uyur; notify() birini, notifyAll() hepsini uyandırır. Anlam Mesa'dır: while şart.
• Üretici ve tüketici aynı bekleme kümesini paylaştığı için notifyAll daha güvenlidir.

alındı 10
alındı 20
alındı 30
alındı 40

• java.util.concurrent.locks: bir kilide birden çok koşul bağlanabilir; signal doğru grubu uyandırır.
• tryLock(), süre sınırlı ve kesilebilir kilitleme, isteğe bağlı adil kip.
• unlock() mutlaka finally içinde.
• Java 21 sanal iş parçacıkları synchronized içinde bloke olunca taşıyıcı iş parçacığını “sabitliyordu”; JDK 24 (JEP 491) bunu giderdi.

1 2 3 4 5 | toplam = 15
1 2 3 4 5 | toplam = 15
1 2 3 4 5 | toplam = 15

void push(node_t *n) {
  node_t *eski = atomic_load(&top);
  do {
    n->next = eski;
  } while (!atomic_compare_exchange_weak(
               &top, &eski, n));
}  /* başarısızsa eski = güncel top */