这种共享字典的方法是否线程安全？

Question

I am constructing a basic web-based chat through ASP.NET which polls a WCF Service hosted inside a Windows Service. I am quite new to managing shared resources in a multi-threaded application, so I have several questions about thread-safety in my approach.

The service core is a Singleton class called ServerManager which maintains a Dictionary of ChatServer objects which is initialized and populated only once, and never added to or removed from again. Calls from the WCF service will reference the key (serverID) of the instance the client is "connected" to. At any given time, multiple calls may be coming into the service, with multiple threads making concurrent calls to ServerManager's methods.

Access to the Dictionary _servers is synchronized with the lock block while obtaining a reference to the requested ChatServer object and then the local reference is then used outside of the lock block. I don't want all ChatServers to be blocked by a read/write to just one ChatServer.

I have also included synchronization within a ChatServer instance during read/writes to the _messages object.

1. Is it thread-safe to synchronize access to _servers when getting the reference to the requested object, but then utilize that reference (currentServer) outside of the lock block? In other words, can multiple threads safely access different elements within the Dictionary as long as access shared data within these objects is synchronized?

2. Is it thread-safe to return the List of String to the caller as I do in ChatServer.GetNewMessages()?

3. If newMessages was instead a List of some new ChatMessage object, what would I need to do to ensure that GetNewMessages won't cause thread-safety issues when returning the List of ChatMessage?

Here is a snippet of the classes (Note: this code has been simplified to illustrate the problem)

class ServerManager
{
    private static readonly ServerManager _instance = new ServerManager();
    private Dictionary<Int32, ChatServer> _servers = new Dictionary<Int32, ChatServer>();
    private Object _lock = new Object();

    private ServerManager()
    {
        _servers.Add(1, new ChatServer());
        _servers.Add(2, new ChatServer());
        _servers.Add(3, new ChatServer());
    }

    public static ServerManager Instance
    {
        get { return _instance; }
    }

    public void AddMessage(Int32 serverID, String message)
    {
        ChatServer currentServer;

        lock (_lock)
        {
            currentServer = _servers[serverID];
        }

        currentServer.AddMessage(message);
    }

    public List<String> GetNewMessages(Int32 serverID)
    {
        ChatServer currentServer;

        lock (_lock)
        {
            currentServer = _servers[serverID];
        }

        return currentServer.GetNewMessages();
    }
}

class ChatServer
{
    private List<String> _messages = new List<string>();
    private Object _lock = new Object();

    public ChatServer() { }

    public void AddMessage(String message)
    {
        lock (_lock)
        {
            _messages.Add(message);
        }
    }

    public List<String> GetNewMessages()
    {
        List<String> newMessages = new List<String>();

        lock (_lock)
        {
            newMessages.AddRange(_messages);
        }

        return newMessages;
    }
}

Answer 1

Is it thread-safe to synchronize access to _servers when getting the reference to the requested object, but then utilize that reference (currentServer) outside of the lock block? In other words, can multiple threads safely access different elements within the Dictionary as long as access shared data within these objects is synchronized?

Yes, it's thread safe, assuming the element itself is thread-safe. In this case, you're dealing with ChatServer objects, which themselves must guarantee thread-safety

Is it thread-safe to return the List of String to the caller as I do in ChatServer.GetNewMessages()?

Yes - you're creating a local variable which is then returned. All resources shared between threads are in the lock scope (only _messages is shared in your example).

If newMessages was instead a List of some new ChatMessage object, what would I need to do to ensure that GetNewMessages won't cause thread-safety issues when returning the List of ChatMessage?

No - your code in GetNewMessages would not have to change. However , ChatMessage must make its own guarantees about thread-safety. In fact, it would be impossible to code GetNewMessages to provide thread-safety if ChatMessage itself was not thread safe (short of cloning the objects, of course).

Suggestions :

1. Your code is broken at the moment: _servers and _lock are not initialised - please fix it up in your post so it's easier to copy & paste

2. You do not need any locks in your ServerManager - assuming _servers is NEVER added to or removed from.

3. You may or may not need locks in your ChatServer class. As it's written now, there are no thread-safety issues with it (that is, your lock s are correct). However, depending on how the class is used, you may want to look into ReaderWriterLock or ConcurrentBag<T>

Your ServerManager class can be written as follows without locks, and will be threadsafe:

class ServerManager
{
    private static readonly ServerManager _instance = new ServerManager();
    private readonly Dictionary<Int32, ChatServer> _servers;

    private ServerManager()
    {
        _servers = new Dictionary<int, ChatServer>();
        _servers.Add(1, new ChatServer());
        _servers.Add(2, new ChatServer());
        _servers.Add(3, new ChatServer());
    }

    public static ServerManager Instance
    {
        get { return _instance; }
    }

    public void AddMessage(Int32 serverID, String message)
    {
        _servers[serverID].AddMessage(message);
    }

    public List<String> GetNewMessages(Int32 serverID)
    {
        return _servers[serverID].GetNewMessages();
    }
}

Answer 2

A short summary of this pretty long answer: Your code is thread-safe, but it can be improved.

Dictionary of ChatServer objects which is initialized and populated only once, and never added to or removed from again.

You don't need to synchronize access to the Dictionary if it's read-only. However, if it is read-only, make it explicit in your code using ReadOnlyDictionary class.

Is it thread-safe to synchronize access to _servers when getting the reference to the requested object, but then utilize that reference (currentServer) outside of the lock block? In other words, can multiple threads safely access different elements within the Dictionary as long as access shared data within these objects is synchronized?

It is thread-safe, but it would be better to use a specialized data structure that would do that for you. For example ConcurrentDictionary . The thread-safe data structures are usually much more efficient as most of them uses Interlocked for thread sync.

Your dictionary is read-only, so it doesn't even need to be synchronized.

Is it thread-safe to return the List of String to the caller as I do in ChatServer.GetNewMessages()?

It's a brand new list for every call, it is thread-safe. But why do you return List<string> ? Should the clients be able to modify the returned collection ( Add , Remove , Clear )? Choose a minimal interface the clients will need, like IEnumerable<string> or IReadOnlyList<string> and use List<T>.AsReadOnly() to return it. You still need a copy of the list, AsReadOnly() only creates a wrapper around the list, not a read-only copy.

An even better option is to store messages in a thread-safe collection, for example ConcurrentQueue<T> . You could use the queue directly in your clients, or return a snapshot every time GetNewMessages is called using ConcurrentQueue<T>.ToArray() .

Here you can see a great thing about making your methods return interfaces. The first option actually returns a ReadOnlyCollection<string> , the 2nd on string[] , but as both of these types implement IEnumerable<string> and IReadOnlyList<string> , the clients are not affected by your choice. It's an implementation detail you can change any time.

If newMessages was instead a List of some new ChatMessage object, what would I need to do to ensure that GetNewMessages won't cause thread-safety issues when returning the List of ChatMessage?

Make ChatMessage immutable. Immutable types are always thread-safe.