Cách tốt nhất để triển khai Từ điển an toàn theo luồng là gì?

Tôi đã có thể triển khai Từ điển an toàn luồng trong C # bằng cách lấy từ IDictionary và xác định đối tượng SyncRoot riêng tư:

public class SafeDictionary<TKey, TValue>: IDictionary<TKey, TValue>
{
    private readonly object syncRoot = new object();
    private Dictionary<TKey, TValue> d = new Dictionary<TKey, TValue>();

    public object SyncRoot
    {
        get { return syncRoot; }
    } 

    public void Add(TKey key, TValue value)
    {
        lock (syncRoot)
        {
            d.Add(key, value);
        }
    }

    // more IDictionary members...
}

Sau đó, tôi khóa đối tượng SyncRoot này trong suốt người tiêu dùng của tôi (nhiều chủ đề):

Thí dụ:

lock (m_MySharedDictionary.SyncRoot)
{
    m_MySharedDictionary.Add(...);
}

Tôi đã có thể làm cho nó hoạt động, nhưng điều này dẫn đến một số mã xấu xí. Câu hỏi của tôi là, có cách nào tốt hơn, thanh lịch hơn để triển khai Từ điển an toàn luồng không?

Như Peter đã nói, bạn có thể đóng gói tất cả các luồng an toàn bên trong lớp. Bạn sẽ cần phải cẩn thận với bất kỳ sự kiện nào bạn để lộ hoặc thêm vào, đảm bảo rằng chúng được gọi ra bên ngoài bất kỳ ổ khóa nào.

public class SafeDictionary<TKey, TValue>: IDictionary<TKey, TValue>
{
    private readonly object syncRoot = new object();
    private Dictionary<TKey, TValue> d = new Dictionary<TKey, TValue>();

    public void Add(TKey key, TValue value)
    {
        lock (syncRoot)
        {
            d.Add(key, value);
        }
        OnItemAdded(EventArgs.Empty);
    }

    public event EventHandler ItemAdded;

    protected virtual void OnItemAdded(EventArgs e)
    {
        EventHandler handler = ItemAdded;
        if (handler != null)
            handler(this, e);
    }

    // more IDictionary members...
}

Chỉnh sửa: Tài liệu MSDN chỉ ra rằng việc liệt kê vốn dĩ không an toàn cho chuỗi. Đó có thể là một lý do để lộ một đối tượng đồng bộ hóa bên ngoài lớp của bạn. Một cách khác để tiếp cận đó là cung cấp một số phương pháp để thực hiện một hành động trên tất cả các thành viên và khóa quanh việc liệt kê các thành viên. Vấn đề với điều này là bạn không biết liệu hành động được chuyển đến hàm đó có gọi thành viên nào đó trong từ điển của bạn hay không (điều đó sẽ dẫn đến bế tắc). Việc để lộ đối tượng đồng bộ hóa cho phép người dùng đưa ra những quyết định đó và không che giấu sự bế tắc bên trong lớp của bạn.

Lớp .NET 4.0 hỗ trợ đồng thời được đặt tên ConcurrentDictionary.

Cố gắng đồng bộ hóa nội bộ gần như chắc chắn sẽ không đủ vì nó ở mức trừu tượng quá thấp. Giả sử bạn thực hiện các thao tác Addvà ContainsKeythao tác riêng lẻ theo chuỗi an toàn như sau:

public void Add(TKey key, TValue value)
{
    lock (this.syncRoot)
    {
        this.innerDictionary.Add(key, value);
    }
}

public bool ContainsKey(TKey key)
{
    lock (this.syncRoot)
    {
        return this.innerDictionary.ContainsKey(key);
    }
}

Sau đó, điều gì sẽ xảy ra khi bạn gọi đoạn mã được cho là an toàn theo luồng này từ nhiều luồng? Nó sẽ luôn hoạt động ổn chứ?

if (!mySafeDictionary.ContainsKey(someKey))
{
    mySafeDictionary.Add(someKey, someValue);
}

Câu trả lời đơn giản là không có. Tại một thời điểm nào đó, Addphương thức sẽ ném ra một ngoại lệ cho biết rằng khóa đã tồn tại trong từ điển. Bạn có thể hỏi điều này như thế nào với một từ điển an toàn theo chuỗi? Chỉ vì mỗi hoạt động là an toàn cho chuỗi, nên sự kết hợp của hai hoạt động thì không, vì một chuỗi khác có thể sửa đổi nó giữa lệnh gọi của bạn đến ContainsKeyvàAdd .

Có nghĩa là để viết đúng loại kịch bản này, bạn cần có một khóa bên ngoài từ điển, ví dụ:

lock (mySafeDictionary)
{
    if (!mySafeDictionary.ContainsKey(someKey))
    {
        mySafeDictionary.Add(someKey, someValue);
    }
}

Nhưng bây giờ, khi bạn phải viết mã khóa bên ngoài, bạn đang trộn lẫn đồng bộ hóa bên trong và bên ngoài, điều này luôn dẫn đến các vấn đề như mã không rõ ràng và bế tắc. Vì vậy, cuối cùng có lẽ bạn tốt hơn nên:

1. Sử dụng bình thường Dictionary<TKey, TValue>và đồng bộ hóa bên ngoài, bao gồm các hoạt động kết hợp trên nó, hoặc

2. Viết một trình bao bọc an toàn luồng mới với một giao diện khác (tức là không IDictionary<T>) kết hợp các thao tác như một AddIfNotContainedphương thức để bạn không bao giờ cần kết hợp các thao tác từ nó.

(Tôi có xu hướng tự đi với số 1)

Bạn không nên xuất bản đối tượng khóa riêng tư của mình thông qua một thuộc tính. Đối tượng khóa nên tồn tại riêng tư với mục đích duy nhất là hoạt động như một điểm hẹn.

Nếu hiệu suất kém khi sử dụng khóa tiêu chuẩn thì bộ sưu tập khóa Power Threading của Wintellect có thể rất hữu ích.

Có một số vấn đề với phương pháp triển khai mà bạn đang mô tả.

1. Bạn không nên để lộ đối tượng đồng bộ hóa của mình. Làm như vậy sẽ giúp bạn dễ dàng nhận ra người tiêu dùng đang nắm lấy đồ vật và mở khóa và sau đó bạn sẽ nâng ly.
2. Bạn đang triển khai giao diện an toàn phi luồng với lớp an toàn luồng. IMHO điều này sẽ khiến bạn phải trả giá

Cá nhân tôi đã tìm thấy cách tốt nhất để triển khai một lớp an toàn luồng là thông qua tính bất biến. Nó thực sự làm giảm số lượng các vấn đề bạn có thể gặp phải với an toàn luồng. Kiểm tra Blog của Eric Lippert để biết thêm chi tiết.

Bạn không cần phải khóa thuộc tính SyncRoot trong các đối tượng tiêu dùng của mình. Khóa bạn có trong các phương thức của từ điển là đủ.

Để hoàn thiện: Điều cuối cùng xảy ra là từ điển của bạn bị khóa trong một khoảng thời gian dài hơn mức cần thiết.

Điều gì xảy ra trong trường hợp của bạn là:

Nói chuỗi A có được khóa trên SyncRoot trước đó gọi đến m_mySharedDictionary.Add. Thread B sau đó cố gắng lấy khóa nhưng bị chặn. Trên thực tế, tất cả các chủ đề khác đều bị chặn. Thread A được phép gọi vào phương thức Add. Tại câu lệnh lock trong phương thức Add, luồng A được phép lấy lại khóa vì nó đã sở hữu nó. Khi thoát khỏi ngữ cảnh khóa trong phương thức và sau đó bên ngoài phương thức, luồng A đã giải phóng tất cả các khóa cho phép các luồng khác tiếp tục.

Bạn chỉ cần cho phép bất kỳ người tiêu dùng nào gọi vào phương thức Add vì câu lệnh khóa trong phương thức Add của lớp SharedDictionary của bạn cũng sẽ có tác dụng tương tự. Tại thời điểm này, bạn có khóa dự phòng. Bạn sẽ chỉ khóa SyncRoot bên ngoài một trong các phương thức từ điển nếu bạn phải thực hiện hai thao tác trên đối tượng từ điển cần được đảm bảo xảy ra liên tiếp.

Chỉ là một suy nghĩ tại sao không tạo lại từ điển? Nếu đọc là nhiều lần ghi thì khóa sẽ đồng bộ hóa tất cả các yêu cầu.

thí dụ

    private static readonly object Lock = new object();
    private static Dictionary<string, string> _dict = new Dictionary<string, string>();

    private string Fetch(string key)
    {
        lock (Lock)
        {
            string returnValue;
            if (_dict.TryGetValue(key, out returnValue))
                return returnValue;

            returnValue = "find the new value";
            _dict = new Dictionary<string, string>(_dict) { { key, returnValue } };

            return returnValue;
        }
    }

    public string GetValue(key)
    {
        string returnValue;

        return _dict.TryGetValue(key, out returnValue)? returnValue : Fetch(key);
    }

Bộ sưu tập và đồng bộ hóa