คอนสตรัคเตอร์ C # คงที่ปลอดภัยหรือไม่?

กล่าวอีกนัยหนึ่งเธรดการใช้งานซิงเกิลนี้ปลอดภัยหรือไม่:

public class Singleton
{
    private static Singleton instance;

    private Singleton() { }

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

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

ตัวสร้างแบบสแตติกรับประกันว่าจะรันเพียงหนึ่งครั้งต่อโดเมนแอปพลิเคชันก่อนที่อินสแตนซ์ใด ๆ ของคลาสจะถูกสร้างขึ้นหรือมีการเข้าถึงสมาชิกแบบคงที่ใด ๆ https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/static-constructors

การนำไปใช้งานที่แสดงนั้นเป็นเธรดที่ปลอดภัยสำหรับการก่อสร้างเริ่มต้นกล่าวคือไม่จำเป็นต้องมีการทดสอบการล็อกหรือโมฆะสำหรับการสร้างวัตถุ Singleton อย่างไรก็ตามนี่ไม่ได้หมายความว่าการใช้งานอินสแตนซ์ใด ๆ จะถูกซิงโครไนซ์ มีหลายวิธีที่สามารถทำได้ ฉันได้แสดงไว้ด้านล่าง

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();
    }
}

ในขณะที่คำตอบทั้งหมดเหล่านี้ให้คำตอบทั่วไปเหมือนกัน แต่ก็มีข้อแม้หนึ่งข้อ

โปรดจำไว้ว่าการสืบทอดที่เป็นไปได้ทั้งหมดของคลาสทั่วไปนั้นได้รับการรวบรวมเป็นประเภทบุคคล ดังนั้นควรใช้ความระมัดระวังเมื่อใช้ตัวสร้างสแตติกสำหรับประเภททั่วไป

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

แก้ไข:

นี่คือการสาธิต:

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()));        
    }
}

ในคอนโซล:

Hit System.Object
Hit System.String

การใช้ตัวสร้างสแตติกจริง ๆ แล้วเป็น threadsafe ตัวสร้างแบบคงที่รับประกันว่าจะดำเนินการเพียงครั้งเดียว

จากข้อกำหนดภาษา C # :

ตัวสร้างแบบคงที่สำหรับคลาสดำเนินการอย่างมากที่สุดในโดเมนแอปพลิเคชันที่กำหนด การดำเนินการของตัวสร้างแบบคงที่จะถูกเรียกโดยเหตุการณ์แรกของเหตุการณ์ต่อไปนี้ที่จะเกิดขึ้นภายในแอปพลิเคชันโดเมน:

• ตัวอย่างของการเรียนที่ถูกสร้างขึ้น
• สมาชิกแบบสแตติกของคลาสใด ๆ ที่ถูกอ้างถึง

ใช่คุณสามารถมั่นใจได้ว่าซิงเกิลตันของคุณจะถูกสร้างขึ้นอย่างถูกต้อง

Zooba ทำคะแนนได้อย่างยอดเยี่ยม (และ 15 วินาทีต่อหน้าฉันด้วย!) ที่ตัวสร้างสแตติกจะไม่รับประกันการเข้าถึงที่แชร์แบบปลอดภัยต่อเธรดไปยังซิงเกิล ที่จะต้องมีการจัดการในลักษณะอื่น

นี่คือเวอร์ชั่น Cliffnotes จากหน้า MSDN ด้านบนใน c # singleton:

ใช้รูปแบบต่อไปนี้เสมอคุณจะไม่ผิดพลาด:

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

   private Singleton(){}

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

นอกเหนือจากคุณสมบัติซิงเกิลที่เห็นได้ชัดมันให้สองสิ่งนี้ฟรี (สำหรับซิงเกิลตันใน c ++):

1. สันหลังยาวก่อสร้าง (หรือไม่มีการก่อสร้างถ้ามันไม่เคยเรียก)
2. การประสาน

ตัวสร้างแบบคงที่รับประกันว่าจะใช้งานได้เพียงหนึ่งครั้งต่อ App Domain ดังนั้นแนวทางของคุณควรจะดี อย่างไรก็ตามมันไม่แตกต่างจากเวอร์ชั่นอินไลน์ที่กระชับกว่านี้:

private static readonly Singleton instance = new Singleton();

ความปลอดภัยของเธรดเป็นปัญหามากกว่าเมื่อคุณเริ่มต้นสิ่งต่างๆอย่างขี้เกียจ

ตัวสร้างแบบสแตติกจะเสร็จสิ้นการรันก่อนที่เธรดใด ๆ จะได้รับอนุญาตให้เข้าถึงคลาส

    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();
    }

รหัสด้านบนสร้างผลลัพธ์ด้านล่าง

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).

แม้ว่าตัวสร้างแบบสแตติกใช้เวลานานในการรันเธรดอื่นจะหยุดและรอ กระทู้ทั้งหมดอ่านค่าของชุด _x ที่ด้านล่างของตัวสร้างสแตติก

ภาษาทั่วไปข้อกำหนดโครงสร้างพื้นฐานรับประกันว่า "ประเภท initializer จะวิ่งครั้งว่าสำหรับประเภทใดก็ตามเว้นแต่เรียกว่าอย่างชัดเจนโดยผู้ใช้รหัส." (มาตรา 9.5.3.1.) ดังนั้นหากคุณไม่มี IL บางตัวในการเรียก Singleton ::. cctor โดยตรง (ไม่น่าเป็นไปได้) Constructor แบบคงที่ของคุณจะทำงานอย่างแน่นอนหนึ่งครั้งก่อนที่จะใช้ Singleton type เพียงครั้งเดียวของ Singleton จะถูกสร้างขึ้น และคุณสมบัติอินสแตนซ์ของคุณปลอดภัยสำหรับเธรด

โปรดทราบว่าหากตัวสร้างของ Singleton เข้าถึงคุณสมบัติอินสแตนซ์ (แม้โดยทางอ้อม) คุณสมบัติอินสแตนซ์จะเป็นโมฆะ สิ่งที่ดีที่สุดที่คุณสามารถทำได้คือการตรวจจับเมื่อสิ่งนี้เกิดขึ้นและส่งข้อยกเว้นโดยตรวจสอบว่าอินสแตนซ์นั้นไม่เป็นโมฆะในตัวเข้าถึงคุณสมบัติ หลังจากตัวสร้างสแตติกของคุณเสร็จสมบูรณ์คุณสมบัติอินสแตนซ์จะไม่เป็นโมฆะ

เมื่อคำตอบของ Zoombaชี้ให้เห็นคุณจะต้องทำให้ Singleton ปลอดภัยในการเข้าถึงจากหลายเธรดหรือใช้กลไกการล็อกโดยใช้อินสแตนซ์ซิงเกิล

เพื่อจะอวดความรู้ แต่ไม่มีสิ่งนี้ในฐานะตัวสร้างแบบคงที่ แต่เป็นตัวเริ่มต้นแบบคงที่ แต่นี่คือตัวอย่างเล็ก ๆของการพึ่งพาตัวสร้างแบบคงที่ของวงจรซึ่งแสดงให้เห็นถึงจุดนี้

ตัวสร้างแบบคงที่รับประกันความปลอดภัยของเธรด นอกจากนี้ตรวจสอบการอภิปรายเกี่ยวกับซิงเกิลที่ DeveloperZen: http://web.archive.org/web/20160404231134/http://www.developerzen.com/2007/07/15/whats-wrong-with-this-code -1-อภิปราย /

แม้ว่าคำตอบอื่น ๆ ส่วนใหญ่จะถูกต้อง แต่ก็มีข้อแม้อื่นที่มีตัวสร้างแบบคงที่

ตามหัวข้อII.10.5.3.3 การแข่งขันและการหยุดชะงักของโครงสร้างพื้นฐานภาษาสามัญ ECMA-335

การเริ่มต้นประเภทอย่างเดียวจะต้องไม่สร้างการหยุดชะงักเว้นแต่ว่าบางรหัสที่เรียกจากตัวเริ่มต้นประเภท (โดยตรงหรือโดยอ้อม) จะเรียกใช้การบล็อกอย่างชัดเจน

โค้ดต่อไปนี้ส่งผลให้เกิดการหยุดชะงัก

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();
    }
}

ผู้เขียนต้นฉบับคืออิกอร์รอฟสกี, เห็นโพสต์ของเขาที่นี่