Uçucuya Karşı Kilitli ve Kilitli

Diyelim ki bir sınıfın public int counterbirden çok iş parçacığı tarafından erişilen bir alanı var. Bu intyalnızca artırılır veya azaltılır.

Bu alanı arttırmak için hangi yaklaşım kullanılmalı ve neden?

• lock(this.locker) this.counter++;,
• Interlocked.Increment(ref this.counter);,
• Erişim değiştiricisini olarak counterdeğiştirin public volatile.

Şimdi keşfettiğime göre volatile, birçok lockifadeyi ve kullanımını kaldırdım Interlocked. Ama bunu yapmamak için bir neden var mı?

En kötü (aslında çalışmaz)

Erişim değiştiricisini olarak counterdeğiştirpublic volatile

Diğer insanların belirttiği gibi, bu tek başına aslında güvenli değildir. Bunun anlamı, volatilebirden fazla CPU üzerinde çalışan birden çok iş parçacığının verileri önbelleğe alıp talimatlarını yeniden sıralayabilmesidir.

Eğer öyleyse değil volatile , ve CPU A değerini artırır, daha sonra CPU B aslında sorunlara neden olabilir daha sonra bir süre, kadar bu arttırılmış değer göremeyebilirsiniz.

Öyleyse volatile, bu sadece iki CPU'nun aynı anda aynı verileri görmesini sağlar. Onlardan kaçınmaya çalıştığınız sorun olan okuma ve yazma işlemlerini bırakmasını engellemez.

En iyi ikinci:

lock(this.locker) this.counter++;

Bunu yapmak güvenlidir ( lockeriştiğiniz her yere hatırlamanız koşuluyla this.counter). Diğer tüm evreler tarafından korunan diğer kodların yürütülmesini engeller locker. Kilitleri kullanarak, yukarıdaki gibi çoklu CPU yeniden sıralama sorunlarını önler, bu harika.

Sorun, kilitleme yavaş ve eğer lockergerçekten ilgili olmayan başka bir yerde yeniden kullanırsanız, o zaman diğer ipliklerinizi hiçbir sebeple bloke edebilirsiniz.

En iyi

Interlocked.Increment(ref this.counter);

Bu, güvenli bir şekilde kesilemeyen 'tek vuruşta' okuma, arttırma ve yazma işlemlerini yaptığı için güvenlidir. Bu nedenle, diğer kodları etkilemez ve başka bir yerde de kilitlemeyi hatırlamanız gerekmez. Ayrıca çok hızlıdır (MSDN'in söylediği gibi, modern CPU'larda, bu genellikle tam anlamıyla tek bir CPU talimatıdır).

Ancak, diğer CPU'ların bir şeyleri yeniden sıralaması veya geçici olarak artışı ile birleştirmeniz gerekiyorsa emin değilim.

InterlockedNotes:

1. İNTERLOK EDİLMİŞ YÖNTEMLER HERHANGİ BİR ÇEKİRDEK VEYA İŞLEMCİ ÜZERİNDE TAMAMEN GÜVENLİDİR.
2. Kilitli yöntemler, yürüttükleri talimatların etrafına tam bir çit uygular, bu nedenle yeniden sıralama gerçekleşmez.
3. Birbirine kenetlenmiş yöntemlerin uçucu bir alana erişime ihtiyacı yoktur ve hatta desteklemezler , çünkü uçucu verilen alandaki işlemlerin etrafına yarım bir çit yerleştirilir ve kenetlenmiş tam çit kullanılır.

Dipnot: Uçucu olan aslında ne işe yarar.

As volatileiçin bu kadar ne mulithread bu tür konuları engellemez? İyi bir örnek, biri her zaman bir değişkene (diyelim queueLength) ve diğeri her zaman aynı değişkenten okuyan iki iş parçacığına sahip olduğunuzu söylemektir .

queueLengthUçucu değilse , A iş parçacığı beş kez yazabilir, ancak B iş parçacığı bu yazma işlemlerini geciktirildiğini (hatta potansiyel olarak yanlış sırada) görebilir.

Bir çözüm kilitlemek olacaktır, ancak bu durumda uçucu da kullanabilirsiniz. Bu, B iş parçacığının her zaman A iş parçacığının yazdığı en güncel şeyi görmesini sağlar. Not Ancak bu mantık o sadece yazdığınız asla hiç okumamış yazarlar ve okuyucular varsa, işler ve şey sen yazma atomik değeri ise. Tek bir okuma-değiştirme-yazma işlemi yaptığınızda, Kilitli işlemlere gitmeniz veya bir Kilit kullanmanız gerekir.

EDIT: Yorumlarda belirtildiği gibi, bugünlerde açıkçası iyi olduğu tek bir değişkenInterlocked durumlarda kullanmak için mutluyum . Daha karmaşık hale geldiğinde, yine de kilitlemeye döneceğim ...

Artırmanız volatilegerektiğinde kullanmak yardımcı olmaz - çünkü okuma ve yazma ayrı talimatlardır. Başka bir evre, okuduktan sonra ancak tekrar yazmadan önce değeri değiştirebilir.

Şahsen neredeyse her zaman kilitliyorum - açık bir şekilde volatilite veya İnterloktan daha doğru bir şekilde almak daha kolaydır . Benim endişe duyduğum kadarıyla, kilitsiz çoklu iş parçacığı gerçek iş parçacığı uzmanları içindir, ki ben değilim. Joe Duffy ve ekibi, inşa edeceğim bir şey kadar kilitlemeden şeyleri paralelleştirecek güzel kütüphaneler inşa ederse, bu muhteşem ve bunu bir kalp atışı içinde kullanacağım - ancak diş açarken kendimi yapmaya çalışıyorum basit olsun.

" volatile" yerine geçmiyor Interlocked.Increment! Sadece değişkenin önbelleğe alınmamasını, doğrudan kullanılmasını sağlar.

Bir değişkeni artırmak aslında üç işlem gerektirir:

1. okumak
2. artım
3. yazmak

Interlocked.Increment üç parçayı da tek bir atomik işlem olarak gerçekleştirir.

Kilit ya da kilitli artış aradığınız şeydir.

Uçucu kesinlikle peşinde olduğunuz şey değildir - sadece geçerli kod yolu derleyicinin bellekten bir okumayı optimize etmesine izin verse bile, derleyiciye değişkeni her zaman değişen olarak ele almasını söyler.

Örneğin

while (m_Var)
{ }

m_Var başka bir iş parçacığında false değerine ayarlanırsa ancak uçucu olarak bildirilmezse, derleyici, CPU kaydına (örneğin EAX olduğu için m_Var'ın bellek konumuna başka bir okuma yapmak yerine (bu önbelleklenebilir - biz bilmiyoruz ve umursamıyoruz ve bu x86 / x64'ün önbellek tutarlılığının noktası). Talimatların yeniden sıralanmasından bahseden diğerleri tarafından daha önce gönderilen tüm yayınlar, x86 / x64 mimarilerini anlamadıklarını gösteriyor. Uçucu değil'Yeniden sıralamayı önler' diyerek önceki gönderilerin ima ettiği gibi okuma / yazma engelleri çıkarır. Aslında, yine MESI protokolü sayesinde, gerçek sonuçların fiziksel belleğe bırakılmış olmasına veya sadece yerel CPU'nun önbelleğinde bulunmasına bakılmaksızın, okuduğumuz sonucun CPU'lar arasında her zaman aynı olduğu garanti edilir. Bunun ayrıntılarına çok fazla girmeyeceğim, ancak bu yanlış giderse Intel / AMD'nin muhtemelen bir işlemci geri çağrısı yapacağından emin olabilirsiniz! Bu aynı zamanda sıra dışı yürütme vb. İle ilgilenmemiz gerekmediği anlamına gelir. Sonuçlar her zaman sırayla emekli olur - aksi takdirde doldurulur!

Kilitli Artım ile, işlemcinin dışarı çıkması, verilen adresten değeri alması, daha sonra artırması ve geri yazması gerekir - tüm bunlar, başka hiçbir işlemcinin değiştiremeyeceğinden emin olmak için tüm önbellek satırının (sahiplik xadd) özel mülkiyetine sahipken Değeri.

Uçucu ile, yine de sadece 1 talimat alacaksınız (JIT'in olması gerektiği gibi verimli olduğu varsayılarak) - inc dword ptr [m_Var]. Bununla birlikte, işlemci (cpuA), kilitli sürümle yaptığı her şeyi yaparken önbellek hattının münhasır sahipliğini istemez. Tahmin edebileceğiniz gibi, bu, diğer işlemcilerin cpuA tarafından okunduktan sonra m_Var'a güncellenmiş bir değer yazabileceği anlamına gelir. Şimdi değeri iki kez artırmak yerine, sadece bir kez elde edersiniz.

Umarım bu sorunu giderir.

Daha fazla bilgi için, bkz. 'Çok İş Parçacıklı Uygulamalarda Düşük Kilit Tekniklerinin Etkisini Anlama' - http://msdn.microsoft.com/en-au/magazine/cc163715.aspx

ps Ne bu çok geç cevap istedi? Tüm cevaplar çok açık bir şekilde yanlış (özellikle bir cevap olarak işaretlenmiş) açıklamalarında sadece bunu okuyan herkes için temizlemek zorunda kaldı. silkiyor

pps Hedefin IA64 değil x86 / x64 olduğunu varsayıyorum (farklı bir bellek modeli var). Microsoft'un ECMA spesifikasyonlarının en güçlü olanı yerine en zayıf bellek modelini belirtmesi nedeniyle berbat edildiğini unutmayın (platformlar arasında tutarlı olması için en güçlü bellek modeline karşı her zaman daha iyidir - aksi takdirde x86'da 24-7 çalışacak kod Intel, IA64 için benzer şekilde güçlü bir bellek modeli uygulamasına rağmen x64, IA64 üzerinde hiç çalışmayabilir) - Microsoft bunu kabul etti - http://blogs.msdn.com/b/cbrumme/archive/2003/05/17/51445.aspx .

Kilitli fonksiyonlar kilitlenmez. Atomiktirler, yani artış sırasında bir bağlamsal geçiş olasılığı olmadan tamamlanabilirler. Yani kilitlenme veya bekleme şansı yok.

Bunu her zaman bir kilit ve artışa tercih etmelisiniz diyebilirim.

Bir iş parçacığında başka bir iş parçacığında okunması gerekiyorsa ve en iyi duruma getiricinin bir değişken üzerindeki işlemleri yeniden sıralamamasını istiyorsanız (en iyi duruma getiricinin bilmediği başka bir iş parçacığında işler olduğu için) Uçucu kullanışlıdır. Nasıl artırdığınıza göre dikey bir seçimdir.

Kilitsiz kod hakkında daha fazla bilgi edinmek ve bunu yazmaya yaklaşmanın doğru yolunu öğrenmek istiyorsanız, bu gerçekten iyi bir makale

http://www.ddj.com/hpc-high-performance-computing/210604448

lock (...) çalışır, ancak bir iş parçacığını engelleyebilir ve başka bir kod aynı kilitleri uyumsuz bir şekilde kullanıyorsa kilitlenmeye neden olabilir.

İnterlocked. * Bunu yapmanın doğru yoludur ... modern CPU'lar bunu ilkel olarak desteklediğinden çok daha az ek yük.

kendi başına uçuculuk doğru değildir. Değiştirilmiş bir değeri alıp geri yazmaya çalışan bir iş parçacığı yine de bunu yapan başka bir iş parçacığı ile çakışabilir.

Teorinin nasıl çalıştığını görmek için bazı testler yaptım: kennethxu.blogspot.com/2009/05/interlocked-vs-monitor-performance.html . Testim CompareExchnage'a daha fazla odaklandı, ancak Artış sonucu benzer. Kilitli çoklu işlemci ortamında daha hızlı gerekli değildir. İşte 2 yıllık 16 CPU sunucusunda Increment için test sonucu. Testin, gerçek dünyada tipik olan artıştan sonra güvenli okumayı da içerdiğini unutmayın.

D:\>InterlockVsMonitor.exe 16
Using 16 threads:
          InterlockAtomic.RunIncrement         (ns):   8355 Average,   8302 Minimal,   8409 Maxmial
    MonitorVolatileAtomic.RunIncrement         (ns):   7077 Average,   6843 Minimal,   7243 Maxmial

D:\>InterlockVsMonitor.exe 4
Using 4 threads:
          InterlockAtomic.RunIncrement         (ns):   4319 Average,   4319 Minimal,   4321 Maxmial
    MonitorVolatileAtomic.RunIncrement         (ns):    933 Average,    802 Minimal,   1018 Maxmial

Jon Skeet'in cevabını ikinci olarak verdim ve "geçici" ve İnterlok hakkında daha fazla bilgi edinmek isteyen herkes için aşağıdaki bağlantıları eklemek istiyorum:

Atomisite, uçuculuk ve değişmezlik farklı, birinci bölüm - (Eric Lippert'in Kodlamadaki Muhteşem Maceraları)

Atomisite, uçuculuk ve değişmezlik farklı, ikinci kısım

Atomisite, uçuculuk ve değişmezlik farklıdır, bölüm üç

Sayonara Volatile - (Joe Duffy Weblog'un 2012'de göründüğü gibi Wayback Machine anlık görüntüsü)

Ben fark arasındaki diğer cevaplar belirtilen eklemek istiyorum volatile, Interlockedve lock:

Geçici anahtar kelime, aşağıdaki türdeki alanlara uygulanabilir :

• Referans türleri.
• İşaretçi türleri (güvenli olmayan bir bağlamda). İşaretçinin kendisi değişken olabilse de, işaret ettiği nesnenin yapamayacağını unutmayın. Başka bir deyişle, bir "işaretçi" nin "geçici" olduğunu bildiremezsiniz.
• Gibi basit türleri sbyte, byte, short, ushort, int, uint, char, float, ve bool.
• Aşağıdaki temel türlerinden biri olan bir numaralama türü: byte, sbyte, short, ushort, intya da uint.
• Referans türleri olduğu bilinen genel tip parametreleri.
• IntPtrve UIntPtr.

Diğer tür de dahil olmak üzere, doubleve long, okur ve bu türde alanlara yazma atomik olması garanti edilemez çünkü "uçucu" işaretli edilemez. Bu tür alanlara çok iş parçacıklı erişimi korumak için, Interlockedsınıf üyelerini kullanın veya lockifadeyi kullanarak erişimi koruyun .