Chủ đề xây dựng tĩnh C # có an toàn không?

Nói cách khác, chủ đề triển khai Singleton này có an toàn không:

public class Singleton
{
    private static Singleton instance;

    private Singleton() { }

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

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

Các hàm tạo tĩnh được đảm bảo chỉ được chạy một lần cho mỗi miền ứng dụng, trước khi bất kỳ phiên bản nào của lớp được tạo hoặc bất kỳ thành viên tĩnh nào được truy cập. https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/groupes-and-structs/static-constructor

Việc triển khai được hiển thị là luồng an toàn cho việc xây dựng ban đầu, nghĩa là không yêu cầu kiểm tra khóa hoặc null để xây dựng đối tượng Singleton. Tuy nhiên, điều này không có nghĩa là bất kỳ việc sử dụng thể hiện nào sẽ được đồng bộ hóa. Có nhiều cách khác nhau để làm điều này; Tôi đã chỉ ra một cái bên dưới.

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

Trong khi tất cả các câu trả lời này đều đưa ra cùng một câu trả lời chung, có một lời cảnh báo.

Hãy nhớ rằng tất cả các dẫn xuất tiềm năng của một lớp chung được biên dịch thành các loại riêng lẻ. Vì vậy, hãy thận trọng khi thực hiện các hàm tạo tĩnh cho các loại chung.

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

BIÊN TẬP:

Đây là cuộc biểu tình:

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

Trong bảng điều khiển:

Hit System.Object
Hit System.String

Sử dụng một constructor tĩnh thực sự là chủ đề an toàn. Hàm tạo tĩnh được đảm bảo chỉ được thực hiện một lần.

Từ đặc tả ngôn ngữ C # :

Hàm tạo tĩnh cho một lớp thực thi nhiều nhất một lần trong một miền ứng dụng nhất định. Việc thực thi một hàm tạo tĩnh được kích hoạt bởi sự kiện đầu tiên sau đây xảy ra trong một miền ứng dụng:

• Một thể hiện của lớp được tạo ra.
• Bất kỳ thành viên tĩnh nào của lớp đều được tham chiếu.

Vì vậy, có, bạn có thể tin tưởng rằng singleton của bạn sẽ được khởi tạo chính xác.

Zooba đã đưa ra một điểm tuyệt vời (và 15 giây trước tôi nữa!) Rằng nhà xây dựng tĩnh sẽ không đảm bảo quyền truy cập được chia sẻ an toàn theo luồng cho người độc thân. Điều đó sẽ cần phải được xử lý theo cách khác.

Đây là phiên bản Cliffnotes từ trang MSDN ở trên trên c # singleton:

Sử dụng mẫu sau, luôn luôn, bạn không thể sai:

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

   private Singleton(){}

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

Ngoài các tính năng đơn lẻ rõ ràng, nó cung cấp cho bạn hai điều này miễn phí (đối với singleton trong c ++):

1. lười xây dựng (hoặc không xây dựng nếu nó không bao giờ được gọi)
2. đồng bộ hóa

Các nhà xây dựng tĩnh được đảm bảo chỉ bắn một lần cho mỗi Miền ứng dụng để cách tiếp cận của bạn sẽ ổn. Tuy nhiên, về mặt chức năng nó không khác với phiên bản nội tuyến ngắn gọn hơn:

private static readonly Singleton instance = new Singleton();

An toàn chủ đề là một vấn đề khi bạn đang lười biếng khởi tạo mọi thứ.

Hàm tạo tĩnh sẽ kết thúc chạy trước khi bất kỳ luồng nào được phép truy cập vào lớp.

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

Các mã ở trên tạo ra kết quả dưới đây.

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

Mặc dù hàm tạo tĩnh mất nhiều thời gian để chạy, các luồng khác dừng lại và chờ đợi. Tất cả các luồng đọc giá trị của _x được đặt ở dưới cùng của hàm tạo tĩnh.

Đặc tả cơ sở hạ tầng ngôn ngữ chung đảm bảo rằng "trình khởi tạo kiểu sẽ chạy chính xác một lần cho bất kỳ loại đã cho nào, trừ khi được gọi rõ ràng bằng mã người dùng." . và thuộc tính Instance của bạn là an toàn chủ đề.

Lưu ý rằng nếu hàm tạo của Singleton truy cập thuộc tính Instance (thậm chí gián tiếp) thì thuộc tính Instance sẽ là null. Điều tốt nhất bạn có thể làm là phát hiện khi điều này xảy ra và đưa ra một ngoại lệ, bằng cách kiểm tra trường hợp đó là không null trong trình truy cập thuộc tính. Sau khi hàm tạo tĩnh của bạn hoàn thành, thuộc tính Instance sẽ không null.

Như câu trả lời của Zoomba chỉ ra, bạn sẽ cần làm cho Singleton an toàn để truy cập từ nhiều luồng hoặc thực hiện cơ chế khóa xung quanh bằng cách sử dụng cá thể singleton.

Chỉ là mô phạm, nhưng không có thứ gọi là hàm tạo tĩnh, mà là các bộ khởi tạo kiểu tĩnh, đây là một bản demo nhỏ của phụ thuộc hàm tạo tĩnh tuần hoàn minh họa điểm này.

Xây dựng tĩnh được đảm bảo là chủ đề an toàn. Ngoài ra, hãy xem cuộc thảo luận về Singleton tại DeveloperZen: http://www.developerzen.com/2007/07/15/whats-wrong-with-this-code-1-discussion/

Mặc dù các câu trả lời khác hầu hết là đúng, nhưng vẫn có một cảnh báo khác với các hàm tạo tĩnh.

Theo phần II.10.5.3.3 Các chủng tộc và sự bế tắc của Cơ sở hạ tầng ngôn ngữ chung ECMA-335

Chỉ riêng việc khởi tạo kiểu sẽ không tạo ra bế tắc trừ khi một số mã được gọi từ trình khởi tạo kiểu (trực tiếp hoặc gián tiếp) gọi rõ ràng các hoạt động chặn.

Đoạn mã sau dẫn đến bế tắc

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

Tác giả gốc là Igor Ostrovsky, xem bài viết của mình ở đây .