0Pricing
Java Academy · Ders

Atomik Değişkenler: Kilitsiz Güncellemeler

Kilit kullanmadan iş parçacığı güvenli sayaçlar için AtomicInteger, AtomicLong ve AtomicReference kullanın.

Atomik Değişkenler: Kilitsiz Güncellemeler, CoddyKit'te ücretsiz bir Java Academy dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Java Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Java Academy kursu toplamda 4 dersten oluşur.

Atomik Olmayan İşlemlerin Sorunu

Basit bir count++ artırma işlemi iş parçacığı güvenli DEĞİLDİR — üç işlemden oluşur: okuma, ekleme ve yazma. Eş zamanlı iş parçacıkları bu işlemleri araya girerek yürütebilir ve güncellemelerin kaybolmasına neden olabilir. Atomik değişkenler bunu kilit kullanmadan çözer.

// UNSAFE:
int count = 0;
// Thread A reads count=0, Thread B reads count=0
// Both write 1 — second update lost!
count++; // NOT thread-safe

// SAFE:
import java.util.concurrent.atomic.*;
AtomicInteger atomicCount = new AtomicInteger(0);
atomicCount.incrementAndGet(); // atomic, lock-free

AtomicInteger Temelleri

AtomicInteger, kilit gerektirmeden CPU karşılaştır ve değiştir (CAS) yönergelerini kullanarak atomik olduğu garanti edilen tamsayı işlemleri sağlar.

AtomicInteger counter = new AtomicInteger(0);

counter.set(10);                   // set to 10
System.out.println(counter.get()); // 10

int prev = counter.getAndIncrement(); // returns 10, sets to 11
int curr = counter.incrementAndGet(); // sets to 12, returns 12
counter.addAndGet(5);                 // adds 5, returns 17
counter.decrementAndGet();            // subtracts 1, returns 16

compareAndSet: CAS İşlemi

compareAndSet(expected, update), değeri yalnızca mevcut değer beklenen değere eşitse atomik olarak günceller. Başarılı olursa true döndürür. Bu, tüm kilitsiz algoritmaların temelidir.

AtomicInteger ai = new AtomicInteger(5);

boolean updated = ai.compareAndSet(5, 10); // current==5? set to 10
System.out.println(updated); // true
System.out.println(ai.get()); // 10

boolean failed = ai.compareAndSet(5, 20); // current==10, not 5 → fails
System.out.println(failed); // false
System.out.println(ai.get()); // still 10

Sayaçlar için AtomicLong

AtomicLong, 64 bitlik eşdeğerdir. Sıra oluşturucularında ve isabet sayaçlarında yaygın olarak kullanılır:

AtomicLong seq = new AtomicLong(0);

// Thread-safe sequence generator:
long nextId() {
    return seq.incrementAndGet();
}

System.out.println(nextId()); // 1
System.out.println(nextId()); // 2
System.out.println(nextId()); // 3

AtomicBoolean

İş parçacığı güvenli bir boolean bayrağıdır. Genellikle tek seferlik başlatma veya kapatma sinyalleri için kullanılır:

AtomicBoolean initialized = new AtomicBoolean(false);

void initOnce() {
    // compareAndSet: only first caller succeeds
    if (initialized.compareAndSet(false, true)) {
        System.out.println("Initializing...");
        // perform expensive init
    } else {
        System.out.println("Already initialized");
    }
}

AtomicReference

AtomicReference<V>, bir nesne başvurusunda atomik güncellemeler sağlar. Kilitsiz veri yapıları uygulamak için kullanılır:

import java.util.concurrent.atomic.*;

record Config(String host, int port) {}

AtomicReference<Config> configRef =
    new AtomicReference<>(new Config("localhost", 8080));

// Hot-swap the configuration atomically:
Config oldConfig = configRef.get();
Config newConfig = new Config("prod.example.com", 443);

boolean swapped = configRef.compareAndSet(oldConfig, newConfig);
System.out.println(swapped); // true
System.out.println(configRef.get()); // Config[host=prod.example.com, port=443]

updateAndGet / getAndUpdate

Bir işlevi, dahili olarak CAS yeniden deneme döngüsü kullanarak atomik biçimde uygulayın:

AtomicInteger value = new AtomicInteger(10);

// Apply function atomically: square the value
int newVal = value.updateAndGet(x -> x * x);
System.out.println(newVal); // 100

// Get old, then apply:
int old = value.getAndUpdate(x -> x + 1);
System.out.println(old);   // 100
System.out.println(value.get()); // 101

accumulateAndGet

Mevcut değeri, bir işlev kullanarak verilen değerle birleştirin:

AtomicInteger max = new AtomicInteger(0);

// Keep running maximum:
max.accumulateAndGet(42, Math::max); // max(0, 42) = 42
max.accumulateAndGet(15, Math::max); // max(42, 15) = 42
max.accumulateAndGet(99, Math::max); // max(42, 99) = 99

System.out.println(max.get()); // 99

Yüksek Çekişmeli Sayaçlar için LongAdder

İş parçacığı çekişmesinin yüksek olduğu durumlarda AtomicLong'un CAS yeniden denemeleri performansı düşürebilir. LongAdder, çekişmeyi azaltmak için birden çok hücre kullanır:

import java.util.concurrent.atomic.*;

LongAdder adder = new LongAdder();

// Multiple threads can call add() with minimal contention:
adder.increment();
adder.add(5);
adder.increment();

System.out.println(adder.sum()); // 7
// Note: sum() is NOT atomic with add() — use only when no concurrent adds

Atomik Diziler

AtomicIntegerArray / AtomicLongArray, tek tek dizi öğeleri üzerinde atomik işlemler sağlar:

AtomicIntegerArray arr = new AtomicIntegerArray(5);

arr.set(0, 10);
arr.incrementAndGet(0);
arr.compareAndSet(2, 0, 42); // index 2: if 0, set 42

System.out.println(arr.get(0)); // 11
System.out.println(arr.get(2)); // 42

Atomikler ile Kilitler Ne Zaman Kullanılmalı

Şu durumlarda atomik değişkenleri kullanın:

  • Tek değişkenli güncellemeler (sayaçlar, bayraklar ve başvurular)
  • Düşük çekişmeli senaryolar
  • Kilitsiz performans önemliyse

Şu durumlarda kilitleri kullanın:

  • Birden çok değişkenin atomik olarak güncellenmesi gerekiyorsa
  • Karmaşık koşullu mantık gerekiyorsa
  • Çekişme çok yüksekse (CAS yeniden denemeleri performansı düşürür)

Hızlı Kontrol

compareAndSet(expected, update) neyi garanti eder?

Özet: Atomik Değişkenler

Temel çıkarımlar:

  • Atomik türler CPU CAS yönergelerini kullanır — kilitsiz ve iş parçacığı güvenlidir
  • Tek değişkenli atomiklik için AtomicInteger/Long/Boolean/Reference
  • compareAndSet, kilitsiz algoritmaların temelidir
  • İşlevsel güncellemeler için updateAndGet/accumulateAndGet
  • Yüksek çekişmeli sayaç senaryoları için LongAdder

Sıkça Sorulan Sorular

“Atomik Değişkenler: Kilitsiz Güncellemeler” dersi ücretsiz mi?

Evet — “Atomik Değişkenler: Kilitsiz Güncellemeler” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Java Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Java Academy kursu toplamda 4 dersten oluşur.

“Atomik Değişkenler: Kilitsiz Güncellemeler” dersinde ne öğreneceğim?

Kilit kullanmadan iş parçacığı güvenli sayaçlar için AtomicInteger, AtomicLong ve AtomicReference kullanın. Java Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Java Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Java Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“Atomik Değişkenler: Kilitsiz Güncellemeler” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Java Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Java Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. ReentrantLock ve synchronized Karşılaştırması
  2. Okuyucu-Yazıcı Senaryoları için ReadWriteLock
  3. Atomik Değişkenler: Kilitsiz Güncellemeler
  4. StampedLock ve İyimser Okumalar
← Java Academy Sayfasına Dön