volatile anahtar kelimesinin kullanımı dışında, iş…

Android'de thread senkronizasyonu ve yarış koşullarını önlemenin birkaç temel yaklaşımı vardır, volatile dışında.

Synchronized kullanımı: Mevcut thread tamamlanana kadar diğer thread'lerin kod veya metoda erişimini engeller.

// Senkronize edilmiş metod
synchronized void incrementCounter() {
    counter++;
}

// Senkronize blok
void updateData() {
    synchronized (this) { // veya başka bir monitor nesnesi
        // senkronizasyon gerektiren kod
    }
}

java.util.concurrent.locks paketinden sınıfların kullanımı: synchronized'dan daha esnek kilit mekanizmaları sağlar.

import java.util.concurrent.locks.ReentrantLock;

private final ReentrantLock lock = new ReentrantLock();

void performLockedOperation() {
    lock.lock(); // kilidi alma
    try {
        // kilit korumalı kod
    } finally {
        lock.unlock(); // kilidi serbest bırakma (önemli finally'de)
    }
}

java.util.concurrent.atomic paketinden sınıfların kullanımı: Atomik işlemler sağlar, diğer thread'ler tarafından kesintiye uğramadan tek bir bütün olarak çalışır. Basit işlemler ve referanslar için uygundur.

import java.util.concurrent.atomic.AtomicInteger;

private final AtomicInteger atomicCounter = new AtomicInteger(0);

void incrementAtomicCounter() {
    atomicCounter.incrementAndGet(); // Atomik artış
}

Thread-safe koleksiyonların kullanımı: java.util.concurrent paketinden koleksiyonlar (örneğin, ConcurrentHashMap, CopyOnWriteArrayList) çoklu thread ortamında güvenli kullanım için tasarlanmıştır, açıkça senkronizasyon gerekmez.

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

private final Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();

void updateMap(String key, Integer value) {
    concurrentMap.put(key, value); // Güvenli yazma işlemi
}

ThreadLocal kullanımı: Her thread için ayrı bir kopya tutan değişkenler oluşturmayı sağlar. Böylece, her thread kendi verisiyle çalışır ve yarış koşulları önlenir.

private final ThreadLocal<Integer> threadLocalValue = new ThreadLocal<Integer>() {
    @Override
    protected Integer initialValue() {
        return 0; // Her thread için başlangıç değeri
    }
};

void processData() {
    int value = threadLocalValue.get();
    value++;
    threadLocalValue.set(value); // Mevcut thread için değeri ayarla
}

Yöntem seçimi, görevin özelliklerine, kilitleme ihtiyacına, veri tipine ve performans gereksinimlerine bağlıdır.

volatile anahtar kelimesinin kullanımı dışında, iş parçacığı yarışını önlemek için hangi yöntemleri biliyorsunuz?