Cách đơn giản nhất để tạo toàn bộ một phương thức an toàn cho luồng?

Question

Dường như có rất nhiều điều để tìm hiểu về lập trình đa luồng và tất cả đều hơi đáng sợ.

Đối với nhu cầu hiện tại của tôi, tôi chỉ muốn bảo vệ chống lại một phương pháp được gọi là một lần nữa từ một thread trước khi nó kết thúc, và câu hỏi của tôi là:

Đây có phải là một đầy đủ (an toàn) cách để làm cho một phương pháp thread-an toàn?

class Foo 
{ 
    bool doingWork; 
    void DoWork() 
    { 
     if (doingWork) // <- sophistocated thread-safety 
      return;  // <- 

     doingWork = true; 

     try 
     { 
      [do work here] 
     } 
     finally 
     { 
      doingWork = false; 
     } 
    } 
} 

Nếu điều đó không đủ, cách đơn giản nhất để đạt được điều này là gì?

---

EDIT: Thông tin thêm về các kịch bản:

• Chỉ có một thể hiện của Foo

• Foo.DoWork() sẽ được gọi từ một sợi ThreadPool trên Đã trôi qua sự kiện của System.Timers.Timer.

• Thông thường Foo.DoWork() sẽ hoàn thành eons trước khi nó được gọi là , nhưng tôi muốn mã cho cơ hội mỏng sẽ chạy dài, và được gọi lại trước khi hoàn tất.

---

(Tôi cũng không đủ thông minh để chắc chắn nếu câu hỏi này có thể được gắn thẻ ngôn ngữ-agnostic, vì vậy tôi không có. Độc giả giác ngộ, cảm thấy tự do để làm như vậy nếu có.)

Answer 1

Mã của bạn không phải là chủ đề an toàn. Thay vào đó, bạn nên sử dụng từ khóa lock.

Trong mã hiện tại của bạn:

if (doingWork) 
     return; 

    // A thread having entered the function was suspended here by the scheduler. 

    doingWork = true; 

Khi thread kế tiếp đi qua, nó cũng sẽ nhập hàm.

Đây là lý do nên sử dụng cấu trúc lock. Về cơ bản, nó giống như mã của bạn, nhưng không có rủi ro cho một chuỗi bị gián đoạn ở giữa:

class Foo 
{ 
    object lockObject = new object; 
    void DoWork() 
    { 
     lock(lockObject) 
     { 
      [do work here] 
     } 
    } 
} 

Lưu ý rằng mã này có ngữ nghĩa hơi khác so với ban đầu của bạn. Mã này sẽ khiến luồng thứ hai nhập vào chờ và sau đó thực hiện công việc. Mã ban đầu của bạn đã tạo chuỗi thứ hai chỉ cần hủy bỏ. Để đến gần mã ban đầu của bạn, bạn không thể sử dụng câu lệnh C# lock. Các cơ bản Monitor xây dựng phải được sử dụng trực tiếp:

class Foo 
{ 
    object lockObject = new object; 
    void DoWork() 
    { 
     if(Monitor.TryEnter(lockObject)) 
     { 
      try 
      { 
       [do work here] 
      } 
      finally 
      { 
       Monitor.Exit(lockObject); 
      } 
     } 
    } 
} 

Answer 2

http://msdn.microsoft.com/en-us/library/system.threading.barrier.aspx

Có thể muốn xem xét sử dụng rào chắn thay vào đó, tất cả đều phù hợp với bạn. Đó là cách tiêu chuẩn để kiểm soát mã reentrant. Cũng cho phép bạn kiểm soát số lượng các chủ đề làm công việc đó cùng một lúc (nếu bạn cho phép nhiều hơn 1).

Answer 3

Re-entrancy không liên quan gì đến việc đa luồng.

Phương pháp tiếp cận lại là một phương pháp có thể kết thúc được gọi từ bên trong chính nó, trên cùng một chuỗi.
Ví dụ: nếu phương thức tăng sự kiện và mã khách hàng xử lý sự kiện đó gọi lại phương thức bên trong trình xử lý sự kiện, thì phương thức đó sẽ được thực hiện lại.
Bảo vệ phương thức đó khỏi việc ủy ​​thác lại có nghĩa là đảm bảo rằng nếu bạn gọi nó từ bên trong chính nó, nó sẽ không làm bất kỳ thứ gì hoặc ném một ngoại lệ.

Mã của bạn được bảo vệ khỏi quyền truy cập lại trong cùng một cá thể đối tượng, miễn là mọi thứ đều nằm trên cùng một chuỗi.

Trừ khi [do work here] có khả năng chạy mã bên ngoài (ví dụ: bằng cách tăng sự kiện hoặc bằng cách gọi đại biểu hoặc phương thức từ một sự kiện khác), nó không phải là người tham gia lại.

Câu hỏi đã chỉnh sửa của bạn cho biết rằng toàn bộ phần này không liên quan đến bạn.
Có lẽ bạn vẫn nên đọc nó.

---

Bạn có thể (EDIT: là) tìm kiếm độc quyền – đảm bảo rằng phương pháp này sẽ không chạy hai lần cùng một lúc nếu gọi bằng nhiều luồng cùng một lúc.
Mã của bạn không độc quyền. Nếu hai luồng chạy phương thức cùng một lúc và cả hai đều chạy câu lệnh if cùng một lúc, cả hai đều sẽ vượt qua if, sau đó cả hai đặt cờ doingWork và cả hai sẽ chạy toàn bộ phương thức.

Để làm điều đó, hãy sử dụng từ khóa lock.

Answer 4

nếu bạn muốn dễ mã và không quan tâm về hiệu suất quá nhiều nó có thể được dễ dàng như

class Foo 
{ 
    bool doingWork; 
object m_lock=new object(); 
    void DoWork() 
    { 
     lock(m_lock) // <- not sophistocated multithread protection 
{ 
     if (doingWork) 
      return;  
     doingWork = true; 
} 


     try 
     { 
      [do work here] 
     } 
     finally 
     { 
lock(m_lock) //<- not sophistocated multithread protection 
{ 
      doingWork = false; 
} 
     } 
    } 

}

Nếu bạn muốn incapsulate khóa một chút, bạn có thể tạo ra một tài sản đó là thread an toàn như thế này:

public bool DoingWork 
{ 
get{ lock(m_Lock){ return doingWork;}} 
set{lock(m_lock){doingWork=value;}} 
} 

Bây giờ bạn có thể sử dụng nó thay vì trường, tuy nhiên nó sẽ dẫn đến nhiều thời gian hơn cho khóa gây ra số lượng sử dụng khóa tăng lên.

Hoặc bạn có thể sử dụng đầy đủ hàng rào cách tiếp cận (từ cuốn sách luồng lớn Joseph Albahari online threading)

class Foo 
{ 
    int _answer; 
    bool _complete; 

    void A() 
    { 
    _answer = 123; 
    Thread.MemoryBarrier(); // Barrier 1 
    _complete = true; 
    Thread.MemoryBarrier(); // Barrier 2 
    } 

    void B() 
    { 
    Thread.MemoryBarrier(); // Barrier 3 
    if (_complete) 
    { 
     Thread.MemoryBarrier();  // Barrier 4 
     Console.WriteLine (_answer); 
    } 
    } 
} 

Ông khẳng định rằng toàn hàng rào là 2x nhanh hơn so với tuyên bố khóa. Trong một số trường hợp, bạn có thể cải thiện hiệu suất bằng cách loại bỏ các cuộc gọi không cần thiết tới MemoryBarrier(), nhưng sử dụng lock đơn giản, rõ ràng hơn và ít bị lỗi hơn.

Tôi tin rằng điều này cũng có thể được thực hiện bằng cách sử dụng lớp Interlocked xung quanh trường làm việc dựa trên int.