Birden fazla iş parçacığından java.util.HashMap'ten değer almak güvenli mi (değişiklik yok)?

Bir haritanın inşa edileceği bir durum vardır ve bir kez başlatıldığında, bir daha asla değiştirilmez. Bununla birlikte, bu dosyaya birden fazla iş parçacığından erişilebilir (yalnızca get (anahtar) aracılığıyla). A'yı java.util.HashMapbu şekilde kullanmak güvenli midir?

(Şu anda, mutlu bir kullanıyorum java.util.concurrent.ConcurrentHashMapve performansı artırmak için hiçbir ölçülen ihtiyacı var, ancak basit eğer sadece merak ediyorum HashMapyeterli olacaktır. Dolayısıyla, bu soru değil "? Biri kullanmalıyım" ne de bir performans sorudur. Aksine, soru "Güvenli olur mu?")

Sizin deyim güvenlidir ancak ve ancak referans HashMapalmaktadır güvenle yayınlanan . İç yayınlarıyla ilgili her şeyden ziyade HashMap, güvenli yayın , yapım iş parçacığının haritaya referansı diğer iş parçacıkları tarafından nasıl görünür hale getirdiği ile ilgilidir.

Temel olarak, burada mümkün olan tek yarış HashMap, tamamen inşa edilmeden önce ona erişebilecek herhangi bir okuma iş parçacığının yapımı arasındadır. Tartışmanın çoğu, harita nesnesinin durumuna ne olduğu ile ilgilidir, ancak asla değiştirmediğiniz için bu önemsizdir - bu yüzden tek ilginç kısım HashMapreferansın nasıl yayınlandığıdır.

Örneğin, haritayı şu şekilde yayınladığınızı düşünün:

class SomeClass {
   public static HashMap<Object, Object> MAP;

   public synchronized static setMap(HashMap<Object, Object> m) {
     MAP = m;
   }
}

... ve bir noktada setMap()bir harita ile çağrılır ve diğer iş parçacıkları SomeClass.MAPharitaya erişmek için kullanılır ve şu şekilde null olup olmadığını kontrol edin:

HashMap<Object,Object> map = SomeClass.MAP;
if (map != null) {
  .. use the map
} else {
  .. some default behavior
}

Bu güvenli değil o sanki muhtemelen görünmesine rağmen. Sorun, başka bir iş parçacığının kümesi ve sonraki okuma arasında önceden gerçekleşen bir ilişki olmamasıdır SomeObject.MAP, bu nedenle okuma iş parçacığı kısmen oluşturulmuş bir harita görmekte serbesttir. Bu hemen hemen her şeyi yapabilir ve pratikte bile okuma ipliğini sonsuz bir döngüye koymak gibi şeyler yapar .

Güvenle haritayı yayınlamak için bir tesis gerekir olur-öncesi arasındaki ilişkinin referans yazılı etmek HashMap(yani yayına ) ve referans (yani tüketim) müteakip okuyucuları. Uygun bir şekilde, bunu başarmanın kolay hatırlanabilir birkaç yolu vardır ^[1] :

1. Referansı uygun şekilde kilitlenmiş bir alanda değiştirin ( JLS 17.4.5 )
2. İlklendirme depolarını yapmak için statik başlatıcı kullanın ( JLS 12.4 )
3. Referansı değişken bir alanla ( JLS 17.4.5 ) veya bu kuralın bir sonucu olarak AtomicX sınıfları aracılığıyla değiştirin
4. Değeri bir son alana başlatın ( JLS 17.5 ).

Senaryonuz için en ilginç olanlar (2), (3) ve (4). Özellikle, (3) doğrudan yukarıdaki kodum için geçerlidir: beyanı dönüştürürseniz MAP:

public static volatile HashMap<Object, Object> MAP;

o zaman her şey koşerdir: null olmayan bir değer gören okuyucular mutlaka mağaza ile önce bir ilişki MAPkurarlar ve böylece harita başlatma ile ilişkili tüm mağazaları görürler.

Diğer yöntemler yönteminizin anlambilimini değiştirir, çünkü (2) (statik initalizer kullanarak) ve (4) ( final kullanarak ) MAPçalışma zamanında dinamik olarak ayarlayamayacağınızı ima eder . Eğer yoksa ihtiyaç bunu, o zaman sadece beyan MAPbir şekilde static final HashMap<>ve güvenli yayın garantilidir.

Uygulamada, kurallar "hiç değiştirilmemiş nesnelere" güvenli erişim için basittir:

Doğal olarak değiştirilemeyen (beyan edilen tüm alanlarda olduğu gibi) bir nesne yayınlıyorsanız finalve:

• Zaten beyanı anında atanacak nesneyi oluşturabilirsiniz ^a : sadece kullanmak final(dahil alanını static finalstatik üyeleri için).
• Nesneyi daha sonra, referans zaten göründükten sonra atamak istiyorsunuz: uçucu bir alan kullanın ^b .

Bu kadar!

Uygulamada çok verimlidir. static finalÖrneğin, bir alanın kullanılması JVM'nin programın ömrü boyunca değerin değişmediğini varsaymasına ve onu yoğun şekilde optimize etmesine izin verir. finalÜye alanının kullanımı, çoğu mimarinin alanı normal alan okumasına eşdeğer bir şekilde okumasına olanak tanır ve daha fazla optimizasyonu engellemez ^c .

Son olarak, kullanımının bir volatileetkisi vardır: pek çok mimaride donanım engeli gerekmez (özellikle x86, özellikle okumaların okumaları geçmesine izin vermeyenler), ancak derleme zamanında bazı optimizasyon ve yeniden sıralama gerçekleşmeyebilir - ancak bu etkisi genellikle küçüktür. Buna karşılık, aslında istediğinizden daha fazlasını elde edersiniz - sadece güvenli bir şekilde yayınlamakla HashMapkalmaz HashMap, aynı referansta istediğiniz kadar çok değiştirilmemiş s kaydedebilir ve tüm okuyucuların güvenli bir şekilde yayınlanmış bir harita göreceğinden emin olabilirsiniz. .

Daha fazla ayrıntı için Shipilev'e veya Manson ve Goetz tarafından hazırlanan bu SSS'ye bakın .

[1] Doğrudan shipilev'den alıntı .

^a Kulağa karmaşık geliyor, ama demek istediğim referansı inşaat zamanında atayabilirsiniz - açıklama noktasında veya yapıcıda (üye alanları) veya statik başlatıcıda (statik alanlar).

^b İsteğe bağlı olarak, synchronizedalmak / ayarlamak için bir yöntem veya bir AtomicReferenceveya bir şey kullanabilirsiniz, ancak yapabileceğiniz minimum işten bahsediyoruz.

c çok zayıf hafıza modelleriyle (Benim baktığım Bazı mimariler size , Alpha) bir önceki okuma bariyer çeşit gerektirebilir finalokuma - ama bunlar bugün çok nadirdir.

Java Bellek Modeli söz konusu olduğunda tanrı Jeremy Manson'un bu konuda üç bölümlü bir blogu var - çünkü özünde "Değişmez bir HashMap'a erişmek güvenli mi?" Sorusunu soruyorsunuz - bunun cevabı evet. Ama şu soruyu yüklemelisiniz - "Benim HashMap'ım değişmez mi?" Cevap sizi şaşırtabilir - Java'nın değişmezliği belirlemek için nispeten karmaşık bir kurallar dizisi vardır.

Konu hakkında daha fazla bilgi için Jeremy'nin blog gönderilerini okuyun:

Java'da Değişmezlik Bölüm 1: http://jeremymanson.blogspot.com/2008/04/immutability-in-java.html

Java'da Değişmezlik Bölüm 2: http://jeremymanson.blogspot.com/2008/07/immutability-in-java-part-2.html

Java'da Değişmezlik Bölüm 3: http://jeremymanson.blogspot.com/2008/07/immutability-in-java-part-3.html

Okumalar senkronizasyon açısından güvenlidir, ancak bellek açısından güvenilir değildir. Bu, Stackoverflow da dahil olmak üzere Java geliştiricileri arasında yaygın olarak yanlış anlaşılan bir şeydir. ( Kanıt için bu cevabın derecelendirmesine dikkat edin .)

Başka iş parçacıklarınız varsa, geçerli iş parçacığından bellek yazma işlemi yoksa, HashMap'in güncelleştirilmiş bir kopyasını görmeyebilirler. Bellek yazma işlemleri, senkronize edilmiş veya geçici anahtar kelimeler kullanılarak veya bazı java eşzamanlılık yapıları kullanılarak gerçekleşir.

Ayrıntılar için Brian Goetz'in yeni Java Bellek Modeli hakkındaki makalesine bakın.

Biraz daha baktıktan sonra, bunu java doc'da buldum (benimki vurgu):

Bu uygulamanın senkronize olmadığını unutmayın. Birden çok iş parçacığı bir eşleme haritasına aynı anda erişiyorsa ve iş parçacıklarından en az biri haritayı yapısal olarak değiştiriyorsa, harici olarak senkronize edilmelidir. (Yapısal bir değişiklik, bir veya daha fazla eşleme ekleyen veya silen herhangi bir işlemdir; yalnızca bir örneğin zaten içerdiği bir anahtarla ilişkili değeri değiştirmek yapısal bir değişiklik değildir.)

Bu, ifadenin tersinin doğru olduğunu varsayarsak, güvenli olacağı anlamına geliyor.

Bir not, bazı durumlarda, senkronize edilmemiş bir HashMap'ten get () yönteminin sonsuz döngüye neden olabileceğidir. Bu, eşzamanlı bir put () Eşlem'in yeniden yakalanmasına neden olursa oluşabilir.

http://lightbody.net/blog/2005/07/hashmapget_can_cause_an_infini.html

Yine de önemli bir bükülme var. Haritaya erişmek güvenlidir, ancak genel olarak tüm iş parçacıklarının HashMap ile tam olarak aynı durumu (ve dolayısıyla değerleri) göreceği garanti edilmez. Bu, bir iş parçacığı tarafından yapılan HashMap'taki değişikliklerin (örneğin, onu dolduran) yaptığı işlemin bu CPU'nun önbelleğinde oturabileceği ve bir bellek çit işlemi yapılana kadar diğer CPU'larda çalışan iş parçacıkları tarafından görülmeyeceği çok işlemcili sistemlerde olabilir. önbellek tutarlılığı sağlanarak gerçekleştirildi. Java Dil Belirtimi bu konuda açıktır: çözüm, bir bellek çit işlemi yayan bir kilit (senkronize (...)) elde etmektir. Bu nedenle, HashMap'i doldurduktan sonra her bir iş parçacığının HERHANGİ bir kilit aldığından eminseniz, HashMap tekrar değiştirilene kadar herhangi bir iş parçacığından HashMap'e erişmek bu noktadan itibaren sorun olmaz.

Http://www.ibm.com/developerworks/java/library/j-jtp03304/ # Başlatma güvenliğine göre HashMap'inizi son bir alan haline getirebilirsiniz ve kurucu bittikten sonra güvenli bir şekilde yayınlanır.

... Yeni bellek modeli altında, bir yapıcıdaki son alanın yazılması ile başka bir iş parçacığında o nesneye paylaşılan bir başvurunun ilk yükü arasındaki önceki bir ilişkiye benzer bir şey vardır. ...

Yani tarif ettiğiniz senaryo, bir Haritaya bir grup veri koymanız gerektiğidir, o zaman doldurmayı bitirdiğinizde değişmez olarak görürsünüz. "Güvenli" yaklaşımlardan biri (bunun gerçekten değişmez olarak ele alındığını zorunlu kıldığınız anlamına gelir), referansı Collections.unmodifiableMap(originalMap)değişmez hale getirmeye hazır olduğunuzda değiştirmektir.

Eşzamanlı olarak kullanıldığında haritaların ne kadar kötü başarısız olabileceğine ve bahsettiğim önerilen geçici çözüm için bu hata geçit girişine göz atın : bug_id = 6423457

Bu soru Brian Goetz'in "Uygulamada Java Eşzamanlılığı" kitabında ele alınmıştır (Liste 16.8, sayfa 350):

@ThreadSafe
public class SafeStates {
    private final Map<String, String> states;

    public SafeStates() {
        states = new HashMap<String, String>();
        states.put("alaska", "AK");
        states.put("alabama", "AL");
        ...
        states.put("wyoming", "WY");
    }

    public String getAbbreviation(String s) {
        return states.get(s);
    }
}

Yana statesolarak bildirilmiş finalve bunun başlatma sahibinin sınıf yapıcı içerisinde gerçekleştirilir sonradan bu haritayı okur herhangi bir iş parçacığı başka hiçbir konu sağlanan yapıcı bitirir, haritanın içeriğini değiştirmeye çalışacağız zamanın olarak görmeye garantilidir.

Tek iş parçacıklı kodda bile, bir ConcurrentHashMap öğesinin HashMap ile değiştirilmesinin güvenli olmayabileceği konusunda uyarılmalıdır. ConcurrentHashMap null değerini anahtar veya değer olarak yasaklar. HashMap onları yasaklamaz (sormayın).

Bu nedenle, mevcut kodunuzun kurulum sırasında (muhtemelen bir tür başarısızlık durumunda) koleksiyona boş değer ekleyebilmesi durumunda, koleksiyonun açıklandığı gibi değiştirilmesi işlevsel davranışı değiştirir.

Bununla birlikte, başka bir şey yapmamanız koşuluyla, bir HashMap'ten eşzamanlı okumalar güvenlidir.

[Düzenle: “eşzamanlı okumalar” ile, eşzamanlı modifikasyonların olmadığı anlamına gelir.

Diğer cevaplar bunun nasıl sağlanacağını açıklar. Bunun bir yolu haritayı değişmez yapmaktır, ancak gerekli değildir. Örneğin, JSR133 bellek modeli, bir iş parçacığının başlatılmasını senkronize bir eylem olarak açıkça tanımlar, yani A iş parçacığında B iş parçacığını başlatmadan önce yapılan değişiklikler B iş parçacığında görülebilir.

Amacım Java Bellek Modeli ile ilgili daha ayrıntılı cevaplarla çelişmemek. Bu yanıt, eşzamanlılık sorunlarının yanı sıra, ConcurrentHashMap ile HashMap arasında en az bir API farkı olduğunu ve bunun da diğeriyle değiştirilen tek iş parçacıklı bir programı bile bozabileceğini belirtmek için tasarlanmıştır.]

http://www.docjar.com/html/api/java/util/HashMap.java.html

İşte HashMap kaynağı. Anlayacağınız gibi, kesinlikle hiçbir kilitleme / muteks kodu yoktur.

Bu, çok iş parçacıklı bir durumda bir HashMap'ten okumak iyi olsa da, birden fazla yazma olsaydı kesinlikle bir ConcurrentHashMap kullanacağım anlamına gelir.

İlginç olan şey hem .NET HashTable hem de Sözlük <K, V> senkronizasyon kodunda yerleşik olmasıdır.

Başlatma ve her koyma senkronize edilmişse kaydedersiniz.

Sınıf yükleyici senkronizasyonla ilgileneceğinden aşağıdaki kod kaydedilir:

public static final HashMap<String, String> map = new HashMap<>();
static {
  map.put("A","A");

}

Aşağıdaki kod kaydedilir, çünkü uçucu yazı senkronizasyonu halleder.

class Foo {
  volatile HashMap<String, String> map;
  public void init() {
    final HashMap<String, String> tmp = new HashMap<>();
    tmp.put("A","A");
    // writing to volatile has to be after the modification of the map
    this.map = tmp;
  }
}

Üye değişkeni son ise bu da işe yarar çünkü final de değişkendir. Ve eğer yöntem bir kurucu ise.