Giriş

Öğrenme Çıktıları

Süreç Kavramı

Süreç Nedir?

Süreç Kavramı

Bellekte Süreç Yerleşimi

Süreç Kavramı

Değişkenler Nereye Yerleşir?

#include <stdlib.h>
int sayac = 5;    /* data */
int tablo[1000];  /* bss */

int main(int argc, char *argv[]) {
    int yerel = 3;
    static int adet;
    int *p = malloc(4 * sizeof *p);
    p[0] = yerel + sayac;
    free(p);
    return 0;
}

Süreç Kavramı

Sözde Paralellik ve Çoklu Programlama

• Tek çekirdekte herhangi bir anda yalnızca bir süreç yürütülür; çizelgeleyici süreçler arasında hızla geçiş yaparak sözde paralellik yaratır.
• Geçişler tipik olarak birkaç milisaniyelik zaman dilimleriyle olur (Linux CFS'de hedef gecikme birkaç ms – onlarca ms); kullanıcıya tüm süreçler aynı anda çalışıyor gibi görünür.
• Kullanıcı için faydalıdır; ancak yönetimi zordur: süreçlerin ne zaman kesileceği öngörülemez, zaman varsayımı yapılmamalıdır.

Süreç Kavramı

Eşzamanlılık ve Paralellik

Süreç Kavramı

Örnek: Chrome'un Çok Süreçli Mimarisi

Süreç Oluşturma

Süreç Oluşturma

Süreç Oluşturma

Süreç Ağacı

Linux açılışta PID 1 olarak systemd (ya da başka bir init) çalıştırır; PID 2 kthreadd çekirdek iş parçacıklarının atasıdır. PID değerleri örnektir.

Süreç Oluşturma

Ata ve Çocuk İlişkisi

Süreç Oluşturma

fork(): Bir Çağrı, İki Dönüş

pid_t pid = fork();
if (pid < 0)        { perror("fork"); exit(1); }
else if (pid == 0)  { /* çocuk: fork 0 döndürdü */ }
else                { /* ata: pid = çocuğun PID'i */ }

Süreç Oluşturma · Kodu adım adım çalıştır

Kod İzleme: fork() + wait()

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void) {
    int x = 10;
    pid_t pid = fork();
    if (pid == 0) {
        x = x + 5;
        printf("çocuk: x=%d\n", x);
        return 0;
    }
    wait(NULL);
    printf("ata: x=%d\n", x);
    return 0;
}

Süreç Oluşturma

wait() Olmadan Çıktı Sırası Belirsizdir

pid_t pid = fork();
if (pid == 0) printf("çocuk\n");
else          printf("ata\n");

Süreç Oluşturma

exec() Ailesi

Hepsi sonunda execve() sistem çağrısını kullanır. Başarılı exec geri dönmez; dönüyorsa hata olmuştur.

Süreç Oluşturma · Kodu adım adım çalıştır

Kod İzleme: fork + exec + waitpid

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void) {
  pid_t pid = fork();
  if (pid == 0) {
    execlp("ls", "ls", "-l", NULL);
    perror("execlp");  /* hata */
    exit(1);
  }
  int st;
  waitpid(pid, &st, 0);
  printf("bitti: %d\n", WEXITSTATUS(st));
  return 0;
}

Süreç Oluşturma

Kabuk Döngüsü: fork → exec → wait

Süreç Sonlandırma

Süreç Sonlandırma

• exit(durum): C kütüphanesi tamponları boşaltır, atexit işleyicilerini çalıştırır, sonra _exit sistem çağrısı.
• abort(): çağıran süreç kendine SIGABRT gönderir, anormal biter (çekirdek dökümü oluşabilir). Başka süreci sonlandırmak için kill() kullanılır.
• Çekirdek sürecin belleğini, açık dosyalarını ve diğer kaynaklarını geri alır; çıkış durumu ata wait() çağırana kadar saklanır.
• Bazı sistemlerde ata sonlanınca çocuklar da sonlandırılır (basamaklı sonlandırma); UNIX'te ise çocuklar yaşamaya devam eder.

Süreç Sonlandırma

Ölümcül Hatalar

Süreç Sonlandırma

Sinyallerle Sonlandırma: kill, pkill, killall

$ ps -e | grep yaz
 1234 ?  00:00:03 yaz
$ kill 1234       # SIGTERM
$ kill -9 1234    # SIGKILL
$ pkill yaz       # ada göre
$ killall yaz

Süreç Sonlandırma

Zombi ve Yetim Süreçler

Zombi kaynak harcamaz ama PID tüketir; wait çağırmayan uzun ömürlü bir sunucu binlerce zombi biriktirip PID’leri tüketebilir. Çözüm: wait/waitpid ya da SIGCHLD işleyicisi.

Durumlar ve PCB

Süreç Durumları (Beş Durum Modeli)

Bir çekirdekte aynı anda yalnız bir süreç çalışıyor olabilir; pek çoğu hazır ya da bekliyor durumundadır.

Durumlar ve PCB

Durum Geçişleri Adım Adım

Bekliyor → Çalışıyor geçişi yoktur: olay tamamlanan süreç önce hazır kuyruğuna girer.

Durumlar ve PCB

Linux'ta Süreç Durumları

$ ps -eo pid,stat,comm
  PID STAT COMMAND
    1 Ss   systemd
  890 Ss   sshd
 2105 Ss   bash
 2241 R+   ps
 2307 Z    yaz <defunct>

Durumlar ve PCB

Süreç Kontrol Bloğu (PCB)

Durumlar ve PCB

PCB Alanları (Tanenbaum'a göre)

Durumlar ve PCB

Linux'ta PCB: task_struct

struct task_struct {          /* <linux/sched.h> */
    pid_t pid;                     /* süreç kimliği */
    unsigned int __state;          /* süreç durumu */
    int prio;                      /* öncelik */
    struct sched_entity se;        /* CFS/EEVDF bilgisi */
    struct task_struct *parent;    /* ata süreç */
    struct list_head children;     /* çocuklar */
    struct files_struct *files;    /* açık dosyalar */
    struct mm_struct *mm;          /* adres uzayı */
    /* ... yüzlerce alan daha ... */
};

Çizelgeleme

Hazır ve Bekleme Kuyrukları

• Çizelgeleyici (scheduler) hazır süreçler arasından CPU'ya geçecek olanı seçer; amaç CPU'yu meşgul tutmak ve kullanıcıya hızlı yanıt vermektir.
• Hazır kuyruğu: bellekte olup yürütülmeyi bekleyen süreçler. Bekleme kuyrukları: belirli bir olayı (G/Ç bitişi, çocuğun sonlanması...) bekleyenler; her olay türü için ayrı kuyruk vardır.
• Linux her çekirdeğe ayrı bir çalışma kuyruğu (runqueue) atar; CFS/EEVDF bunu kırmızı-siyah ağaçla tutar. Algoritmalar Bölüm 5'te.

Çizelgeleme

Kuyruk Diyagramı: Bir Sürecin Yolculuğu

Çizelgeleme

CPU'ya Bağlı ve G/Ç'ye Bağlı Süreçler

• CPU'lar disklerden çok daha hızlı geliştiği için süreçler giderek G/Ç'ye bağlı hâle gelir.
• G/Ç'ye bağlı süreç hazır olunca hemen CPU almalı (hızlı bağlam anahtarlama); iki tür dengeli karıştırılmalıdır.

Çizelgeleme

Çoklu Programlamanın Modellenmesi

Çizelgeleme

Bağlam Anahtarlama (Context Switch)

Çizelgeleme

Bağlam Anahtarlamanın Maliyeti

Çizelgeleme

Kesmenin Ele Alınması

Bir G/Ç kesmesi geldiğinde işletim sisteminin en alt katmanında olanlar (Tanenbaum):

Süreçler Arası İletişim

Süreçler Arası İletişim

Süreçler Arası İletişim

Paylaşımlı Bellek ve Mesaj Geçirme

Süreçler Arası İletişim

POSIX Paylaşımlı Bellek

/* üretici */
int fd = shm_open("/os03", O_CREAT|O_RDWR, 0600);
ftruncate(fd, 4096);
char *p = mmap(NULL, 4096, PROT_READ|PROT_WRITE,
               MAP_SHARED, fd, 0);
strcpy(p, "merhaba");   /* doğrudan yaz */

/* tüketici (başka süreç) */
int fd = shm_open("/os03", O_RDONLY, 0);
char *p = mmap(NULL, 4096, PROT_READ,
               MAP_SHARED, fd, 0);
printf("%s\n", p);
shm_unlink("/os03");    /* sil */

Süreçler Arası İletişim

Mesaj Geçirme Tasarımı

İki temel işlem: send(mesaj) ve receive(mesaj). Önce bir iletişim bağı kurulmalıdır.

Süreçler Arası İletişim

Doğrudan ve Dolaylı İletişim

Düzeltme: eski sunumda ikinci slayt da “Doğrudan İletişim” başlığını taşıyordu; posta kutusu modeli dolaylı iletişimdir.

Süreçler Arası İletişim

Borular (Pipes)

Süreçler Arası İletişim · Kodu adım adım çalıştır

Kod İzleme: pipe() + fork()

int main(void) {
  int fd[2];
  char buf[32];
  pipe(fd);
  pid_t pid = fork();
  if (pid == 0) {   /* çocuk: okur */
    close(fd[1]);
    ssize_t n = read(fd[0], buf, sizeof buf - 1);
    buf[n] = '\0';
    printf("çocuk aldı: %s\n", buf);
    close(fd[0]);
    return 0;
  }
  close(fd[0]);     /* ata: yazar */
  write(fd[1], "merhaba", 7);
  close(fd[1]);
  wait(NULL);
  return 0;
}

Süreçler Arası İletişim

Kabukta Boru Hattı: ls | wc -l

int fd[2]; pipe(fd);
if (fork() == 0) { dup2(fd[1], 1); close(fd[0]); close(fd[1]);
                   execlp("ls", "ls", NULL); }
if (fork() == 0) { dup2(fd[0], 0); close(fd[0]); close(fd[1]);
                   execlp("wc", "wc", "-l", NULL); }
close(fd[0]); close(fd[1]); wait(NULL); wait(NULL);

Hata denetimleri kısalık için çıkarıldı. dup2(eski, yeni) yeni tanımlayıcıyı eskinin kopyası yapar; programlar stdin/stdout ile çalıştığı için boruyu fark etmez.

Süreçler Arası İletişim

Soketler

Eşzamanlılık Sorunları

Yarış Durumu: Yazıcı Biriktirme Dizini

Yarış durumu (race condition): iki ya da daha çok süreç paylaşılan veriye eriştiğinde nihai sonucun yürütme sırasına bağlı olması.

Eşzamanlılık Sorunları

Tekrarlanamaz Yürütme (Non-reproducible)

/* Süreç 1 */     /* Süreç 2 */
repeat           repeat
  n = n + 1;       print(n);
                   n = 0;

Eşzamanlılık Sorunları

Kritik Bölge ve Karşılıklı Dışlama

Eşzamanlılık Sorunları · Kodu adım adım çalıştır

Peterson Çözümü

bool flag[2] = { false, false };
int turn;

void enter(int i) {
    int j = 1 - i;
    flag[i] = true;   /* girmek istiyorum */
    turn = j;         /* ama önce sen */
    while (flag[j] && turn == j)
        ;             /* meşgul bekle */
}
void leave(int i) {
    flag[i] = false;
}

Uyarı: modern CPU ve derleyiciler yükleme/saklama sırasını değiştirebilir; Peterson ancak _Atomic değişkenler (sıralı tutarlılık) ya da bellek bariyerleriyle doğru çalışır. Pratikte donanım atomik komutları ve kilitler kullanılır.

Eşzamanlılık Sorunları

Meşgul Bekleme ve Uyu/Uyandır

Eşzamanlılık Sorunları

Üretici-Tüketici (Sınırlı Tampon) Problemi

• İki süreç sabit boyutlu (N) bir tamponu paylaşır: üretici yazar, tüketici okur.
• Sınırlı tampon: doluysa üretici, boşsa tüketici bekler. Sınırsız tampon: yalnız tüketici bekler.

Eşzamanlılık Sorunları · Kodu adım adım çalıştır

Ölümcül Yarış: Kayıp Uyandırma

#define N 100
int count = 0;
void producer(void) {
    while (TRUE) {
        item = produce_item();
        if (count == N) sleep();
        insert_item(item);
        count = count + 1;
        if (count == 1) wakeup(consumer);
    }
}
void consumer(void) {
    while (TRUE) {
        if (count == 0) sleep();
        item = remove_item();
        count = count - 1;
        if (count == N - 1) wakeup(producer);
        consume_item(item);
    }
}

Eşzamanlılık Sorunları

Semaforlarla Üretici-Tüketici

semaphore mutex = 1, empty = N, full = 0;
void producer(void) {               void consumer(void) {
  while (TRUE) {                      while (TRUE) {
    item = produce_item();              down(&full);
    down(&empty);                       down(&mutex);
    down(&mutex);                       item = remove_item();
    insert_item(item);                  up(&mutex);
    up(&mutex);                         up(&empty);
    up(&full);                          consume_item(item);
  }                                   }
}                                   }

Semafor, mutex ve monitörler Bölüm 6'da ayrıntılı işlenecektir.

Eşzamanlılık Sorunları

Yemek Yiyen Filozoflar (Dining Philosophers)

Dijkstra (1965): sınırlı kaynakların (G/Ç aygıtları gibi) birden çok süreç arasında kilitlenmeden paylaşılmasını modeller.

Eşzamanlılık Sorunları

Filozoflar: Durum Dizisi ile Çözüm

#define N 5
#define LEFT  (i + N - 1) % N
#define RIGHT (i + 1) % N
int state[N];          /* THINKING, HUNGRY, EATING */
semaphore mutex = 1;   /* state[] için */
semaphore s[N];        /* filozof başına, başta 0 */

void take_forks(int i) {           void test(int i) {
    down(&mutex);                      if (state[i] == HUNGRY &&
    state[i] = HUNGRY;                     state[LEFT] != EATING &&
    test(i);    /* 2 çatal al */           state[RIGHT] != EATING) {
    up(&mutex);                            state[i] = EATING;
    down(&s[i]); /* alamadıysa */          up(&s[i]);
}                                      }
void put_forks(int i) {            }
    down(&mutex);
    state[i] = THINKING;           void philosopher(int i) {
    test(LEFT);  /* komşular */        while (TRUE) {
    test(RIGHT); /* yiyebilir mi? */       think(); take_forks(i);
    up(&mutex);                            eat();   put_forks(i);
}                                      }
                                   }

Filozof ancak iki komşusu da yemiyorsa yer; çatallar tek tek değil, durum dizisi üzerinden birlikte alınır. Kilitlenme olmaz ve en fazla ⌊N/2⌋ = 2 filozof aynı anda yer.

Eşzamanlılık Sorunları

Okur-Yazar Problemi

semaphore mutex = 1;   /* rc için */          void reader(void) {
semaphore db = 1;      /* veritabanı için */    while (TRUE) {
int rc = 0;            /* okuyan sayısı */          down(&mutex);
                                                  rc = rc + 1;
void writer(void) {                               if (rc == 1) down(&db);
  while (TRUE) {                                  up(&mutex);
    think_up_data();                              read_data_base();
    down(&db);                                    down(&mutex);
    write_data_base();                            rc = rc - 1;
    up(&db);                                      if (rc == 0) up(&db);
  }                                               up(&mutex);
}                                                 use_data_read();
                                                }
                                              }

Mobil Sistemler

Mobil Sistemlerde Çoklu Görev

Kısıtların nedeni sınırlı bellek ve pil. Eski belgelerdeki “arka plan” ve “boş” süreçler bugün önbellekteki (cached) grupta toplanır; bellek azalınca lmkd alttan başlayarak sonlandırır.

Özet

Özet

Özet

Kontrol Soruları

Özet

Kaynaklar

• A. Silberschatz, P. B. Galvin, G. Gagne, Operating System Concepts, 10. baskı, Wiley, 2018 — Bölüm 3: Processes.
• A. S. Tanenbaum, H. Bos, Modern Operating Systems, 4. baskı (5. baskı 2023), Pearson — Bölüm 2: Processes and Threads.
• R. H. Arpaci-Dusseau, A. C. Arpaci-Dusseau, Operating Systems: Three Easy Pieces (OSTEP), pages.cs.wisc.edu/~remzi/OSTEP — Processes, Process API.
• Linux kılavuz sayfaları: fork(2), execve(2), wait(2), pipe(7), signal(7), shm_overview(7).
• Chromium Projects, “Multi-process Architecture” ve “Site Isolation” belgeleri; Android Developers, “Processes and app lifecycle”.