Use C# Thread Local Storage To Pass Thread Specific Data

In an ideal world developers typically createinstance variables and access these via interfaces to hold threadspecific data. There are times however in a multithreaded applicationwhere this is not realistic due to a variety of factors includinginflexible interfaces, legacy code, and the original overall design ofthe application. The .NET framework provides a mechanism to store dataat a thread level and allows you to access this thread specific dataanywhere this thread exists.

This specific thread level storage is known asthread local storage or TLS for short. The .NET threading namespaceallows .NET developers to use TLS from within their multi-threadedapplications to store data that is unique to each thread.

The common language runtime allocates amulti-slot data store array to each process when it is created. Threadscan use data slots inside these data stores to persist and retrieveinformation at a thread level. The access methods used to put data intothese slots and pull data from them accept and return a type of objectand therefore make the use of these data slots very flexible.

The sample code included demonstrates a simpleapplication that uses these data slots or TLS. We will go over a few ofthe lines to help give you a better understanding of what is happeningwhen we put data on and pull data from TLS.

Sample Application:
The sample codeincludes a console application named TLSSample.exe, which is meant todemonstrate how TLS works. A Manager object is created and begins toloop while calling into the processwork method of an instance of aWorker object. The Worker object then generates a random number, whichrepresents the amount of time the Manager object will sleep beforeagain calling into the Worker object, and places this number on TLS.Next, the manager object pulls this number from TLS and sleeps for thespecified amount of time before calling back into the Worker object.

We will now look more closely at the code thatspecifically deals with TLS in our sample application in an effort tobetter understand how to utilize TLS. We want to be able to access thedata slot by name and therefore we need to allocate a named data slot.The following line allocates a data slot with the name sleeptime.

Thread.AllocateNamedDataSlot("sleeptime");

Now that we have allocated the data slot weneed to place a thread specific value on it so we can access it later.The code snippet below first gets the thread specific named data slotand then places the rndValue variable on this data slot. It isimportant to note that the Thread.SetData method takes two parametersthe second parameter is a type of object.

LocalDataStoreSlot myData;
myData=Thread.GetNamedDataSlot("sleeptime");
Thread.SetData(myData, rndValue);

Now that we have placed a value on the data slot we need to read it back out from higher up the stack.

In order to read the value from the data slotwe need to take some similar steps that we took to put the value intothe data slot. The code listed below first gets the named data slot andthen we actually read the data from the named data slot. TheThread.GetData method returns an object so we need to coarse this towhatever data type your application needs, in our case this is aninteger.

LocalDataStoreSlot myTLSValue;
myTLSValue=Thread.GetNamedDataSlot("SleepTime");
int tlsValue=(int)Thread.GetData(myTLSValue);

Finally, we need to free the data slot that we allocated in the beginning of our application.

Thread.FreeNamedDataSlot("sleeptime");

Download TLS.zip

Summary:
Thread local storage allows you tostore data that is unique to a thread and whose value is determined atrun time. This type of storage can be very helpful when dealing with anexisting multithreaded application whose interfaces or original designare too inflexible for passing these values another way.

About the Author:
Doug Doedens is a seniorsoftware consultant living in San Diego specializing in .NET, VisualBasic 6, Java, and enterprise development. Doug can be reached atddoedens@hotmail.com