Catálogo de publicaciones - libros

This chapter outlined a wide range of important threading topics. The chapters began with the basics of multitasking and how it is accomplished by using threads and then moved on to discuss the differences between multitasking and free threading. Next, it considered processes and how they isolate data from other applications, before looking at the function of threads in an operating system such as Windows. You now know that Windows interrupts threads to grant execution time to other threads for a brief period called a time slice or a quantum and what implications this has for program execution as a whole. You’ve learned the function of thread priorities and the different levels of these priorities, and also that threads will inherit their parent process’s priority by default. This chapter also described how the .NET runtime monitors threads created in the .NET environment and additionally any unmanaged threads that execute managed code. You learned about the support for threading in the .NET Framework and how the System. AppDomain class provides an additional layer of logical data isolation on top of the physical process data isolation. The chapter has looked at how threads can cross easily from one AppDomain to another. Finally, you learned how an AppDomain doesn’t necessarily have its own thread as all processes do.

This chapter introduced the System. Threading namespace and examined the Thread class in detail. We also discussed some basic ideas to help you hone your decision-making skills when it comes to multithreading your applications. You must always keep in mind the fact that threads require resources. Before you consume those resources, analyze the effect their use will have on the system and how you can minimize that overhead. You should consider creating a thread if you are accessing outside resources such as a network share or remote databases. You should also consider spawning a new thread when you plan to execute a lengthy process such as printing, I/O operations, and background data processing. Whatever your situation, keep the number of your threads to aminimum. You’ll reduce the overhead on your processor, increase the amount of time that your time slice uses to process instructions within your thread, and reduce the amount of memory required by your application.

In this chapter, we’ve discussed the various threading models that can be applied to your application, why you should use them, and how to implement them. You should now be confident in your knowledge of the following: Different types of basic threading models, such as STA and MTA apartments How to specify the threading model The different models of threads that can be applied and their relationships to each other This chapter will help you design your threaded application because the application will fit into one or more of the models; the code examples given will also help you to build the code you need. With the .NET Framework, threads are far more powerful, but also far more prone to errors than they used to be. By being aware of which model your application fits into, you can look out for these potential errors.

In this chapter, you saw how thread pooling can be used when a thread is required for a relatively short duration. Thread pooling allows thread recycling. A thread is assigned a task and when that task has completed, the thread returns to the pool and waits for the next assignment. We also covered the various aspects of using thread pools in .NET applications. You learned the definition of a thread pool and then why you might choose to use one in your applications. The chapter also covered the role of CLR in creating the thread pool followed by the glitches involved in using a thread pool. We later covered some more scalability issues, as the ThreadPool class isn’t suitable for applications that may need to fire a number of long-lived threads. We discussed the creation of a ThreadPool manager class and mentioned how SMP systems can dramatically increase the performance of an application if it is threaded.

In this chapter, you’ve seen how the Visual Studio .NET debugger can be used to observe an application’s behavior during its execution. Also, you’ve seen which powerful tools the debugger provides to allow you to examine and change a variable’s value, and more. In the second part of the chapter, we covered the tracing functionality provided by .NET with three classes: Trace, Debug, and Switch. We started listing the most useful tracing functionalities, focusing on the ability to activate tracing techniques by modifying values within the application configuration file. Finally, you saw a practical example where the tracing technique helps developers find and correct bugs and logical errors.

As you’ve seen, developing multithreaded network applications with VS .NET is a straightforward process. Much of the plumbing and infrastructure has already been abstracted away in the form of a comprehensive and OO set of classes. For even greater control over the network sockets, the System. Net.Socket offers plenty of rich functionality. We also experienced how simple it is to use .NET’s intrinsic support for asynchronous operations that run in the background worker thread without much code. We hope that you found this book both helpful and enjoyable. The extra features in .NET give the VB developer more power than they have ever had—threading is just one of them.