Eşzamanlılık (Concurrency), birden fazla görevin zaman içinde iç içe geçerek ilerlemesini ifade ederken; Paralellik (Parallelism), birden fazla görevin fiziksel olarak aynı anda, eş zamanlı olarak çalışmasını ifade eder. Java'daki `java.util.concurrent` paketi her ikisi için de güçlü araçlar sunar.

Genişletmek için tıkla ...

public class MyRunnable implements Runnable {
    private String taskName;

    public MyRunnable(String name) {
        this.taskName = name;
    }

    @Override
    public void run() {
        System.out.println("Görev " + taskName + " başlatıldı: " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000); // Görevin çalıştığını simüle et
        } catch (InterruptedException e) {
            System.out.println("Görev " + taskName + " kesintiye uğradı.");
            Thread.currentThread().interrupt();
        }
        System.out.println("Görev " + taskName + " tamamlandı: " + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        System.out.println("Ana İş Parçacığı: " + Thread.currentThread().getName());
        Thread thread1 = new Thread(new MyRunnable("A"));
        Thread thread2 = new Thread(new MyRunnable("B"));
        Thread thread3 = new Thread(new MyRunnable("C"));

        thread1.start();
        thread2.start();
        thread3.start();

        try {
            thread1.join(); // thread1'in bitmesini bekle
            thread2.join(); // thread2'nin bitmesini bekle
            thread3.join(); // thread3'ün bitmesini bekle
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("Tüm görevler tamamlandı. Ana İş Parçacığı sonlandı.");
    }
}

public class Counter {
    private int count = 0;

    // Metod senkronizasyonu
    public synchronized void increment() {
        count++;
    }

    // Blok senkronizasyonu
    public void decrement() {
        synchronized (this) { // 'this' objesi üzerinde kilit
            count--;
        }
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final Sayım: " + counter.getCount()); // Beklenen: 2000
    }
}

import java.util.concurrent.locks.ReentrantLock;

public class DataProcessor {
    private int data = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void processData() {
        lock.lock(); // Kilidi al
        try {
            // Kritik Bölüm
            data++;
            System.out.println(Thread.currentThread().getName() + " - İşlenmiş veri: " + data);
        } finally {
            lock.unlock(); // Kilidi serbest bırakmayı garanti et
        }
    }

    public static void main(String[] args) {
        DataProcessor processor = new DataProcessor();

        Runnable task = () -> {
            for (int i = 0; i < 5; i++) {
                processor.processData();
                try { Thread.sleep(50); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
            }
        };

        for (int i = 0; i < 3; i++) {
            new Thread(task, "İş Parçacığı-" + (i + 1)).start();
        }
    }
}

• Executor Framework: İş parçacığı yönetimini geliştiricinin üzerinden alarak, iş parçacığı havuzları (thread pools) aracılığıyla görevlerin yürütülmesini sağlar. `ExecutorService`, `ThreadPoolExecutor` gibi sınıflar içerir. Görevleri kuyruğa alıp mevcut iş parçacıklarına dağıtarak, iş parçacığı oluşturma ve yok etme maliyetlerini azaltır.
  Avantajları:
  • İş parçacığı yönetimini basitleştirir.
  • İş parçacığı maliyetini azaltır.
  • Kaynak kullanımını optimize eder.
  • Görevlerin yürütülmesi üzerinde daha fazla kontrol sağlar (planlama, iptal vb.).
  Kod:

  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  import java.util.concurrent.TimeUnit;
  
  public class ExecutorServiceExample {
      public static void main(String[] args) {
          // 2 iş parçacıklı sabit bir havuz oluştur
          ExecutorService executor = Executors.newFixedThreadPool(2);
  
          for (int i = 0; i < 5; i++) {
              int taskId = i;
              executor.submit(() -> {
                  System.out.println("Görev " + taskId + " " + Thread.currentThread().getName() + " üzerinde çalışıyor.");
                  try {
                      Thread.sleep(Math.round(Math.random() * 1000));
                  } catch (InterruptedException e) {
                      Thread.currentThread().interrupt();
                  }
                  System.out.println("Görev " + taskId + " tamamlandı.");
              });
          }
  
          executor.shutdown(); // Yeni görev kabul etmeyi durdur, mevcutları bitir
          try {
              // Tüm görevlerin bitmesini bekle, maksimum 60 saniye
              if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                  executor.shutdownNow(); // Hala bitmeyenleri zorla durdur
              }
          } catch (InterruptedException e) {
              executor.shutdownNow();
              Thread.currentThread().interrupt();
          }
          System.out.println("Tüm Executor görevleri tamamlandı.");
      }
  }

• Callable ve Future: `Runnable` arayüzü değer döndürmezken, `Callable` arayüzü bir değer döndürebilir ve bir istisna fırlatabilir. `Future` nesnesi, bir `Callable` görevinin sonucunu asenkron olarak almak için kullanılır. Bu, uzun süren işlemlerin sonucunu beklerken ana iş parçacığının bloke olmamasını sağlar.
  
  Kod:

  import java.util.concurrent.Callable;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  import java.util.concurrent.Future;
  import java.util.concurrent.TimeUnit;
  
  public class CallableFutureExample {
  
      public static void main(String[] args) throws Exception {
          ExecutorService executor = Executors.newFixedThreadPool(1);
  
          // Bir Callable görevi tanımla
          Callable<Integer> sumTask = () -> {
              System.out.println(Thread.currentThread().getName() + " - Hesaplama başlatıldı...");
              Thread.sleep(2000); // Yoğun bir hesaplama simülasyonu
              int sum = 0;
              for (int i = 1; i <= 100; i++) {
                  sum += i;
              }
              System.out.println(Thread.currentThread().getName() + " - Hesaplama tamamlandı.");
              return sum;
          };
  
          Future<Integer> future = executor.submit(sumTask);
  
          System.out.println("Hesaplama devam ederken başka işler yapılıyor...");
          // ... başka işler ...
  
          // Sonucu alana kadar bekle (bloklama)
          Integer result = future.get(); // Sonuç hazır olana kadar bekler
          System.out.println("Görevin sonucu: " + result);
  
          executor.shutdown();
          executor.awaitTermination(1, TimeUnit.MINUTES);
      }
  }

• Eşzamanlı Koleksiyonlar: `java.util.concurrent` paketi, standart koleksiyonların (HashMap, ArrayList vb.) çoklu iş parçacığı ortamlarında güvenli bir şekilde kullanılabilen eşzamanlı alternatiflerini sunar. Örneğin, `ConcurrentHashMap`, `CopyOnWriteArrayList`, `BlockingQueue`.
  
  
  Kod:

  import java.util.concurrent.ConcurrentHashMap;
  import java.util.Map;
  
  public class ConcurrentMapExample {
      public static void main(String[] args) throws InterruptedException {
          Map<String, Integer> map = new ConcurrentHashMap<>();
  
          Runnable task = () -> {
              for (int i = 0; i < 1000; i++) {
                  map.put(Thread.currentThread().getName() + "_key_" + i, i);
              }
          };
  
          Thread t1 = new Thread(task, "Thread-1");
          Thread t2 = new Thread(task, "Thread-2");
  
          t1.start();
          t2.start();
  
          t1.join();
          t2.join();
  
          System.out.println("Haritadaki toplam eleman sayısı: " + map.size());
          // Çıktı beklenildiği gibi 2000 olacaktır, çünkü ConcurrentHashMap iş parçacığı güvenlidir.
      }
  }

• Fork/Join Framework: Java 7 ile gelen bu framework, büyük problemleri daha küçük, bağımsız parçalara bölerek (fork) ve bu parçaların sonuçlarını birleştirerek (join) paralel olarak çözmek için tasarlanmıştır. Özellikle yoğun hesaplama gerektiren algoritmalar (örneğin, sıralama, arama, görüntü işleme) için etkilidir.
  
  Kod:

  import java.util.concurrent.ForkJoinPool;
  import java.util.concurrent.RecursiveTask;
  
  class SumTask extends RecursiveTask<Long> {
      private final long[] array;
      private final int start;
      private final int end;
      private static final int THRESHOLD = 1000; // Küçük görev sınırı
  
      public SumTask(long[] array, int start, int end) {
          this.array = array;
          this.start = start;
          this.end = end;
      }
  
      @Override
      protected Long compute() {
          if (end - start <= THRESHOLD) {
              // Eğer görev küçükse, doğrudan hesapla
              long sum = 0;
              for (int i = start; i < end; i++) {
                  sum += array[i];
              }
              return sum;
          } else {
              // Görev büyükse, ikiye böl
              int mid = start + (end - start) / 2;
              SumTask leftTask = new SumTask(array, start, mid);
              SumTask rightTask = new SumTask(array, mid, end);
  
              // Sol görevi asenkron çalıştır
              leftTask.fork();
  
              // Sağ görevi mevcut iş parçacığında çalıştır
              Long rightResult = rightTask.compute();
  
              // Sol görevin bitmesini bekle ve sonuçları birleştir
              Long leftResult = leftTask.join();
              return leftResult + rightResult;
          }
      }
  
      public static void main(String[] args) {
          long[] data = new long[100000];
          for (int i = 0; i < data.length; i++) {
              data[i] = i + 1;
          }
  
          ForkJoinPool pool = new ForkJoinPool();
          long sum = pool.invoke(new SumTask(data, 0, data.length));
          System.out.println("Dizinin toplamı: " + sum);
      }
  }

  Bu örnekte, `RecursiveTask` kullanarak büyük bir dizinin toplamını paralel olarak hesapladık. `fork()` metodu yeni bir alt görevi zamanlarken, `compute()` metodu mevcut iş parçacığında devam eder. `join()` ise fork edilen görevin sonucunu bekler.

• Çıkmaz (Deadlock): İki veya daha fazla iş parçacığının birbirlerinin kaynaklarını serbest bırakmasını beklemesi ve bu nedenle sonsuza kadar bloke kalması durumu.
• Canlı Kilit (Livelock): İş parçacıklarının sürekli olarak durumlarını değiştirmeleri ancak hiçbir ilerleme kaydedememeleri durumu.
• Açlık (Starvation): Bir iş parçacığının, kaynaklara veya işlemci süresine tekrar tekrar erişememesi durumu.
• Veri Tutarsızlığı (Data Inconsistency): Senkronizasyon eksikliği nedeniyle paylaşılan verilere yanlış erişimden kaynaklanan hatalı durumlar.
• Hata Ayıklama Zorlukları: Yarış durumları gibi zamanlama bağımlı hataların yeniden üretilmesi ve ayıklanması oldukça zordur.

• Değişmezlik (Immutability): Mümkün olduğunca değişmez (immutable) nesneler kullanın. Değişmez nesnelerin durumu oluşturulduktan sonra değişmediği için iş parçacığı güvenlidirler ve senkronizasyon gerektirmezler.
• Paylaşılan Durumu En Aza İndirme: İş parçacıkları arasında paylaşılan mutable (değişebilir) durumu mümkün olduğunca azaltın. Eğer paylaşım kaçınılmazsa, bunu güvenli bir şekilde yönetmek için uygun senkronizasyon mekanizmalarını kullanın.
• Yüksek Seviyeli Soyutlamaları Kullanma: `java.util.concurrent` paketindeki `ExecutorService`, `ConcurrentHashMap`, `BlockingQueue`, `ForkJoinPool` gibi yüksek seviyeli API'ları tercih edin. Bu API'lar, alt seviye iş parçacığı yönetiminin karmaşıklığını gizler ve daha az hataya açık çözümler sunar.
• Atomik İşlemler: `java.util.concurrent.atomic` paketindeki `AtomicInteger`, `AtomicLong` gibi sınıfları kullanarak küçük, tekil değerler üzerinde atomik (bölünemez) işlemler yapın. Bu, kilit kullanmadan performansı artırabilir.
• İyi Tasarım ve Test: Paralel kısımları dikkatlice tasarlayın ve özellikle birim ve entegrasyon testlerinde iş parçacığı güvenliklerini kapsamlı bir şekilde test edin. Test ortamında yarış durumlarını tetiklemeye çalışın.
• Kaynaktan Gelen Kapatmalar (Graceful Shutdown): İş parçacığı havuzlarını ve ilgili kaynakları düzgün bir şekilde kapatmayı unutmayın (`executor.shutdown()`, `awaitTermination()`).