Sgt. Conker We are "absolutely fine"

Article : Multi-threading your XNA

2. A Look at Multi-Threading Primitives

This section will not be a complete guide to threading in C#. For that, you can access a free ebook with that name: Threading in C#. But I also can't simply give you that link and go on with the article, so I'll cover the primitives I'll be using throughout the article.

In C#, the Thread class creates and controls a thread, sets its priority and reads its status. When creating an instance of the Thread class, we need to pass a ThreadStart or a ParameterizedThreadStart delegate to its constructor. A ThreadStart delegate represents a method with no arguments that will be run on the thread. For example, if we have a method a(), we can create a new Thread on which to run that method with the following code.

<br />
    void a()<br />
    {<br />
        [...]<br />
    }<br />
    [...]</p>
<p>    ThreadStart threadStart = new ThreadStart(a);<br />
    Thread newThread = new Thread(threadStart);<br />
    newThread.Start();<br />

or simply

<br />
    Thread t = new Thread(new ThreadStart(a));<br />
    t.Start();<br />

But simply starting functions on threads is not enough. Data that can be accessed by more than one thread at once needs to be protected. To do this, the lock statement can be used. The lock keyword marks a statement block as a critical section by obtaining the mutual-exclusion lock for a given object, executing a statement, and then releasing the lock. In other words, while a thread is in a section of code protected by a lock on an object, that no other thread may enter any area of code protected by the same lock.

<br />
    lock(lockObject)<br />
    {<br />
        //this code, and all other code surrounded by a lock on lockObject can only be accessed by one thread at a time. All other threds will be blocked, until the thread finishes.<br />
    }<br />

The last class I will shortly explain is the AutoResetEvent. This class allows threads to communicate between them using signals. In order to start waiting for a signal, a thread can call the WaitOne() function of an AutoResetEvent object. If this event has been signaled previously, the thread can resume execution. Othewise, the thread is blocked, and starts waiting until someone signals the AutoResetEvent, by calling the Set() function. The class is called AutoResetEvent, because when a thread that was waiting for a signal is released, the AutoResetEvent is automatically reset, and enters the non-signaled state.
The following code shows how to declare and initialize an AutoResetEvent.

<br />
    AutoResetEvent myEvent = new AutoResetEvent(false); // you can specify the initial state through the constructor's parameter.<br />
    [...]<br />
    //when a thread tries to enter a protected region of code, it calls WaitOne()<br />
    myEvent.WaitOne();<br />
    [...]<br />
    //the thread stays blocked until some other thread signals the event using<br />
    myEvent.Set()<br />

These are the most important primitives we will use. For more details, there are lots of places where you can read about threading primitives, with the most important being MSDN and the free ebook I linked above.

About Sgt. Conker

The Sergeant!