Giriş

Öğrenme Çıktıları

Temel Kavramlar

İş Parçacığı Nedir?

Temel Kavramlar

Neden Çok İş Parçacığı?

Temel Kavramlar

Tek ve Çok İş Parçacıklı Süreç

Temel Kavramlar

Paylaşılan ve Özel Öğeler

Temel Kavramlar

Her İş Parçacığının Kendi Yığını

Temel Kavramlar

Örnek: Üç İş Parçacıklı Kelime İşlemci

Üç ayrı süreç bu işi yapamaz: üçü de aynı belge üzerinde çalışmalıdır. Ortak adres alanı burada temel avantajdır.

Temel Kavramlar

Çok İş Parçacıklı Web Sunucusu

Temel Kavramlar

Dağıtıcı ve İşçi Kodu

while (TRUE) {
  get_next_request(&buf);  /* ağdan oku */
  handoff_work(&buf);      /* işçiye ver */
}

while (TRUE) {
  wait_for_work(&buf);
  look_for_page_in_cache(&buf, &page);
  if (page_not_in_cache(&page))
    read_page_from_disk(&buf, &page);
  return_page(&page);
}

• Her iki kod da sıralı ve okunaklıdır: bloke eden read çağrısı yalnızca o işçiyi durdurur.
• Tek iş parçacıklı sunucuda önbellekte olmayan sayfa için tüm süreç bloke olur; disk beklenirken CPU boşta kalır.
• Çok iş parçacıklı sunucuda iş bir işçiye aktarılır, sunucu yeni istekleri kabul etmeye devam eder.

Temel Kavramlar

Sunucu Tasarımının Üç Yolu

Kaynak: Tanenbaum & Bos, Modern Operating Systems, Şekil 2-10'daki karşılaştırma.

Temel Kavramlar

Çok İş Parçacığının Faydaları

Temel Kavramlar

Bağlam Değiştirme Maliyeti

• Kullanıcı düzeyi iş parçacıklarında geçiş çekirdeğe girmeden (tuzak yok) bir kütüphane fonksiyonuyla yapılır: daha da ucuzdur.
• Doğrudan maliyet mikrosaniyeler mertebesindedir; dolaylı maliyet (soğuk önbellek, TLB kaçırmaları) çoğu zaman daha büyüktür.

Çok Çekirdekli Programlama

Eşzamanlılık ve Paralellik

Çok Çekirdekli Programlama

Çok Çekirdekli Programlamanın Zorlukları

Çok Çekirdekli Programlama

Veri ve Görev Paralelliği

• Veri paralelliği: N öğeli diziyi toplamak için her çekirdek N/4 öğe toplar; sonunda kısmi toplamlar birleştirilir (GPU'lar bu modelin uç örneğidir).
• Görev paralelliği: iş, bağımsız görevlere bölünür; görevler aynı ya da farklı veriyi kullanabilir.
• Gerçek uygulamalar çoğunlukla ikisini birlikte kullanır.

Çok Çekirdekli Programlama

Amdahl Yasası

Çok Çekirdekli Programlama

Amdahl Eğrileri

• Programın %95'i paralelse teorik hızlanma sınırı 1 / 0,05 = 20×; 1024 çekirdekte bile yaklaşık 19,6×.
• Gerçekte senkronizasyon ve iletişim yükü nedeniyle hızlanma daha da düşüktür. Gustafson yasası: problem boyutu çekirdekle büyürse ölçeklenmiş hızlanma S + (1 − S)·N olur.

İş Parçacığı Modelleri

Kullanıcı ve Çekirdek Düzeyi İş Parçacıkları

• Kullanıcı düzeyi: iş parçacıkları kütüphanede (çalışma zamanı sistemi) yönetilir; çekirdek her süreci tek akışlı sanır.
• Çekirdek düzeyi: çekirdek her iş parçacığını tanır ve kendisi çizelgeler. Linux, Windows, macOS böyledir.

İş Parçacığı Modelleri

Kullanıcı Düzeyi İş Parçacıkları

İş Parçacığı Modelleri

Bloke Eden Çağrı: N:1 ve 1:1

İş Parçacığı Modelleri

Çekirdek Düzeyi İş Parçacıkları

İş Parçacığı Modelleri

Eşleme Modelleri

İş Parçacığı Modelleri

Modellerin Karşılaştırılması

* Çalışma zamanı, bloke olan çağrıyı fark edip başka çekirdek iş parçacığına geçebiliyorsa.

İş Parçacığı Modelleri

Güncel M:N: Sanal İş Parçacıkları

İş Parçacığı Modelleri

Açılır (Pop-up) İş Parçacıkları

/* mesaj gelince */
pthread_t t;
pthread_create(&t, NULL, isle, msg);
pthread_detach(t); /* join yok */

İş Parçacığı Kütüphaneleri

İş Parçacığı Kütüphaneleri

İş Parçacığı Kütüphaneleri

POSIX Pthreads

İş Parçacığı Kütüphaneleri · Kodu adım adım çalıştır

Pthreads: Oluştur ve Bekle

int toplam;           /* paylaşılan */
void *runner(void *param) {
  int ust = atoi(param);
  toplam = 0;
  for (int i = 1; i <= ust; i++)
    toplam += i;
  pthread_exit(0);
}
int main(void) {
  pthread_t tid;
  pthread_create(&tid, NULL, runner, "5");
  pthread_join(tid, NULL);
  printf("toplam = %d\n", toplam);
  return 0;
}

Silberschatz Şekil 4.11'den uyarlanmıştır; #include <pthread.h>, <stdio.h>, <stdlib.h> satırları gösterilmedi.

İş Parçacığı Kütüphaneleri

Birden Çok İş Parçacığı

#define N 4
long kismi[N];           /* her biri kendi hücresine */

void *topla(void *arg) {
  long k = (long)arg;    /* 0 .. N-1 */
  for (long i = k*250 + 1; i <= (k+1)*250; i++)
    kismi[k] += i;
  return NULL;
}
int main(void) {
  pthread_t t[N];
  for (long k = 0; k < N; k++)
    pthread_create(&t[k], NULL, topla, (void *)k);
  long toplam = 0;
  for (int k = 0; k < N; k++) {
    pthread_join(t[k], NULL);
    toplam += kismi[k];
  }
  printf("%ld\n", toplam);  /* 500500 */
}

İş Parçacığı Kütüphaneleri · Kodu adım adım çalıştır

Java: Thread, start ve join

public class Topla {
  static int toplam = 0;
  public static void main(String[] a)
      throws InterruptedException {
    Thread t = new Thread(() -> {
      for (int i = 1; i <= 5; i++) toplam += i;
    });
    t.start();
    System.out.println("main: bekliyor");
    t.join();
    System.out.println("toplam = " + toplam);
  }
}

JDK 21 ile derlenip çalıştırıldı; çıktı her seferinde aynıdır.

İş Parçacığı Kütüphaneleri

Java 21: Sanal İş Parçacıkları

import java.time.Duration;
import java.util.concurrent.*;
import java.util.stream.IntStream;

public class Sanal {
  public static void main(String[] args) {
    try (var ex = Executors.newVirtualThreadPerTaskExecutor()) {
      IntStream.range(0, 10_000).forEach(i ->
        ex.submit(() -> {
          Thread.sleep(Duration.ofSeconds(1));
          return i;
        }));
    }  // close(): tüm görevleri bekler
    System.out.println("bitti");
  }
}

Örtük İş Parçacığı

Örtük İş Parçacığı (Implicit Threading)

• İş parçacığı sayısı yüzlere çıkınca doğruluğu elle yönetmek zorlaşır.
• Çözüm: programcı görevleri (paralel çalışabilecek işleri) belirtir; iş parçacıklarını derleyici ve çalışma zamanı kütüphaneleri oluşturur ve yönetir.

Örtük İş Parçacığı

İş Parçacığı Havuzu

Faydalar: daha hızlı hizmet, sistemi aşırı iş parçacığından koruma, görevin nasıl çalıştırılacağını (gecikmeli, periyodik) görevden ayırma.

Örtük İş Parçacığı

Java ExecutorService

ExecutorService havuz = Executors.newFixedThreadPool(2);
List<Future<Integer>> sonuclar = new ArrayList<>();
for (int g = 1; g <= 4; g++) {
  final int n = g;
  sonuclar.add(havuz.submit(() -> n * n));
}
int toplam = 0;
for (Future<Integer> f : sonuclar)
  toplam += f.get();      // sonucu bekler
System.out.println("toplam = " + toplam);
havuz.shutdown();

toplam = 30

Örtük İş Parçacığı

Fork-Join

Örtük İş Parçacığı

Java ForkJoinPool ve İş Çalma

class Toplam extends RecursiveTask<Long> {
  protected Long compute() {
    if (son - bas <= ESIK) {      // küçükse doğrudan
      long s = 0;
      for (int i = bas; i < son; i++) s += a[i];
      return s;
    }
    int orta = (bas + son) / 2;
    Toplam sol = new Toplam(a, bas, orta);
    Toplam sag = new Toplam(a, orta, son);
    sol.fork();                   // asenkron başlat
    long sagSonuc = sag.compute();
    return sol.join() + sagSonuc;
  }
}
long s = ForkJoinPool.commonPool()
           .invoke(new Toplam(a, 0, a.length));

Örtük İş Parçacığı

OpenMP

#include <omp.h>
#include <stdio.h>

int main(void) {
  #pragma omp parallel
  printf("merhaba, ben %d\n", omp_get_thread_num());

  double a[1000], b[1000], c[1000], s = 0;
  /* ... a ve b doldurulur ... */
  #pragma omp parallel for reduction(+:s)
  for (int i = 0; i < 1000; i++) {
    c[i] = a[i] + b[i];
    s += c[i];
  }
  return 0;
}

Örtük İş Parçacığı

Grand Central Dispatch ve oneTBB

dispatch_queue_t q = dispatch_get_global_queue(
                       QOS_CLASS_USER_INITIATED, 0);
dispatch_async(q, ^{ puts("Ben bir bloğum"); });

İş Parçacığı Sorunları

fork() ve exec() İş Parçacıklarıyla

• Bazı UNIX'ler iki fork sürümü sunmuştu (tüm iş parçacıklarını ya da yalnızca çağıranı kopyalayan). POSIX: yalnızca çağıran iş parçacığı kopyalanır.
• fork'tan hemen sonra exec çağrılacaksa bu doğrudur: yeni program zaten tüm adres alanını değiştirir.
• Çocukta exec'e kadar yalnızca async-signal-safe fonksiyonlar güvenlidir; pthread_atfork kilitleri düzenlemeye yarar. Çoğu zaman posix_spawn daha iyi seçimdir.

İş Parçacığı Sorunları

Sinyal İşleme

İş Parçacığı Sorunları

İş Parçacığı İptali

İş Parçacığı Sorunları

Global Değişken Çakışması

• Tek iş parçacıklı programlar için tasarlanmış global değişkenler (UNIX errno) iş parçacıkları arasında çakışır.
• Çözüm: değişkeni yasaklamak, ya da her iş parçacığına kendi kopyasını vermek. Bugünkü C kütüphanelerinde errno iş parçacığına yereldir.

İş Parçacığı Sorunları

İş Parçacığına Yerel Depolama (TLS)

static ThreadLocal<Integer> no =
  ThreadLocal.withInitial(() -> 0);

İş Parçacığı Sorunları

Yeniden Girilir ve İş Parçacığı Güvenli Kod

İş Parçacığı Sorunları

Yarış Koşulu: sayac++

LOAD  R, sayac
ADD   R, 1
STORE sayac, R

İş Parçacığı Sorunları

Yarışı Gözlemlemek (Java)

public class Yaris {
  static int sayac = 0;
  public static void main(String[] a) throws Exception {
    Runnable is = () -> {
      for (int i = 0; i < 1_000_000; i++) sayac++;
    };
    Thread t1 = new Thread(is), t2 = new Thread(is);
    t1.start(); t2.start();
    t1.join();  t2.join();
    System.out.println("sayac = " + sayac);
  }
}

sayac = 1456465
sayac = 1544210
sayac = 1910165

İş Parçacığı Sorunları

Linux'ta İş Parçacıkları: clone()

Senkronizasyona Giriş

Pthreads Mutex ve Koşul Değişkeni

pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer = 0;          /* tek hücreli tampon */

void *producer(void *ptr) {
  for (int i = 1; i <= MAX; i++) {
    pthread_mutex_lock(&the_mutex);
    while (buffer != 0)    /* dolu: bekle */
      pthread_cond_wait(&condp, &the_mutex);
    buffer = i;            /* ürünü koy */
    pthread_cond_signal(&condc);
    pthread_mutex_unlock(&the_mutex);
  }
  pthread_exit(0);
}

void *consumer(void *ptr) {
  for (int i = 1; i <= MAX; i++) {
    pthread_mutex_lock(&the_mutex);
    while (buffer == 0)    /* boş: bekle */
      pthread_cond_wait(&condc, &the_mutex);
    buffer = 0;            /* ürünü al */
    pthread_cond_signal(&condp);
    pthread_mutex_unlock(&the_mutex);
  }
  pthread_exit(0);
}

Senkronizasyona Giriş

Üretici–Tüketici Adım Adım

Tanenbaum & Bos, Şekil 2-32'den uyarlanmıştır. Semafor, monitör ve kilitlenme ayrıntıları Bölüm 6 ve 7'de.

Özet

Avantajlar ve Dezavantajlar

Özet

Kontrol Soruları

1. Yazmaç değerleri, heap, global değişkenler ve yığından hangileri bir sürecin iş parçacıkları arasında paylaşılır?
2. Tek çekirdekli bir sistemde eşzamanlılık var mıdır? Paralellik var mıdır?
3. Programın %80'i paralelleştirilebiliyor. 8 çekirdekte hızlanma ve teorik üst sınır nedir?
4. Çoktan bire modelde bir iş parçacığı read() ile bloke olursa ne olur? Neden çok çekirdekten yararlanamaz?
5. İki iş parçacığı başlangıçta 0 olan sayac'ı birer kez artırıyor. Olası son değerler nelerdir?
6. İş parçacığı havuzunun yeni iş parçacığı oluşturmaya göre iki avantajını yazın.
7. Ertelenmiş ve asenkron iptal arasındaki fark nedir? Neden ertelenmiş tercih edilir?
8. POSIX'te üç iş parçacıklı bir süreçte fork() sonrası çocukta kaç iş parçacığı vardır?

Özet

Kaynaklar

• A. Silberschatz, P. B. Galvin, G. Gagne, Operating System Concepts, 10. baskı, Wiley, 2018 — Bölüm 4: Threads & Concurrency.
• A. S. Tanenbaum, H. Bos, Modern Operating Systems, 4. baskı (2014) / 5. baskı (2022), Pearson — Bölüm 2.2: Threads.
• R. H. Arpaci-Dusseau, A. C. Arpaci-Dusseau, Operating Systems: Three Easy Pieces (OSTEP), ostep.org — “Concurrency: An Introduction”, “Thread API”.
• POSIX.1-2017 (IEEE Std 1003.1), pthreads(7) ve clone(2) Linux kılavuz sayfaları.
• JEP 444: Virtual Threads (Java 21); OpenMP 5.2 belirtimi.