The below code demonstrates using a ReaderWriterLockSlim on an array which is shared between a single writer and three readers:

class ReaderWriterLockDemo
{
const int MaxNumberValues = 30;
static int[] _array = new int[MaxNumberValues];
static ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
static void Main(string[] args)
{
ThreadPool.QueueUserWorkItem(WriteThread);
for (int i = 0; i < 3; i++)
{
ThreadPool.QueueUserWorkItem(ReadThread);
}
Console.ReadKey();
}
static void WriteThread(object state)
{
int id = Thread.CurrentThread.ManagedThreadId;
for (int i = 0; i < MaxNumberValues; ++i)
{
_lock.EnterWriteLock();
Console.WriteLine(“Entered WriteLock on thread {0}”, id);
_array[i] = i*i;
Console.WriteLine(“Added {0} to array on thread {1}”, _
array[i], id);

Console.WriteLine(“Exiting WriteLock on the thread {0}”, id);
_lock.ExitWriteLock();
Thread.Sleep(1000);
}
}
static void ReadThread(object state)
{
int idNumber = Thread.CurrentThread.ManagedThreadId;
for (int i = 0; i < MaxNumberValues; ++i)
{
_lock.EnterReadLock();
Console.WriteLine(“Entered ReadLock on the thread {0}”, idNumber);
StringBuilder sbObj = new StringBuilder();
for (int j = 0; j < i; j++)
{
if (sbObj.Length > 0) sbObj.Append(“, “);
sbObj.Append(_array[j]);
}
Console.WriteLine(“Array: {0} on the thread {1}”, sbObj, idNumber);
Console.WriteLine(“Exiting the ReadLock on thread {0}”, idNumber);
_lock.ExitReadLock();
Thread.Sleep(10000);
}
}
}

The below sample uses a mutex to protect a file from being written to by two instances of this same program:

static void Main(string[] args)
{
Mutex mutexObj = new Mutex(false, “MutexDemo1”);
Process me = Process.GetCurrentProcess();
string outputFile = “MutexDemoOutput1.txt”;
while (!Console.KeyAvailable)
{
mutexObj.WaitOne();
Console.WriteLine(“The process {0} gained control”, me.Id);
using (FileStream fsObj = new FileStream(outputFile,
FileMode.OpenOrCreate))
using (TextWriter writer = new StreamWriter(fsObj))
{
fsObj.Seek(0, SeekOrigin.End);
string outputObj = string.Format(“The process {0} writing timestamp
 {1}”, me.Id, DateTime.Now.ToLongTimeString());
writer.WriteLine(outputObj);
Console.WriteLine(outputObj);
}
Console.WriteLine(“The process {0} releasing control”, me.Id);
mutexObj.ReleaseMutex();
Thread.Sleep(1000); }
}

As with a Monitor object, you may attempt a wait on a mutex for a TimeSpan before giving up, and in case the mutex gives up WaitOne will return false.

In the above code, each process will lock the mutex before then writing to the file. Ensure you select good names for your mutexes, you should either use a unique combination of your application, company, and mutex purpose, or else use a GUID to make sure no collisions with your own applciations or others.

//6 parts of the book
string[] inputTextFiles =
{
“part1.txt”, “part2.txt”, “part3.txt”,
“part4.txt”, “part5.txt”, “part6.txt”
};

foreach (string file in inputTextFiles)

{
string contentStr = File.ReadAllText(file);
CountCharacters(contentStr);
CountWords(contentStr);
}

The Parallel class can be used with lambda expressions to parallelize the two calculation methods:

foreach(string file in inputFiles)

{
string contentStr = File.ReadAllText(file);
Parallel.Invoke(
() => CountCharacters(contentStr),
() => CountWords(contentStr)
);
}

The results from using the Parallel Class to split tasks are normally not as dramatic  as using Parallel to split data across processors but they are still significant.

For a task which is easily split into independent sub-tasks, or data that can be partitioned and computed separately you can use the Parallel class in System.Threading to assign tasks to be automatically scheduled and then wait for the tasks to be completed. The Parallel class will automatically scale to the number of available processors or cores.

Process Data in Parallel across Multiple Processors or Cores

When you have a data set which can be split over multiple processors and then processed independently, you should use constructs such as Parallel.For(), in the below example this is demonstrated for computing prime numbers:

using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace  PrimesDemo
{
class Program
{
static void Main(string[] args)
{
int maxPrimes = 1000000;
int maxNumber = 200000000;
long primesFound = 0;
Console.WriteLine(“Iterative”);
Stopwatch watchObj = new Stopwatch();
watchObj.Start();

for (UInt32 i = 0; i < maxNumber; ++i) { if (IsPrime(i)) { Interlocked.Increment(ref primesFound); if (primesFound > maxPrimes)
{
Console.WriteLine(“Last prime found was: {0:N0}”,
i);
break;
}
}
}
watchObj.Stop();
Console.WriteLine(“Found {0:N0} prime numbers in {1}”,
primesFound, watchObj.Elapsed);
watchObj.Reset();
primesFound = 0;
Console.WriteLine(“Parallel”);
watchObj.Start();
// to stop the loop, there is an overload that takes Action
Parallel.For(0, maxNumber, (i, loopState) =>
{
if (IsPrime((UInt32)i))
{
Interlocked.Increment(ref primesFound);
if (primesFound > maxPrimes)
{
Console.WriteLine(“Last prime found was: {0:N0}”,
i);
loopState.Stop();
}
}
});
watchObj.Stop();
Console.WriteLine(“Found {0:N0} prime numbers in {1}”,
primesFound, watchObj.Elapsed);
Console.ReadKey();
}
public static bool IsPrime(UInt32 number)
{

//check for evenness
if (number % 2 == 0)
{
if (number == 2)
return true;
return false;
}

UInt32 max = (UInt32)Math.Sqrt(number);
for (UInt32 i = 3; i <= max; i += 2)
{
if ((number % i) == 0)
{
return false;
}
}
return true;
}
}
}

When you run this note the drastically reduced time using Parallel, also note that the results are not necessarily in order and that the parallel evaluation of the data does not arrive at the same results as the iterative evaluation. As opposed to running sequentially from 1 to 200,000,000 until one million primes are found, the input space is instead divided up and therefore it is possible to get different results in some circumstances.

This C# .NET test harness configures easilycomparing throughput results of multi-threaded and single threadedcalculations using ADO .NET datasets. This simple multi-threadedexample performs calculation and database updates three times fasterthan a single threaded approach.

Creating the Workspace

To start the test harness, open a MicrosoftVisual Studio 2005, .NET Framework Version 2.0 development environmentand create two Console Applications. The first application performscalculations using a scheduler and worker threads. The secondapplication performs calculations in a single thread.

Code

Both applications create an ADO .NET datasetof inventory from a fictitious database table called INVENTORYcontaining fields for the ID, COST, PRICE and PROFIT. The sample codeincludes database SQL scripts containing the ID and COST for samplesizes up to 10000 data points. The test harness calculates the PRICEand PROFIT for each data point and updates the database.

The multi-threaded test harness starts a worker thread for each calculation and database update.

public class CalculatorScheduler
{
private DataSet m_invDataSet;

public void Init()
{
try
{
m_invDataSet = (new InventoryData()).GetDataSet();
foreach (DataRow row in m_invDataSet.Tables[Properties.Settings.Default.TABLE_DS].Rows)
{
Thread t = new Thread(new ParameterizedThreadStart(ProcessCalculations));
t.Start(row);
}
}
catch (Exception exc)
{
exc.Message.ToString();
}
}
private void ProcessCalculations(object row)
{
new CalculatorWorker().Calc((DataRow) row);
}
}

public class CalculatorWorker
{
private static Decimal MARGIN = Convert.ToDecimal(1.1);
private static object item = new object();

public void Calc(DataRow row)
{
try
{
row.BeginEdit();
row[Properties.Settings.Default.PRICE] = Convert.ToDecimal(row[Properties.Settings.Default.COST]) * MARGIN;
row[Properties.Settings.Default.PROFIT] = Convert.ToDecimal(row[Properties.Settings.Default.PRICE]) – Convert.ToDecimal(row[Properties.Settings.Default.COST]);
row.EndEdit();
row.AcceptChanges();
UpdateInventory(row);
}
catch (Exception exc)
{
exc.Message.ToString();
}
}

private void UpdateInventory(DataRow row)
{
try
{
OdbcCommand m_UpdateRatingsCmd = new OdbcCommand(Properties.Settings.Default.UPDATE, DBWrapper.Instance.InitializeConnection());
m_UpdateRatingsCmd.Parameters.AddWithValue("@PRICE", Convert.ToDouble(row[Properties.Settings.Default.PRICE]));
m_UpdateRatingsCmd.Parameters.AddWithValue("@PROFIT", Convert.ToDouble(row[Properties.Settings.Default.PROFIT]));
m_UpdateRatingsCmd.Parameters.AddWithValue("@ID", Convert.ToInt32(row[Properties.Settings.Default.ID]));
m_UpdateRatingsCmd.ExecuteNonQuery();
DBWrapper.Instance.CloseConnection();
}
catch (Exception exc)
{
exc.Message.ToString();
}
}
}

Whereas the single threaded test harness performs the calculations linearly.

m_invDataSet = (new InventoryData()).GetDataSet();
foreach (DataRow row in m_invDataSet.Tables[Properties.Settings.Default.TABLE_DS].Rows)
{
try
{
row.BeginEdit();
row[Properties.Settings.Default.PRICE] = Convert.ToDecimal(row[Properties.Settings.Default.COST]) * MARGIN;
row[Properties.Settings.Default.PROFIT] = Convert.ToDecimal(row[Properties.Settings.Default.PRICE]) – Convert.ToDecimal(row[Properties.Settings.Default.COST]);
row.EndEdit();
row.AcceptChanges();

OdbcCommand m_UpdateRatingsCmd = new OdbcCommand(Properties.Settings.Default.UPDATE, DBWrapper.Instance.InitializeConnection());
m_UpdateRatingsCmd.Parameters.AddWithValue("@PRICE", Convert.ToDouble(row[Properties.Settings.Default.PRICE]));
m_UpdateRatingsCmd.Parameters.AddWithValue("@PROFIT", Convert.ToDouble(row[Properties.Settings.Default.PROFIT]));
m_UpdateRatingsCmd.Parameters.AddWithValue("@ID", Convert.ToInt32(row[Properties.Settings.Default.ID]));
m_UpdateRatingsCmd.ExecuteNonQuery();
DBWrapper.Instance.CloseConnection();
}
}

Tests of different sample sizes showsignificantly faster results from the multi-threaded solution comparedto the single threaded solution. All Start Time and End Time values arein seconds. In this simple example the multi-threaded test harnessachieves an average of 1000 calculation and database updates per secondfor a dataset of 5000 records more than three times the rate of thesingle threaded approach. The test harnesses could be modified toperform more complex calculations for larger datasets; however, thissimple example presents the benefits of multi-threaded calculations.

Multi-Threaded Test Harness for Data Set of 1000333 calculation and db updates per second

Start Time : 27
End Time : 30

Single Threaded Test Harness For Data Set of 1000
200 calculation and db updates per second

Start Time : 23
End Time : 32

Multi-Threaded Test Harness for Data Set of 5000
1000 calculation and db updates per second

Start Time : 10
End Time : 15

Single Threaded Test Harness for Data Set of 5000
333 calculation and db updates per second

Start Time : 19
End Time : 34

Download Source & SQL

AmThreader_demo.zip

Terms definition

Multithreaded class – sounds very confusing.
In fact there is no such a thing as singlethreaded or multithreaded class,
on the other hand I do not have better name for the construction I have created.
Perhaps, I can name it a Thread Isolator. 

AmThreader is a code generator that creates a class wrapper for any .NET class (not necessarily C#)
and any call of wrapper class method will be translated to original class call but in a separate thread.

Introduction

All of us use computers today. You start an application , click controls and at some
moment it stops to respond. Well, the most probable cause of it is that the main thread is
unable to exit (or continue) for some reason. What reason?
The reason in fact, can be any : Input-Output can not complete, some network problems,
internal application error and the thread went into endless loop etc.
Very annoying situation, indeed. How can this problem be resolved? The only way to create a
responsive and in a certain sense robust application is to use multithreading. However everything is
at cost because the development of multithreaded applications is more complicated. It involves
threads synchronisation, considerably more complicated debugging and so on. That is
why even reputable companies still use single threading. So, how to simplify the development
of multithreaded software?

Code Generator

The answer is AmThreader – the code generator.It converts any singlethreaded .NET class to multithreaded one.
How it works?

Let's look first into the stages of the development of simple multithreaded
application . What are the components of multithreading?
Nothing in fact is really special:
1. Temporary variables for holding and passing the parameters from one thread to another.
2. A new thread (worker thread).
3. Methods to invoke certain methods in the worker thread.
4. A loop that runs in the worker thread .
5. A bunch of enums ,switches and cases that control the work flow in the worker thread.
6. Wait procedure (or extra thread).
7. Threads synchronisation components (depend on OS and used language).
8. Exception handling.

For instance we have a class ClassA that has the method DoSomething() which may not return.

public class ClassA { public ClassA() { public void DoSomething(int b) { // do something } } }

Let's convert it to multithreaded one in order to make the application safe and friendly. Speaking in C#
terms this new class can be represented with a snippet below:

namespace SomeNameSpace { public class __ClassA { private enum Commands_enums { ClassA__enum_0, DoSomething__enum_1 } private Commands_enums CurrCommand; private bool bError; private bool ThreadStop; private ManualResetEvent EventStart = new ManualResetEvent(false); private object[] inParams = new object[100]; private object ValueParam; private Thread fThread; private int nTimeOut = 10000; private int CycleTime = 15; private ClassA ThreadObjectInstance; public __ClassA() { StartThread(); CurrCommand = Commands_enums.ClassA__enum_0; WaitForComplete(); } public void DoSomething(int b) { inParams[0] = b; CurrCommand = Commands_enums.doSomething__enum_1; WaitForComplete(); }  private void Worker_Thread_01()   { while(!ThreadStop) { EventStart.WaitOne(); switch(CurrCommand) { case Commands_enums.ClassA__enum_0: ThreadObjectInstance = new ClassA(); break; case Commands_enums.DoSomething__enum_1: ThreadObjectInstance.DoSomething((int)inParams[0]); break;   default: break; }   bStopWaiting = true; CurrCommand = Commands_enums.wait_command__enum_; EventStart.Reset(); } } private void StartThread() { ThreadStart thr_start_func = new ThreadStart (Worker_Thread_01); fThread = new Thread (thr_start_func); fThread.Name = "Worker_Thread_01"; fThread.Start (); //starting the thread } private void WaitForComplete() {  int ElapsedTime = 0; EventStart.Set(); while(!bStopWaiting)   {   //** Place for event processing ElapsedTime += CycleTime;   if (ElapsedTime > nTimeOut) { bStopWaiting = true; throw new Exception("Wait TimeOut"); } Thread.Sleep(CycleTime); } } } }

The snippet above is the simplest ,though complete multithreaded class. Yes, it is simple , but what can it do?

> Not mu
ch, the only thing it can do well is waiting for a completion of DoSomething() method and announce
of it's failure if the worker thread sticks in it. Even with this limited functionality it is useful. The application can
always be terminated gracefully. Although the main thread is still frozen during the execution of DoSomething().
However for the event driven applications (all GUI or winforms) there is a trick to overcome that unpleasant
effect. We only need to place Application.DoEvents() inside   Wait loop. The interface will still be
responding during doSomething(). The code line Thread.Sleep(CycleTime) controls the responsiveness of the
interface. The smaller CycleTime the more responsive the interface is, on the other hand it uses more CPU resources. 

How can the new class __ClassA be used? The same way the original class is. 

For example : 
The original class ClassA can be used in the way something like that :

ClassA MyClassA = new ClassA(); try { MyClassA.DoSomething(5); } catch(Exception ex) { MessageBox.Show(ex.Message); }

How to use the new class? Well , almost the same. The only difference is that the class must be 
destroyed explicitly calling Dispose() , otherwise the application will never end with worker thread running.

__ClassA MyClassA = new __ClassA(); try { MyClassA.DoSomething(5); } catch(Exception ex) { MessageBox.Show(ex.Message); } MyClassA.Dispose();

So, what is so special in __ClassA and how can it be derived (not in the sense of inheritance) from ClassA ? Absolutely
nothing and this operation can be automated completely.

Using Reflection AmThreder generates new class from the Assembly with the same methods names , indexers and properties
as the original class has. Only public methods are processed, even the source code of the original class is no longer needed.

Where to download 

To download fresh version of AmThreader visit http://www.amplefile.com/ , "downloads" page. 
AmThreader constantly monitors if fresh version is avalable and will notify you.

History

The current version is 1.0.2.0 

License

For independent developers AmThreader is free. However it has to be registered

This is the second article of two partson dotNet threading. In this second part, I will discuss further thesynchronization objects in the System.Threading dotNet namespace, thread localstorage, COM interoperability and thread states.

Intermediate Level

This article is written for theintermediate and senior C# developer. Working knowledge of the C# programminglanguage and dotNet framework is assumed. The article was written with a Betaversion of VS.NET and associated documentation. Changes, although notanticipated, might occur before final release of VS.NET that invalidateportions of this article.

In the first article, I discussed how tocreate threads, thread pools and some of the synchronization objects availablein the System.Threading dotNet namespace. In this second article, I willcomplete my discussion of the synchronization objects and will discuss threadlocal storage, COM interoperability and thread states.

ReaderWriterLock

Another popular design pattern introducedas a class in the dotNet framework is the ReaderWriterLock. This class allowsan unlimited amount of read locks or one write lock, but not both. This allowsanyone to read the protected resource, as long as nobody is writing to the protectedresource and allows only one thread to write to the protected resource at anyone time. Listing 1 presents a sample using the ReaderWriterLock class.

Listing 1:ReaderWriterLock Class

using System;

using System.Threading;

<!–[if !supportEmptyParas]–> <!–[endif]–><o:p></o:p>

namespace ConsoleApplication9

{

??class Class1

??{

?????public Class1()

?????{

????????rwlock = new ReaderWriterLock();

????????val = "Writer Sequence Number is 1";

?????}

<!–[if !supportEmptyParas]–> <!–[endif]–><o:p></o:p>

?????private ReaderWriterLock rwlock;

?????private string val;

<!–[if !supportEmptyParas]–> <!–[endif]–><o:p></o:p>

?????public void Reader()

?????{

????????rwlock.AcquireReaderLock(Timeout.Infinite);

????????Console.WriteLine("Acquired Read Handle: "

??????????? "Value = {0}", val);

????????Thread.Sleep(1);

????????Console.WriteLine("Releasing Read Handle");

????????rwlock.ReleaseReaderLock();

?????}

<!–[if !supportEmptyParas]–> <!–[endif]–><o:p></o:p>

?????public void Writer()

?????{

????????rwlock.AcquireWriterLock(Timeout.Infinite);

????????Console.WriteLine("Acquired Write Handle");

????????int id = rwlock.WriterSeqNum;

????????Console.WriteLine("Writer Sequence Number "

??????????? "is {0}", id);

????????Thread.Sleep(1);

????????val = "Writer ";

????????Thread.Sleep(1);

>??

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