Sự cần thiết của công cụ sửa đổi dễ bay hơi trong khóa kiểm tra hai lần trong .NET

Nhiều văn bản nói rằng khi triển khai khóa được kiểm tra hai lần trong .NET, trường bạn đang khóa phải được áp dụng công cụ sửa đổi dễ bay hơi. Nhưng chính xác là tại sao? Xem xét ví dụ sau:

public sealed class Singleton
{
   private static volatile Singleton instance;
   private static object syncRoot = new Object();

   private Singleton() {}

   public static Singleton Instance
   {
      get 
      {
         if (instance == null) 
         {
            lock (syncRoot) 
            {
               if (instance == null) 
                  instance = new Singleton();
            }
         }

         return instance;
      }
   }
}

tại sao "khóa (syncRoot)" không đạt được tính nhất quán bộ nhớ cần thiết? Không phải là sau khi câu lệnh "lock" cả đọc và ghi đều sẽ biến động và do đó, sự nhất quán cần thiết sẽ được thực hiện?

Dễ bay hơi là không cần thiết. Chà, đại loại là **

volatileđược sử dụng để tạo hàng rào bộ nhớ * giữa các lần đọc và ghi trên biến.
lock, khi được sử dụng, gây ra các rào cản bộ nhớ được tạo ra xung quanh khối bên trong lock, ngoài việc giới hạn quyền truy cập vào khối trong một luồng.
Rào cản bộ nhớ khiến mỗi luồng đọc giá trị hiện tại nhất của biến (không phải giá trị cục bộ được lưu trong một số thanh ghi) và trình biên dịch không sắp xếp lại các câu lệnh. Việc sử dụng volatilelà không cần thiết ** vì bạn đã có khóa.

Joseph Albahari giải thích điều này theo cách tốt hơn tôi từng có thể.

Và hãy nhớ xem hướng dẫn của Jon Skeet để triển khai singleton trong C #

update :
* volatilekhiến các lần đọc biến là VolatileReads và ghi là VolatileWrites, trên x86 và x64 trên CLR, được thực hiện với a MemoryBarrier. Chúng có thể được phân loại tốt hơn trên các hệ thống khác.

** câu trả lời của tôi chỉ đúng nếu bạn đang sử dụng CLR trên bộ xử lý x86 và x64. Nó có thể đúng trong các mô hình bộ nhớ khác, như trên Mono (và các triển khai khác), Itanium64 và phần cứng trong tương lai. Đây là những gì Jon đang đề cập đến trong bài viết của anh ấy trong "gotchas" cho khóa được kiểm tra hai lần.

Thực hiện một trong {đánh dấu biến là volatile, đọc nó bằng Thread.VolatileReadhoặc chèn lệnh gọi tới Thread.MemoryBarrier} có thể cần thiết để mã hoạt động bình thường trong tình huống mô hình bộ nhớ yếu.

Theo những gì tôi hiểu, trên CLR (thậm chí trên IA64), các lần viết không bao giờ được sắp xếp lại (các lần viết luôn có ngữ nghĩa phát hành). Tuy nhiên, trên IA64, các lần đọc có thể được sắp xếp lại thứ tự trước khi ghi, trừ khi chúng được đánh dấu là dễ bay hơi. Thật không may, tôi không có quyền truy cập vào phần cứng IA64 để chơi cùng, vì vậy bất cứ điều gì tôi nói về nó sẽ chỉ là suy đoán.

Tôi cũng thấy những bài viết này hữu ích:
http://www.codeproject.com/KB/tips/MemoryBarrier.aspx
Bài viết của vance morrison (mọi thứ liên kết đến điều này, nó nói về khóa được kiểm tra hai lần)
bài viết của chris brumme (mọi thứ liên kết đến điều này )
Joe Duffy: Các biến thể bị hỏng của khóa được kiểm tra kép

Loạt bài về đa luồng của luis abreu cũng cung cấp một cái nhìn tổng quan tốt đẹp về các khái niệm
http://msmvps.com/blogs/luisabreu/archive/2009/06/29/multithreading-load-and-store-reordering.aspx
http://msmvps. com / blogs / luisabreu / archive / 2009/07/03 / multithreading-Introduction-memory-domains.aspx

Có một cách để thực hiện nó mà không cần volatiletrường. Tôi sẽ giải thích nó ...

Tôi nghĩ rằng việc sắp xếp lại thứ tự truy cập bộ nhớ bên trong khóa là điều nguy hiểm, vì vậy bạn có thể nhận được một phiên bản được khởi tạo không hoàn chỉnh bên ngoài khóa. Để tránh điều này, tôi làm điều này:

public sealed class Singleton
{
   private static Singleton instance;
   private static object syncRoot = new Object();

   private Singleton() {}

   public static Singleton Instance
   {
      get 
      {
         // very fast test, without implicit memory barriers or locks
         if (instance == null)
         {
            lock (syncRoot)
            {
               if (instance == null)
               {
                    var temp = new Singleton();

                    // ensures that the instance is well initialized,
                    // and only then, it assigns the static variable.
                    System.Threading.Thread.MemoryBarrier();
                    instance = temp;
               }
            }
         }

         return instance;
      }
   }
}

Hiểu mã

Hãy tưởng tượng rằng có một số mã khởi tạo bên trong phương thức khởi tạo của lớp Singleton. Nếu các hướng dẫn này được sắp xếp lại thứ tự sau khi trường được đặt bằng địa chỉ của đối tượng mới, thì bạn có một thể hiện chưa hoàn chỉnh ... hãy tưởng tượng rằng lớp có mã này:

private int _value;
public int Value { get { return this._value; } }

private Singleton()
{
    this._value = 1;
}

Bây giờ hãy tưởng tượng một cuộc gọi đến hàm tạo bằng cách sử dụng toán tử mới:

instance = new Singleton();

Điều này có thể được mở rộng cho các hoạt động sau:

ptr = allocate memory for Singleton;
set ptr._value to 1;
set Singleton.instance to ptr;

Điều gì sẽ xảy ra nếu tôi sắp xếp lại các hướng dẫn này như thế này:

ptr = allocate memory for Singleton;
set Singleton.instance to ptr;
set ptr._value to 1;

Liệu nó có làm cho một sự khác biệt? KHÔNG nếu bạn nghĩ về một chủ đề duy nhất. CÓ nếu bạn nghĩ về nhiều chuỗi ... điều gì sẽ xảy ra nếu chuỗi được xen vào ngay sau set instance to ptr:

ptr = allocate memory for Singleton;
set Singleton.instance to ptr;
-- thread interruped here, this can happen inside a lock --
set ptr._value to 1; -- Singleton.instance is not completelly initialized

Đó là điều mà rào cản bộ nhớ tránh được, bằng cách không cho phép sắp xếp lại thứ tự truy cập bộ nhớ:

ptr = allocate memory for Singleton;
set temp to ptr; // temp is a local variable (that is important)
set ptr._value to 1;
-- memory barrier... cannot reorder writes after this point, or reads before it --
-- Singleton.instance is still null --
set Singleton.instance to temp;

Chúc bạn viết mã vui vẻ!

Tôi không nghĩ rằng có ai đó đã thực sự trả lời câu hỏi , vì vậy tôi sẽ thử.

Cái dễ bay hơi và cái đầu tiên if (instance == null)là không "cần thiết". Khóa sẽ làm cho mã này an toàn.

Vì vậy, câu hỏi là: tại sao bạn lại thêm cái đầu tiên if (instance == null)?

Lý do có lẽ là để tránh thực thi đoạn mã bị khóa một cách không cần thiết. Trong khi bạn đang thực thi mã bên trong khóa, bất kỳ luồng nào khác cố gắng thực thi mã đó cũng bị chặn, điều này sẽ làm chậm chương trình của bạn nếu bạn cố gắng truy cập singleton thường xuyên từ nhiều luồng. Tùy thuộc vào ngôn ngữ / nền tảng, cũng có thể có chi phí phát sinh từ chính khóa mà bạn muốn tránh.

Vì vậy, kiểm tra null đầu tiên được thêm vào như một cách thực sự nhanh chóng để xem bạn có cần khóa hay không. Nếu bạn không cần tạo singleton, bạn có thể tránh khóa hoàn toàn.

Nhưng bạn không thể kiểm tra xem tham chiếu có là null hay không mà không khóa nó theo một cách nào đó, vì do bộ nhớ đệm của bộ xử lý, một luồng khác có thể thay đổi nó và bạn sẽ đọc một giá trị "cũ" dẫn đến việc bạn phải nhập khóa một cách không cần thiết. Nhưng bạn đang cố gắng tránh một ổ khóa!

Vì vậy, bạn làm cho singleton dễ bay hơi để đảm bảo rằng bạn đọc giá trị mới nhất mà không cần sử dụng khóa.

Bạn vẫn cần khóa bên trong bởi vì biến số dễ bay hơi chỉ bảo vệ bạn trong một lần truy cập duy nhất vào biến - bạn không thể kiểm tra và thiết lập nó một cách an toàn mà không sử dụng khóa.

Bây giờ, điều này thực sự hữu ích?

Tôi sẽ nói "trong hầu hết các trường hợp, không".

Nếu Singleton.Instance có thể gây ra sự kém hiệu quả do các ổ khóa, thì tại sao bạn lại gọi nó thường xuyên đến mức đây sẽ là một vấn đề nghiêm trọng ? Toàn bộ điểm của một singleton là chỉ có một, vì vậy mã của bạn có thể đọc và lưu vào bộ nhớ cache tham chiếu singleton một lần.

Trường hợp duy nhất tôi có thể nghĩ về nơi mà bộ nhớ đệm này sẽ không thể thực hiện được khi bạn có một số lượng lớn các luồng (ví dụ: một máy chủ sử dụng một luồng mới để xử lý mọi yêu cầu có thể tạo ra hàng triệu luồng chạy rất ngắn, mỗi luồng mà sẽ phải gọi Singleton.Instance một lần).

Vì vậy, tôi nghi ngờ rằng khóa kiểm tra hai lần là một cơ chế có vị trí thực sự trong các trường hợp quan trọng về hiệu suất rất cụ thể, và sau đó mọi người đã tranh luận về nhóm "đây là cách thích hợp để làm điều đó" mà không thực sự nghĩ nó làm gì và liệu nó có sẽ thực sự cần thiết trong trường hợp họ đang sử dụng nó.

Bạn nên sử dụng biến động với mô hình khóa kiểm tra hai lần.

Hầu hết mọi người coi bài viết này là bằng chứng rằng bạn không cần phải dễ bay hơi: https://msdn.microsoft.com/en-us/magazine/cc163715.aspx#S10

Nhưng họ không đọc đến cuối: " Lời cảnh báo cuối cùng - Tôi chỉ đoán mô hình bộ nhớ x86 từ hành vi quan sát được trên các bộ xử lý hiện có. Vì vậy, các kỹ thuật khóa thấp cũng rất mong manh vì phần cứng và trình biên dịch có thể trở nên hung hăng hơn theo thời gian . Dưới đây là một số chiến lược để giảm thiểu tác động của sự mong manh này đối với mã của bạn. Đầu tiên, bất cứ khi nào có thể, hãy tránh các kỹ thuật khóa thấp. . "

Nếu bạn cần thuyết phục hơn thì hãy đọc bài viết này về thông số ECMA sẽ được sử dụng cho các nền tảng khác: msdn.microsoft.com/en-us/magazine/jj863136.aspx

Nếu bạn cần thuyết phục hơn nữa, hãy đọc bài viết mới hơn này rằng các tối ưu hóa có thể được đưa vào để ngăn nó hoạt động mà không dễ bay hơi: msdn.microsoft.com/en-us/magazine/jj883956.aspx

Tóm lại, nó "có thể" làm việc cho bạn mà không dễ bay hơi trong thời điểm này, nhưng đừng có khả năng nó viết mã thích hợp và sử dụng phương thức dễ bay hơi hoặc biến động đọc / ghi. Các bài viết đề xuất làm theo cách khác đôi khi bỏ qua một số rủi ro có thể xảy ra đối với việc tối ưu hóa JIT / trình biên dịch có thể ảnh hưởng đến mã của bạn, cũng như chúng tôi, các tối ưu hóa trong tương lai có thể xảy ra có thể phá vỡ mã của bạn. Cũng như các giả định đã đề cập trong bài viết trước, các giả định về hoạt động mà không có biến động đã có thể không giữ được ARM.

AFAIK (và - hãy thận trọng với điều này, tôi không làm nhiều việc đồng thời) không. Khóa chỉ cung cấp cho bạn sự đồng bộ hóa giữa nhiều đối thủ (luồng).

Mặt khác, dễ bay hơi yêu cầu máy của bạn đánh giá lại giá trị mỗi lần để bạn không gặp phải giá trị được lưu trong bộ nhớ cache (và sai).

Xem http://msdn.microsoft.com/en-us/library/ms998558.aspx và lưu ý trích dẫn sau:

Ngoài ra, biến được khai báo là dễ bay hơi để đảm bảo rằng việc gán cho biến cá thể hoàn tất trước khi biến cá thể có thể được truy cập.

Mô tả về tính dễ bay hơi: http://msdn.microsoft.com/en-us/library/x13ttww7%28VS.71%29.aspx

Tôi nghĩ rằng tôi đã tìm thấy những gì tôi đang tìm kiếm. Thông tin chi tiết có trong bài viết này - http://msdn.microsoft.com/en-us/magazine/cc163715.aspx#S10 .

Tóm lại - trong .NET công cụ sửa đổi dễ bay hơi thực sự không cần thiết trong tình huống này. Tuy nhiên, trong các mô hình bộ nhớ yếu hơn, việc ghi được thực hiện trong phương thức khởi tạo của đối tượng khởi tạo lười biếng có thể bị trì hoãn sau khi ghi vào trường, vì vậy các luồng khác có thể đọc phiên bản non-null bị hỏng trong câu lệnh if đầu tiên.

Là lockđủ. Bản thân đặc tả ngôn ngữ MS (3.0) đề cập đến kịch bản chính xác này trong §8.12, mà không đề cập đến volatile:

Một cách tiếp cận tốt hơn là đồng bộ hóa quyền truy cập vào dữ liệu tĩnh bằng cách khóa một đối tượng tĩnh riêng. Ví dụ:

class Cache
{
    private static object synchronizationObject = new object();
    public static void Add(object x) {
        lock (Cache.synchronizationObject) {
          ...
        }
    }
    public static void Remove(object x) {
        lock (Cache.synchronizationObject) {
          ...
        }
    }
}

Đây là một bài đăng khá hay về việc sử dụng dễ bay hơi với khóa được kiểm tra hai lần:

http://tech.puredanger.com/2007/06/15/double-checked-locking/

Trong Java, nếu mục đích là bảo vệ một biến, bạn không cần phải khóa nếu nó được đánh dấu là dễ bay hơi