• Thread yapıcısına parametre olarak Runnable nesne verilir.
• start() çağrılarak iş parçacığı başlatılır.
• run() doğrudan çağrılmaz: aksi takdirde kod, çağıranın iş parçacığında çalışır.

main devam ediyor
Worker çalışıyor: Thread-0

Satırların sırası çalıştırmadan çalıştırmaya değişebilir: start() döner dönmez main devam eder; yeni iş parçacığının ne zaman çalışacağını zamanlayıcı belirler.

• İş parçacığı, Thread sınıfı genişletilerek (extends) de oluşturulabilir.
• Runnable gerçeklemek yerine Thread alt sınıfı yazılır; Thread zaten Runnable'ı gerçekler.
• Nesnenin kendisi bir Thread olduğu için doğrudan w.start() ve getName() çağrılır.

main devam ediyor
Worker çalışıyor: Thread-0

Sıra yine değişebilir.

public class StartRunFarki {
    public static void main(String[] args)
            throws InterruptedException {
        Thread t = new Thread(() -> {
            String ad = Thread.currentThread().getName();
            System.out.println("run() içinde: " + ad);
        });
        t.run();     // YANLIŞ: main çalıştırır
        t.start();   // DOĞRU: yeni iş parçacığı
        t.join();
    }
}

Ata sınıfından merhaba
run(): Thread-0

• Worker hem Ata'nın metotlarını kalıtır hem de bir iş parçacığında çalışabilir.
• Kendi start() metodumuz new Thread(this) ile kendini bir Thread'e verir.
• this, Runnable türündendir; Thread yapıcısı bunu kabul eder.

1) Runnable sınıfı
2) Thread alt sınıfı
3) Lambda

Her start()'tan hemen sonra join() geldiği için çıktı sırası sabittir. static class: başka sınıfın içinde tanımlanan sınıf.

public class JoinOrnegi {
    static long sonuc = 0;
    public static void main(String[] args)
            throws InterruptedException {
        Thread hesap = new Thread(() -> {
            long toplam = 0;
            for (int i = 1; i <= 1_000_000; i++) {
                toplam += i;
            }
            sonuc = toplam;
        });
        hesap.start();
        System.out.println("join öncesi : " + sonuc);
        hesap.join();   // hesap bitene kadar bekle
        System.out.println("join sonrası: " + sonuc);
    }
}

join öncesi : 0
join sonrası: 500000500000

join() olmadan main, hesap bitmeden sonuc'u okur: 0 görür. join() sonrası hesap kesinlikle bitmiştir ve yazdığı değer görünür.

sleep ve join, InterruptedException fırlatabilir: yakalanmalı ya da throws ile bildirilmelidir.

public class DaemonOrnegi {
    public static void main(String[] args)
            throws InterruptedException {
        Thread saat = new Thread(() -> {
            int s = 0;
            while (true) {
                System.out.println("tik " + s++);
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    return;
                }
            }
        });
        saat.setDaemon(true);   // start()'tan ÖNCE
        saat.start();
        Thread.sleep(1000);
        System.out.println("main bitti, JVM kapanıyor");
    }
}

tik 0
tik 1
tik 2
tik 3
main bitti, JVM kapanıyor

• JVM, daemon olmayan tüm iş parçacıkları bitince kapanır; daemon iş parçacıklarının bitmesi beklenmez.
• saat sonsuz döngüde olsa da main bitince program sonlanır.
• setDaemon(true), start()'tan önce çağrılmalı; sonra çağrılırsa IllegalThreadStateException.

class Worker extends Thread {
    private volatile boolean flag = false;
    public void finish() { flag = true; }
    public void run() {
        while (!flag) {
            System.out.println("çalışıyor...");
            try { Thread.sleep(100); }
            catch (InterruptedException e) { return; }
        }
        System.out.println("bayrak görüldü, bitiyor");
    }
}
public class BayrakDurdurma {
    public static void main(String[] args)
            throws InterruptedException {
        Worker w = new Worker();
        w.start();
        Thread.sleep(350);
        w.finish();   // bayrağı kaldır
        w.join();     // bitmesini bekle
        System.out.println("main: işçi durdu");
    }
}

çalışıyor...
çalışıyor...
çalışıyor...
çalışıyor...
bayrak görüldü, bitiyor
main: işçi durdu

• finish() yalnızca bayrağı kaldırır; iş parçacığı döngünün başında bunu görür ve run()'dan kendisi çıkar.
• main 350 ms uyurken işçi 0, 100, 200, 300 ms'de dört kez yazdı.
• volatile olmasaydı işçi bayrağın değiştiğini hiç görmeyebilirdi (bkz. Görünürlük).

class Worker implements Runnable {
    private volatile Thread thread;
    public void start() {
        thread = new Thread(this);
        thread.start();
    }
    public void finish() { thread = null; }
    public void run() {
        Thread ben = Thread.currentThread();
        while (thread == ben) {   // ... iş ...
        }
        System.out.println("run() bitti");
    }
}
public class ReferansDurdurma {
    public static void main(String[] args) throws Exception {
        Worker w = new Worker();
        w.start();
        Thread.sleep(200);
        w.finish();
        Thread.sleep(200);
        System.out.println("main: bitti");
    }
}

run() bitti
main: bitti

• Sınıf Runnable gerçekler; çalışan Thread nesnesi volatile bir alanda tutulur.
• Döngü, alan hâlâ kendi iş parçacığını gösterdikçe sürer: Thread.currentThread() ile karşılaştırılır.
• finish() alanı null yapar; koşul bozulur, run() biter.
• currentThread() static bir Thread metodudur; Thread'i genişletmeyen sınıfta Thread. ön eki şarttır.

public class YarisDurumu {
    static int sayac = 0;   // paylaşılan veri
    public static void main(String[] args)
            throws InterruptedException {
        Runnable arttir = () -> {
            for (int i = 0; i < 100_000; i++) {
                sayac++;   // oku, 1 ekle, yaz: atomik DEĞİL
            }
        };
        Thread t1 = new Thread(arttir);
        Thread t2 = new Thread(arttir);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Beklenen: 200000");
        System.out.println("Bulunan : " + sayac);
    }
}

Beklenen: 200000
Bulunan : 138001

Beklenen: 200000
Bulunan : 135352

Beklenen: 200000
Bulunan : 136776

Her çalıştırmada farklı ve 200000'den küçük bir sonuç: bazı artışlar kayboluyor.

class Sayac {
    private int deger = 0;
    public synchronized void arttir() { deger++; }
    public synchronized int getDeger() { return deger; }
}

public class SenkronSayac {
    public static void main(String[] args)
            throws InterruptedException {
        Sayac sayac = new Sayac();
        Runnable gorev = () -> {
            for (int i = 0; i < 100_000; i++) {
                sayac.arttir();
            }
        };
        Thread t1 = new Thread(gorev);
        Thread t2 = new Thread(gorev);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Sonuç: " + sayac.getDeger());
    }
}

Sonuç: 200000

• arttir() artık synchronized: oku–ekle–yaz adımları bölünmeden yapılır.
• Okuyan getDeger() da senkronize olmalı; yoksa güncel değeri görmesi garanti değildir.
• Bedeli: iş parçacıkları sırayla girer, biraz yavaşlar. Yalnızca paylaşılan veriyi koruyun.

class OncelikliKuyruk {
    private int[] veri;
    private int boyut;
    public OncelikliKuyruk(int n) { veri = new int[n]; }
    public synchronized void ekle(int o) {
        if (boyut == veri.length)
            throw new HeapFullException();
        veri[boyut++] = o;
    }
    public synchronized int cikar() {   // en küçüğü
        int enk = 0;
        for (int i = 1; i < boyut; i++) {
            if (veri[i] < veri[enk]) enk = i;
        }
        int sonuc = veri[enk];
        veri[enk] = veri[--boyut];
        return sonuc;
    }
    public synchronized String toString() {
        return Arrays.toString(Arrays.copyOf(veri, boyut));
    }
}

Tüm metotlar aynı monitörü (this) kullanır.

OncelikliKuyruk k =
        new OncelikliKuyruk(3);
k.ekle(5);
k.ekle(2);
k.ekle(8);
System.out.println(k);
int x = k.cikar();
System.out.println(x);
System.out.println(k);
k.ekle(1);
try {
    k.ekle(9);
} catch (HeapFullException e) {
    String m = e.getMessage();
    System.out.println(m);
}

[5, 2, 8]
2
[5, 8]
Kuyruk dolu

public class GorunurlukSorunu {
    static boolean dur = false;   // volatile DEĞİL!
    public static void main(String[] args)
            throws InterruptedException {
        Thread t = new Thread(() -> {
            long tur = 0;
            while (!dur) {
                tur++;
            }
            System.out.println("iş parçacığı durdu");
        });
        t.setDaemon(true);
        t.start();
        Thread.sleep(500);
        dur = true;
        System.out.println("main: dur = true");
        t.join(2000);   // en çok 2 sn bekle
        boolean canli = t.isAlive();
        System.out.println("hâlâ çalışıyor mu? " + canli);
    }
}

main: dur = true
hâlâ çalışıyor mu? true

main: dur = true
iş parçacığı durdu
hâlâ çalışıyor mu? false

volatile olmadan JIT derleyicisi dur'u bir kez okuyup döngüyü while (true) gibi çalıştırabilir: iş parçacığı değişikliği hiç görmez. Sonuç JVM'e göre değişebilir; doğruluk şansa bırakılmaz.

setDaemon(true): takılan iş parçacığı programın kapanmasını engellemesin diye.

public class Ornek {
    private final Lock kilit = new ReentrantLock();
    private int sayac = 0;
    public void calistir() {
        kilit.lock();
        try {
            // kritik bölge
            sayac++;
        } finally {
            kilit.unlock();
        }
    }
    public static void main(String[] args)
            throws InterruptedException {
        Ornek o = new Ornek();
        Runnable r = () -> {
            for (int i = 0; i < 100_000; i++) o.calistir();
        };
        Thread a = new Thread(r), b = new Thread(r);
        a.start(); b.start();
        a.join(); b.join();
        System.out.println("Sonuç: " + o.sayac);
    }
}

• Karmaşık senkronizasyon senaryoları için kullanılır.
• java.util.concurrent.locks paketindeki Lock arayüzü; ReentrantLock ve ReadWriteLock gelişmiş, özelleştirilebilir kilitler sunar.
• Esneklik ve performans iyileştirmeleri sağlar: denemeli, süreli, kesilebilir kilit alma.
• Kullanırken dikkatli olunmalı: kilidi siz açmalısınız.
• İçe aktarma: java.util.concurrent.locks.*

Sonuç: 200000

BLOCKED BLOCKED
Kilitlenmiş: 2

İki ya da daha fazla iş parçacığının, birbirinin tuttuğu kilidi sonsuza dek beklemesi. Kilitler farklı sırada alındığında oluşur. uyu(ms): sleep'i try-catch ile sarar.

BlockingQueue kuyruk = new BlockingQueue(2);
Thread uretici = new Thread(() -> {
    try {
        for (int i = 1; i <= 4; i++) {
            kuyruk.add(i);
            System.out.println("üretildi: " + i);
        }
    } catch (InterruptedException e) { }
});
Thread tuketici = new Thread(() -> {
    try {
        for (int i = 1; i <= 4; i++) {
            Thread.sleep(100);
            Object x = kuyruk.remove();
            System.out.println("tüketildi: " + x);
        }
    } catch (InterruptedException e) { }
});
uretici.start();
tuketici.start();
uretici.join();
tuketici.join();
System.out.println("kalan: " + kuyruk.getSize());

üretildi: 1
üretildi: 2
üretildi: 3
tüketildi: 1
üretildi: 4
tüketildi: 2
tüketildi: 3
tüketildi: 4
kalan: 0

Satırların sırası değişebilir. Burada “üretildi: 3”, “tüketildi: 1”den önce göründü: tüketici remove'dan döndükten sonra, yazdıramadan üretici çalıştı.

1 2 3 4 

Gerçek projelerde hazır java.util.concurrent.BlockingQueue gerçeklemeleri (ArrayBlockingQueue, LinkedBlockingQueue) tercih edilir; kendi sınıfımız mekanizmayı anlamak içindir.

public static void main(String[] args) {
    int parti = 3;
    Runnable eylem = () -> {
        System.out.println("Parti tamamlandı!");
    };
    CyclicBarrier bariyer =
            new CyclicBarrier(parti, eylem);
    for (int i = 0; i < parti; i++) {
        int no = i + 1;
        new Thread(() -> {
            try {
                System.out.println(no + " bekliyor");
                // iş parçacıklarını bekle
                bariyer.await();
                System.out.println(no + " devam ediyor");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
    }
}

• Bir grup iş parçacığını buluşma noktasında (barrier) bekletir; parti: beklenecek sayı.
• await(): parti dolana kadar bekle. Dolunca bariyer eylemi bir kez çalışır, herkes devam eder.
• İstisna, zaman aşımı ya da kesme bariyeri kırar: bekleyenler BrokenBarrierException alır.

1 bekliyor
2 bekliyor
3 bekliyor
Parti tamamlandı!
3 devam ediyor
1 devam ediyor
2 devam ediyor

static void takas(Exchanger<String> ex, String veri, int ms) {
    try {
        System.out.println("gönderiliyor: " + veri);
        Thread.sleep(ms);
        String alinan = ex.exchange(veri);   // karşıyı bekle
        System.out.println(veri + " sahibi aldı: " + alinan);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
public static void main(String[] args) {
    Exchanger<String> exchanger = new Exchanger<>();
    // İlk iş parçacığı "Veri 1" gönderir, 2 sn sonra
    new Thread(() -> takas(exchanger, "Veri 1", 2000)).start();
    // İkinci iş parçacığı "Veri 2" gönderir, 1 sn sonra
    new Thread(() -> takas(exchanger, "Veri 2", 1000)).start();

gönderiliyor: Veri 2
gönderiliyor: Veri 1
Veri 1 sahibi aldı: Veri 2
Veri 2 sahibi aldı: Veri 1

• İki iş parçacığının veri alışverişi için kullanılır; kilitten çok bir iletişim nesnesidir.
• exchange(veri), karşı taraf da exchange çağırana kadar bekler: “Veri 2” sahibi 1 sn bekledi.
• Buluşunca her biri ötekinin verisini alır.

public class AtomikSayac {
    public static void main(String[] args)
            throws InterruptedException {
        AtomicInteger sayac = new AtomicInteger(0);
        Runnable r = () -> {
            for (int i = 0; i < 100_000; i++) {
                sayac.incrementAndGet();   // atomik ++sayac
            }
        };
        Thread a = new Thread(r), b = new Thread(r);
        a.start(); b.start();
        a.join(); b.join();
        System.out.println("Sonuç: " + sayac.get());
        boolean b1 = sayac.compareAndSet(200000, 0);
        System.out.println(b1 + " " + sayac.get());
        boolean b2 = sayac.compareAndSet(5, 10);
        System.out.println(b2 + " " + sayac.get());
    }
}

Sonuç: 200000
true 0
false 0

• AtomicInteger, AtomicLong, AtomicBoolean…: kilitsiz, güvenli erişim.
• incrementAndGet() = atomik ++x; işlem yarıda kesilemez.
• Atomik nesne ≈ volatile alan + atomik compareAndSet.
• compareAndSet(beklenen, yeni): değer hâlâ beklenen ise yeni'yi yazar, true döner; değilse dokunmaz.

public class KesmeOrnegi {
    public static void main(String[] args)
            throws InterruptedException {
        Thread isci = new Thread(() -> {
            try {
                while (!Thread.interrupted()) {
                    // İş parçacığının çalışma mantığı
                    System.out.println("çalışıyor...");
                    Thread.sleep(400);
                }
            } catch (InterruptedException e) {
                System.out.println("İş parçacığı iptal edildi!");
            }
        });
        isci.start();
        Thread.sleep(1000);
        isci.interrupt();   // sleep() içindeyken kes
        isci.join();
        System.out.println("main: bitti");
    }
}

çalışıyor...
çalışıyor...
çalışıyor...
İş parçacığı iptal edildi!
main: bitti

• interrupt(): kesme isteği; iş parçacığı sleep/wait'teyse InterruptedException.
• Thread.interrupted() bayrağı okur ve temizler; isInterrupted() yalnızca okur.

public class HavuzOrnegi {
    static void gorev(int no) {
        String ad = Thread.currentThread().getName();
        System.out.println("Görev " + no + " -> " + ad);
    }
    public static void main(String[] args) throws Exception {
        ExecutorService havuz = Executors.newFixedThreadPool(2);
        for (int i = 1; i <= 4; i++) {
            int no = i;
            havuz.submit(() -> gorev(no));
        }
        // Callable: değer döndüren görev
        Future<Integer> f = havuz.submit(() -> 6 * 7);
        System.out.println("Callable sonucu: " + f.get());
        havuz.shutdown();   // yeni görev kabul etme
        havuz.awaitTermination(5, TimeUnit.SECONDS);
        System.out.println("Havuz kapandı");
    }
}

Java 21+: Executors.newVirtualThreadPerTaskExecutor() her göreve hafif bir sanal iş parçacığı (virtual thread) verir.

Görev 1 -> pool-1-thread-1
Görev 2 -> pool-1-thread-2
Görev 3 -> pool-1-thread-2
Görev 4 -> pool-1-thread-2
Callable sonucu: 42
Havuz kapandı

Görev 3 -> pool-1-thread-1
Görev 4 -> pool-1-thread-2

Callable değer döndürür; Future.get() sonucu bekler. shutdown() unutulursa havuzun iş parçacıkları programı açık tutar.