C # statik yapıcı iş parçacığı güvenli midir?

Başka bir deyişle, bu Singleton uygulama iş parçacığı güvenli midir:

public class Singleton
{
    private static Singleton instance;

    private Singleton() { }

    static Singleton()
    {
        instance = new Singleton();
    }

    public static Singleton Instance
    {
        get { return instance; }
    }
}

Statik kurucuların, bir sınıfın herhangi bir örneği oluşturulmadan veya statik üyelere erişilmeden önce her uygulama etki alanı için yalnızca bir kez çalıştırılacağı garanti edilir. https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/static-constructors

Gösterilen uygulama, ilk konstrüksiyon için diş açmaya karşı güvenlidir, yani Singleton nesnesinin oluşturulması için herhangi bir kilitleme veya null test gerekli değildir. Ancak bu, örneğin herhangi bir kullanımının senkronize edileceği anlamına gelmez. Bunun yapılabileceği çeşitli yollar vardır; Aşağıda bir tane gösterdim.

public class Singleton
{
    private static Singleton instance;
    // Added a static mutex for synchronising use of instance.
    private static System.Threading.Mutex mutex;
    private Singleton() { }
    static Singleton()
    {
        instance = new Singleton();
        mutex = new System.Threading.Mutex();
    }

    public static Singleton Acquire()
    {
        mutex.WaitOne();
        return instance;
    }

    // Each call to Acquire() requires a call to Release()
    public static void Release()
    {
        mutex.ReleaseMutex();
    }
}

Bütün bu cevaplar aynı genel cevabı verirken bir uyarı var.

Genel bir sınıfın tüm potansiyel türevlerinin bireysel türler olarak derlendiğini unutmayın. Bu nedenle, genel türler için statik yapıcılar uygularken dikkatli olun.

class MyObject<T>
{
    static MyObject() 
    {
       //this code will get executed for each T.
    }
}

DÜZENLE:

İşte gösteri:

static void Main(string[] args)
{
    var obj = new Foo<object>();
    var obj2 = new Foo<string>();
}

public class Foo<T>
{
    static Foo()
    {
         System.Diagnostics.Debug.WriteLine(String.Format("Hit {0}", typeof(T).ToString()));        
    }
}

Konsolda:

Hit System.Object
Hit System.String

Aslında statik yapıcı kullanılması olduğunu threadsafe. Statik kurucunun yalnızca bir kez yürütülmesi garanti edilir.

C # dil spesifikasyonundan :

Bir sınıfın statik yapıcısı, belirli bir uygulama etki alanında en fazla bir kez yürütülür. Statik bir kurucunun yürütülmesi, bir uygulama etki alanında gerçekleşen aşağıdaki olayların ilki tarafından tetiklenir:

• Sınıfın bir örneği oluşturulur.
• Sınıfın statik üyelerinden herhangi birine başvurulur.

Yani evet, singletonunuzun doğru bir şekilde başlatılacağına güvenebilirsiniz.

Zooba mükemmel bir noktaya değindi (ve benden 15 saniye önce!), Statik kurucunun singleton'a iş parçacığı için güvenli paylaşılan erişimi garanti etmeyeceği. Bunun başka bir şekilde ele alınması gerekecektir.

İşte c # singleton'ın yukarıdaki MSDN sayfasındaki Cliffnotes sürümü:

Aşağıdaki modeli kullanın, her zaman yanlış gidemezsiniz:

public sealed class Singleton
{
   private static readonly Singleton instance = new Singleton();

   private Singleton(){}

   public static Singleton Instance
   {
      get 
      {
         return instance; 
      }
   }
}

Belirgin singleton özelliklerinin ötesinde, bu iki şeyi ücretsiz olarak verir (c ++ 'daki singleton ile ilgili olarak):

1. tembel inşaat (veya hiç çağrılmadıysa inşaat yok)
2. senkronizasyon

Statik kurucuların her bir Uygulama Etki Alanı için yalnızca bir kez tetikleneceği garanti edilir, bu nedenle yaklaşımınız iyi olmalıdır. Ancak, işlevsel olarak daha özlü, satır içi sürümden farklı değildir:

private static readonly Singleton instance = new Singleton();

İşleri tembel olarak başlatırken iş parçacığı güvenliği daha önemli bir konudur.

Statik kurucu sınıfa erişmesine izin verilmeden önce çalışmayı bitirir .

    private class InitializerTest
    {
        static private int _x;
        static public string Status()
        {
            return "_x = " + _x;
        }
        static InitializerTest()
        {
            System.Diagnostics.Debug.WriteLine("InitializerTest() starting.");
            _x = 1;
            Thread.Sleep(3000);
            _x = 2;
            System.Diagnostics.Debug.WriteLine("InitializerTest() finished.");
        }
    }

    private void ClassInitializerInThread()
    {
        System.Diagnostics.Debug.WriteLine(Thread.CurrentThread.GetHashCode() + ": ClassInitializerInThread() starting.");
        string status = InitializerTest.Status();
        System.Diagnostics.Debug.WriteLine(Thread.CurrentThread.GetHashCode() + ": ClassInitializerInThread() status = " + status);
    }

    private void classInitializerButton_Click(object sender, EventArgs e)
    {
        new Thread(ClassInitializerInThread).Start();
        new Thread(ClassInitializerInThread).Start();
        new Thread(ClassInitializerInThread).Start();
    }

Yukarıdaki kod aşağıdaki sonuçları üretmiştir.

10: ClassInitializerInThread() starting.
11: ClassInitializerInThread() starting.
12: ClassInitializerInThread() starting.
InitializerTest() starting.
InitializerTest() finished.
11: ClassInitializerInThread() status = _x = 2
The thread 0x2650 has exited with code 0 (0x0).
10: ClassInitializerInThread() status = _x = 2
The thread 0x1f50 has exited with code 0 (0x0).
12: ClassInitializerInThread() status = _x = 2
The thread 0x73c has exited with code 0 (0x0).

Statik kurucunun çalışması uzun sürmesine rağmen, diğer dişler durdu ve bekledi. Tüm evreler statik kurucunun alt kısmında ayarlanan _x değerini okur.

Ortak Dil Altyapı şartname garanti olduğunu "açıkça kullanıcı koduyla adlandırılan sürece, herhangi bir tür için tam olarak bir kez çalıştırmak zorundadır başlatıcısı türüdür." (Kısım 9.5.3.1.) Bu nedenle, doğrudan çağrıda bulunan Singleton ::. Cctor üzerinde biraz zorlayıcı IL yoksa, statik kurucunuz Singleton türü kullanılmadan önce tam olarak bir kez çalışır, yalnızca bir Singleton örneği oluşturulur, ve Instance özelliğiniz iş parçacığı için güvenlidir.

Singleton yapıcısı Instance özelliğine (dolaylı olarak da olsa) erişirse, Instance özelliğinin null olacağını unutmayın. Yapabileceğiniz en iyi şey, bunun gerçekleştiğini algılamak ve özellik erişimcisinde bu örneğin null olmadığını kontrol ederek bir istisna atmaktır. Statik kurucunuz tamamlandıktan sonra Instance özelliği null olmayacaktır.

As Zoomba cevabı size Puan birden çok iş parçacığı erişim Singleton kasa yapmak veya tekil örneğini kullanarak etrafında bir kilitleme mekanizması uygulamak gerekir.

Sadece bilgiçlikçi olmakla birlikte, statik bir kurucu olarak değil, statik tip başlatıcılar diye bir şey yoktur, işte bu noktayı gösteren döngüsel statik kurucu bağımlılığının küçük bir demosu.

Statik oluşturucunun diş güvenli olması garanti edilir. Ayrıca, DeveloperZen'deki Singleton hakkındaki tartışmaya göz atın: http://web.archive.org/web/20160404231134/http://www.developerzen.com/2007/07/15/whats-wrong-with-this-code -1 tartışma /

Diğer cevaplar çoğunlukla doğru olmasına rağmen, statik yapıcılarla başka bir uyarı daha vardır.

Bölüm gereğince II.10.5.3.3 Yarışları ve çözümsüzlüklerle ait ECMA-335 Ortak Dil Altyapısı

Bir tür başlatıcıdan (doğrudan veya dolaylı olarak) çağrılan bazı kodlar açıkça engelleme işlemlerini başlatmadığı sürece, yalnızca tür başlatma bir kilitlenme oluşturmaz.

Aşağıdaki kod bir kilitlenmeyle sonuçlanır

using System.Threading;
class MyClass
{
    static void Main() { /* Won’t run... the static constructor deadlocks */  }

    static MyClass()
    {
        Thread thread = new Thread(arg => { });
        thread.Start();
        thread.Join();
    }
}

Orijinal yazar Igor Ostrovsky, yazısına bakın buradan .