What Will You Learn?

---

The book takes a top-down look at how exactly .NET executes C# code. We begin by describing what a Windows thread is, and how threads relate to .NET processes, application domains, and threads. We examine thread scheduling (how the operating system decides which thread to process next), then look at how we write .NET code to work with threads. Then we look at thread synchronization, so that we can safely allow multiple threads to access the same resources. We look at some typical architectures that multithreaded programs employ, in particular thread pooling. We also examine how to debug multithreaded code. We finish with a fully worked example showing how threading can help us build a scalable, high performance network server.

Chapter by chapter, here's what to expect:

• Chapter 1 - Defining Threads

  This chapter explains what exactly a thread is, what role threads play in .NET, and how threads are created, executed, and terminated in the operating system.

• Chapter 2 - Threading in .NET

  In the second chapter, we examine how the concepts explored in Chapter 1 are implemented in .NET. We see how C# code can create threads, access information about their state and lifecycle, and perform basic operations like sleeping, stopping, and interrupting.

• Chapter 3 - Working with Threads

  This chapter explores in more depth how we can work with multiple threads in an application. We look at synchronization and locking, to ensure exclusive access to data by one thread at a time, and examine the danger of deadlock, and how to avoid it.

• Chapter 4 - Threading Design Principles

  In this chapter, we look at some of the common patterns employed in multithreaded code - architectures that we can use confidently, knowing that if we implement them following these tried and tested principles, we should avoid the dangers of deadlocks.

• Chapter 5 - Scaling Threaded Applications

  We can't go on creating threads forever - there is, with threads, a law of diminishing returns. Often, however, when we want to execute multiple simultaneous tasks on separate threads, we can achieve the effect without spawning more and more threads by employing a thread pool. This chapter examines .NET's own thread pool, and how to implement your own.

• Chapter 6 - Debugging and Tracing Threads

  Multithreaded applications can be much more complex to debug. This chapter examines some of .NET's most useful debugging tools, and explains how to use them to debug multithreaded code.

• Chapter 7 - Networking and Threading

  Networking operations can be slow in a single-threaded program. The application spends a lot of its time waiting for traffic to travel across the network, and during that time, it is doing nothing. Multithreading is therefore a common requirement in network applications, enabling them to get on with other activities while waiting for network traffic. In this chapter, we look at how threading can enable us to build a fast, scalable network server.

---