Làm thế nào để: Viết một phương pháp an toàn chỉ có thể được gọi một lần?

Question

Tôi đang cố gắng viết một phương pháp an toàn chỉ có thể được gọi một lần (mỗi trường hợp đối tượng). Một ngoại lệ nên được ném nếu nó đã được gọi trước đó.

Tôi đã đưa ra hai giải pháp. Cả hai đều đúng không? Nếu không, có gì sai với họ?

1. Với lock:

   public void Foo() 
   { 
       lock (fooLock) 
       { 
        if (fooCalled) throw new InvalidOperationException(); 
        fooCalled = true; 
       } 
       … 
   } 
   private object fooLock = new object(); 
   private bool fooCalled; 
   

2. Với Interlocked.CompareExchange:

   public void Foo() 
   { 
       if (Interlocked.CompareExchange(ref fooCalled, 1, 0) == 1) 
        throw new InvalidOperationException(); 
       … 
   } 
   private int fooCalled; 
   

   Nếu tôi không nhầm, giải pháp này có lợi thế là lock-free (dường như không có liên quan gì trong trường hợp của tôi) và điều đó đòi hỏi ít trường riêng hơn .

Tôi cũng mở cho các ý kiến ​​hợp lý về giải pháp nào nên được ưu tiên và đề xuất thêm nếu có cách tốt hơn.

Answer 1

Giải pháp Interlocked.CompareExchange của bạn trông đẹp nhất và (như bạn đã nói) không có khóa. Nó cũng ít phức tạp hơn các giải pháp khác. Khóa là khá nặng, trong khi CompareExchange có thể được biên dịch xuống một lệnh cpu CAS duy nhất. Tôi nói đi với cái đó.

Answer 2

Các đôi khóa patter kiểm tra là những gì bạn đang sau:

Đây là những gì bạn đang sau:

class Foo 
{ 
    private object someLock = new object(); 
    private object someFlag = false; 


    void SomeMethod() 
    { 
    // to prevent locking on subsequent calls   
    if(someFlag) 
     throw new Exception(); 

    // to make sure only one thread can change the contents of someFlag    
    lock(someLock) 
    { 
     if(someFlag) 
     throw new Exception(); 

     someFlag = true;      
    } 

    //execute your code 
    } 
} 

Nói chung khi tiếp xúc với những vấn đề như thế này cố gắng và làm theo cũng biết patters như một trong những ở trên.
Điều này làm cho nó dễ nhận biết và ít bị lỗi hơn vì bạn ít có khả năng bỏ sót điều gì đó hơn khi theo dõi một mẫu, đặc biệt là khi nói đến luồng.
Trong trường hợp của bạn đầu tiên nếu không có nhiều ý nghĩa nhưng thường bạn sẽ muốn thực thi logic thực tế và sau đó đặt cờ. Một chuỗi thứ hai sẽ bị chặn trong khi bạn đang thực thi mã (có thể khá tốn kém) của bạn.

Về mẫu thứ hai:
Có đúng, nhưng đừng làm cho nó phức tạp hơn. Bạn nên có lý do rất tốt để không sử dụng khóa đơn giản và trong tình huống này nó làm cho mã phức tạp hơn (bởi vì Interlocked.CompareExchange() ít được biết đến) mà không đạt được bất kỳ thứ gì (như bạn đã chỉ ra là khóa ít hơn khóa để đặt cờ boolean không thực sự một lợi ích trong trường hợp này).

Answer 3

Task task = new Task((Action)(() => { Console.WriteLine("Called!"); })); 
    public void Foo() 
    { 
     task.Start(); 
    } 

    public void Bar() 
    { 
     Foo(); 
     Foo();//this line will throws different exceptions depends on 
       //whether task in progress or task has already been completed 
    }