hiçbir çekişme

Question

aşağıdaki kod sniper düşünün oluşabilir eğer okurken gerekli senkronizasyon mı. Belleği yerel önbellekten ana belleğe akıtmak için ayarlayıcıda senkronizasyon gereklidir. Zamanında Time2 (Zaman2> Zaman1, iplik çekimi yok) iş parçacığı Thread2 değişkenin değerini okuyacaktır.

Soru: - getterden önce senkronize edilmeli mi? Bunun herhangi bir soruna yol açmayacağı anlaşılıyor - bellek güncel olmalı ve Thread2’nin yerel önbelleği, Thread1 tarafından güncellenen & geçersiz kılmalı, ancak emin değilim.

Answer 1

Merak etmek yerine, neden atomik referansları sadece java.util.concurrent?

(ve buna değecek, happens-before okumam da, Thread2'nin senkronize olarak kullanılmadığı sürece değiştirilemez değişiklikleri görmesini garanti etmez ... ama JLS'nin her zaman bir baş ağrısına neden olurum, bu yüzden atomik kullanın referanslar)

Answer 2

Alıcının sadece ayarlayıcı çağrıldıktan sonra çağrılacağından kesinlikle emin misiniz? Eğer öyleyse, eşzamanlı okumaların senkronize edilmesine gerek olmadığı için senkronize edilecek alıcıya ihtiyacınız yoktur.

Eşzamanlı olarak çağrılıp aranabilme şansı varsa, ikisini de senkronize etmeniz gerekir.

Answer 3

sen, uçucu değişken ayrıntıları yaparsanız iyi olacak "cheap read-write lock"

Answer 4

Bu muhtemelen yanlış davranışlara neden asla, ama aynı zamanda ipler de başlangıç ​​sırasını garanti sürece, mutlaka garanti olamaz Derleyici, Thread1'deki yazmadan önce Thread2'deki okumayı yeniden düzenlemediğinden. Daha spesifik olarak, the entire Java runtime only has to guarantee that threads execute as if they were run in serial. Bu yüzden, iş parçacığı, çıktıları seri halinde, optimizasyonlar altında çalıştığında, tüm dil yığını (derleyici, donanım, dil çalışma zamanı) istediği kadar çok yapabilir. Thread2'nin LockQuestion.getMutable() sonucunu önbelleğe almasına izin verilmesi dahil.

Pratikte, böyle bir şey olsaydı çok şaşırırdım. Bunun gerçekleşmediğini garanti etmek isterseniz, LockQuestion.mutable'un final olarak bildirilmesini sağlayın ve kurucuda başlatılmış olsun. Or use the following idiom:

private static class LazySomethingHolder { 
    public static Something something = new Something(); 
} 

public static Something getInstance() { 
    return LazySomethingHolder.something; 
} 

Answer 5

Eğer okuma dizisindeki performansı hakkında çok kaygı, o zaman doğru senkronizasyon veya uçucu veya atomik referansları kullanarak bir kez değer okunur ne. Sonra değeri düz eski bir değişkene atarsınız.

Düzlük değişkeni atama, atomik okumadan sonra gerçekleşeceğinden (aksi halde değeri nasıl alabilir?) Olduğundan ve değerin hiçbir zaman başka bir iş parçacığı tarafından yazılmayacağı garanti edilir.

Answer 6

Sanırım bir sorun olduğunu bildiğiniz zaman doğru olan ve daha sonra optimize olan bir şeyle başlamalısınız. Birkaç nano saniye çok uzun olmadıkça AtomicReference kullanıyorum.A mikro-saniye 1 milyonda ile)

public static void main(String... args) { 
    AtomicReference<String> ars = new AtomicReference<String>(); 
    ars.set("hello"); 
    long start = System.nanoTime(); 
    int runs = 1000* 1000 * 1000; 
    int length = test(ars, runs); 
    long time = System.nanoTime() - start; 
    System.out.printf("get() costs " + 1000*time/runs + " ps."); 
} 

private static int test(AtomicReference<String> ars, int runs) { 
    int len = 0; 
    for (int i = 0; i < runs; i++) 
     len = ars.get().length(); 
    return len; 
} 

Baskılar

get() costs 1219 ps. 

PS, bir piko saniyedir.