How to make a class Thread Safe [closed]

Answer 1

use lock() so that multiple threads will not use the logging at the same time

Answer 2

In C#, any object can be used to protect a "critical section", or in other words, code that must not be executed by two threads at the same time.

For example, the following will synchronize access to the SharedLogger.Write method, so only a single thread is logging a message at any given time.

public class SharedLogger : ILogger
{
   public static SharedLogger Instance = new SharedLogger();

   public void Write(string s)
   {
      lock (_lock)
      {
         _writer.Write(s);
      }
   }

   private SharedLogger() 
   { 
      _writer = new LogWriter();
   }

   private object _lock;
   private LogWriter _writer;
}

Answer 3

I would use an off the shelf logger for this, since there are several that are rock solid and simple to use. No need to roll your own. I reccomend Log4Net.

Answer 4

Pursuant to BCS' answer:

BCS is describing the case of a stateless object. Such an object is intrinsically thread safe because it has no variables of it's own that can be clobbered by calls from different theads.

The logger described does have a file handle (sorry, not C# user, maybe it's called IDiskFileResource or some such MS-ism) which it must serialize use of.

So, separate the storage of messages from the logic that writes them to the log file. The logic should only operate on one message at a time.

One way to do it is: if the logger object were to keep a queue of message objects, and the logger object merely has the logic to pop a message off the queue, then extract the useful stuff from a message object, then write that to the log, then look for another message in the queue - then you can make that thread safe by having the queue's add/remove/queue_size/etc operations thread safe. It would require the logger class, a message class and a thread safe queue (which is probably a third class, an instance of which is a member variable of the logger class).

Answer 5

If performance isn't' the main issue, for instance if the class isn't under a lot of load, just do this:

Make your class inherit ContextBoundObject

Apply this attribute to your class [Synchronization]

Your entire class is now only accessible to one thread at a time.

It's really more useful for diagnosis, as speed wise it's nearly the worst case...but to quickly determine "is this weird issue a racing condition", throw it on, re run the test.. if the problem goes away... you know it's a threading problem...

A more performant option is to make your logging class have a thread safe message queue ( that accepts logging messages, then just pull them out and process them sequentially...

For example the ConcurrentQueue class in the new parallelism stuff is a good thread safe queue.

Or user log4net RollingLogFileAppender, which is already thread safe.

Answer 6

• Try and do most computation using local variables and then alter the state of the object in one quick locked block.
• Keep in mind that some variables might change between when you read them and when you get to altering the state.