500
Extreme C#
PART IV
LISTING 23.2 continued
string[] comment = new string[] |
||
{ “one”, |
“two”, “three”, |
“four”, “five”, |
“six”, |
“seven”, “eight”, |
“nine”, “ten” }; |
public string GetNextComment()
{
// allow only a single thread at a time lock (this)
{
if (index < comment.Length)
{
return comment[index++];
}
else
{
return “empty”;
}
}
}
}
///<summary>
///Demonstrates synchronized data access.
///</summary>
class Synchronization
{
SyncData sdat = new SyncData();
static void Main(string[] args)
{
Synchronization sync = new Synchronization();
Thread t1 = new Thread(new ThreadStart(sync.GetComments)); Thread t2 = new Thread(new ThreadStart(sync.GetComments)); Thread t3 = new Thread(new ThreadStart(sync.GetComments));
t1.Name = “Thread 1”; t2.Name = “Thread 2”; t3.Name = “Thread 3”;
t1.Start();
t2.Start();
t3.Start();
}
public void GetComments()
{
string comment;
502
Extreme C#
PART IV
Surrounding the if statement in the GetNextComment() method is a lock statement. Here’s a cutout of the lock statement from Listing 23.2:
lock (this)
{
// statements
}
The parameter of the lock statement is this. The parameter for a lock statement can be any reference type expression. An invalid expression would be a value type, such as an int type. The lock statement implements mutual exclusion on the statements inside the curly braces.
Tip
Use the lock statement for mutually exclusive access to data in a multi-threaded program.
Without the lock statement, it would be possible for two or more threads to be reading the same value at the same time. In the absence of a lock statement, if the statements inside the curly braces represented an airline seat reservation or a bank account withdrawal, the results would not be nice. The lock statement ensures that only one thread at a time can be executing those statements.
Summary
This chapter presented multi-threaded applications in C#. The first section discussed how to create and start a thread, including declaring a thread argument and passing it a delegate with the method to be invoked, as well as executing the thread.
To keep threads from wreaking havoc with shared data, it’s often necessary to use synchronization objects. Proper thread synchronization helps manage access to program data. The example program in this chapter used lock statements, providing a mutual exclusion access scenario to program data.
Multi-threading is common on server programs that create new threads to handle client requests. The next chapter, “Browsing the Network Libraries,” shows how to create clients and servers that communicate over a network.
