Java'da multithreading nasıl çalışır?

Question

Accepted Answer

**Multithreading**, bir Java programının birden fazla thread'i eşzamanlı olarak çalıştırmasını sağlar, parallelizm (birden fazla CPU çekirdeğini kullanma) ve yanıt verme yeteneği (engellenmeden çalışma) sağlar. Java thread'ler için birinci sınıf destek sunar — ancak paylaşılan değiştirilebilir durum karmaşıklığı (race conditions) ortaya çıkarır ve bunu dikkatle yönetmek gerekir. ## Thread'leri oluşturma ```java // 1. Implement Runnable (preferred — separates task from thread) Runnable task = () -> System.out.println("running on " + Thread.currentThread().getName()); Thread t = new Thread(task); t.start(); // start() runs it on a NEW thread (run() would run on the CURRENT thread!) // 2. modern: use an ExecutorService instead of raw threads ExecutorService executor = Executors.newFixedThreadPool(4); executor.submit(task); ``` **Önemli hata:** `start()` çağırın (yeni bir thread oluşturur), `run()` değil (sadece kodu geçerli thread'de senkron olarak çalıştırır). ## Temel problem: race conditions ```java // ❌ multiple threads modifying shared state → unpredictable results class Counter { int count = 0; void increment() { count++; } // NOT atomic: read → add → write (can interleave) } // 1000 threads each incrementing 1000 times → final count is often < 1,000,000! ``` `count++` aslında üç işlemdir (okuma, artırma, yazma). Thread'ler iç içe geçtiğinde, güncellemeler kaybolur — bir **race condition**. Bu, eşzamanlılığın temel sorunu: birden fazla thread tarafından koordinasyon olmaksızın erişilen paylaşılan değiştirilebilir durum. ## Güvenli paylaşılan durum için çözümler ```java // 1. synchronized — only one thread in the method/block at a time (a lock) synchronized void increment() { count++; } // 2. atomic classes — lock-free atomic operations AtomicInteger count = new AtomicInteger(0); count.incrementAndGet(); // atomic, thread-safe, efficient // 3. concurrent collections — built for multi-threaded access ConcurrentHashMap map = new ConcurrentHashMap<>(); // 4. immutability — immutable objects are inherently thread-safe (nothing to corrupt) ``` ## Thread koordinasyonu ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## Modern yaklaşım: ham thread'leri yönetmeyin ```text ✓ Use ExecutorService / thread pools (not new Thread() per task — expensive) ✓ Use CompletableFuture for async composition ✓ Use concurrent collections and atomic classes over manual synchronization ✓ Java 21+ adds Virtual Threads — millions of lightweight threads for I/O concurrency ``` ## Neden önemli Multithreading, Java programlarının birden fazla çekirdeği kullanmasını ve duyarlı kalmasını sağlar, ancak aynı zamanda doğru şekilde uygulaması en zor alanlardan biridir — senkronize edilmeyen paylaşılan değiştirilebilir durumdan gelen **race conditions**, aralıklı ve yeniden üretilmesi zor olan hatalara neden olur. Thread'lerin nasıl çalıştığını (`start()` vs `run()`), race condition'ın temel sorununu (neden `count++` güvenli değildir) ve güvenliği sağlamak için araçları (`synchronized`, atomic sınıflar, concurrent koleksiyonlar, değişmezlik) anlamak, doğru eşzamanlı kod yazması için gereklidir. Modern en iyi uygulama, ham thread yönetimi yerine daha yüksek seviye soyutlamaları (ExecutorService, CompletableFuture, sanal thread'ler) tercih eder. Bu, sunucu tarafı ve yüksek performanslı Java için kritik bilgidir ve yetkin geliştiricileri uzman geliştiricilerden ayıran derin, sıkça test edilen bir konudur.