C#托管线程官方指南：多线程编程最佳实践与同步机制

需积分: 10 87 浏览量更新于2024-07-16 收藏 765KB PDF 举报

《C#托管线程官方文档》是一份详尽的指南，涵盖了C#编程语言中的线程管理核心概念。本文档深入剖析了在.NET框架下进行多线程编程的关键要素，包括： 1. **线程与线程同步**：介绍了基础的线程概念，以及如何在C#中创建和操作线程，如通过`Thread`类或`Task`类创建新线程，并讨论了数据同步的重要性。 2. **异常处理**：针对在托管线程中可能出现的异常情况，文档详细解释了如何捕获、处理和避免线程执行中的错误，确保程序的健壮性。 3. **前台和后台线程**：区分了`Thread`类中的`IsBackground`属性，阐述了前台线程（影响应用程序的退出行为）和后台线程（不影响主线程的结束）在实际场景中的应用。 4. **托管与非托管线程在Windows中的交互**：探讨了.NET框架如何处理底层的线程模型，以及何时选择使用托管线程以避免潜在的性能问题。 5. **线程局部存储**：讨论了`ThreadLocal<T>`类，它提供了一种在每个线程上下文中存储数据的方法，这对于避免全局变量竞争很有帮助。 6. **使用线程和线程池**：给出了如何利用.NET的线程池来管理线程，提高资源效率，同时演示了如何创建线程并传递数据给它们，以及如何暂停和中断线程。 7. **线程取消机制**：介绍了在C#中如何实现线程的取消，包括协处理器取消、轮询监听取消请求、注册回调函数以及使用WaitHandle进行取消操作。 8. **最佳实践**：提供了关于线程编程的一些建议，如何时使用特定的线程对象（如ThreadPool、Timer等），以及如何有效地同步并发操作，如使用`EventWaitHandle`、`CountdownEvent`、`Mutex`、`Semaphore`、`Barrier`、`SpinLock`和`SpinWait`等同步工具。通过阅读这份文档，开发人员可以深入了解C#中的线程管理技术，从而编写出高效、可维护且健壮的多线程代码。理解这些概念和技巧对于在分布式系统、并发编程、高并发Web服务等领域都有着至关重要的作用。

Threads and fibers

See also

The .NET threading model does not support fibers. You should not call into any unmanaged function that is

implemented by using fibers. Such calls may result in a crash of the .NET runtime.

Thread.ApartmentState

ThreadState

ServicedComponent

Thread

Monitor

Thread Local Storage: Thread

Relative Static Fields

and Data Slots

10/30/2019 • 3 minutes to read • Edit Online

Uniqueness of Data in Managed TLS

Thread-Relative Static Fields

You can use managed thread local storage (TLS) to store data that is unique to a thread and application domain.

The .NET Framework provides two ways to use managed TLS: thread-relative static fields and data slots.

Use thread-relative static fields (thread-relative Shared fields in Visual Basic) if you can anticipate your exact

needs at compile time. Thread-relative static fields provide the best performance. They also give you the

benefits of compile-time type checking.

Use data slots when your actual requirements might be discovered only at run time. Data slots are slower

and more awkward to use than thread-relative static fields, and data is stored as type Object, so you must

cast it to the correct type before you use it.

In unmanaged C++, you use TlsAlloc to allocate slots dynamically and __declspec(thread) to declare that a

variable should be allocated in thread-relative storage. Thread-relative static fields and data slots provide the

managed version of this behavior.

In the .NET Framework 4, you can use the System.Threading.ThreadLocal<T> class to create thread-local objects

that are initialized lazily when the object is first consumed. For more information, see Lazy Initialization.

Whether you use thread-relative static fields or data slots, data in managed TLS is unique to the combination of

thread and application domain.

Within an application domain, one thread cannot modify data from another thread, even when both threads

use the same field or slot.

When a thread accesses the same field or slot from multiple application domains, a separate value is

maintained in each application domain.

For example, if a thread sets the value of a thread-relative static field, enters another application domain, and then

retrieves the value of the field, the value retrieved in the second application domain differs from the value in the

first application domain. Setting a new value for the field in the second application domain does not affect the

field's value in the first application domain.

Similarly, when a thread gets the same named data slot in two different application domains, the data in the first

application domain remains independent of the data in the second application domain.

If you know that a piece of data is always unique to a thread and application-domain combination, apply the

ThreadStaticAttribute attribute to the static field. Use the field as you would use any other static field. The data in

the field is unique to each thread that uses it.

Thread-relative static fields provide better performance than data slots and have the benefit of compile-time type

checking.

Be aware that any class constructor code will run on the first thread in the first context that accesses the field. In all

other threads or contexts in the same application domain, the fields will be initialized to null ( Nothing in Visual

Using threads and threading
4/2/2020 • 3 minutes to read • Edit Online
NOTENOTE
How to: Create and start a new thread
How to: Stop a thread
How to: Pause or interrupt a thread
With .NET, you can write applications that perform multiple operations at the same time. Operations with the
potential of holding up other operations can execute on separate threads, a process known as 
multithreading
 or
free threading
.
Applications that use multithreading are more responsive to user input because the user interface stays active as
processor-intensive tasks execute on separate threads. Multithreading is also useful when you create scalable
applications, because you can add threads as the workload increases.
If you need more control over the behavior of the application's threads, you can manage the threads yourself. However,
starting with the .NET Framework 4, multithreaded programming is greatly simplified with the
System.Threading.Tasks.Parallel and System.Threading.Tasks.Task classes, Parallel LINQ (PLINQ), new concurrent collection
classes in the System.Collections.Concurrent namespace, and a new programming model that is based on the concept of
tasks rather than threads. For more information, see Parallel Programming and Task Parallel Library (TPL).
You create a new thread by creating a new instance of the System.Threading.Thread class and providing the name
of the method that you want to execute on a new thread to the constructor. To start a created thread, call the
Thread.Start method. For more information and examples, see the Creating threads and passing data at start time
article and the Thread API reference.
To terminate the execution of a thread, use the System.Threading.CancellationToken. It provides a unified way to
stop threads cooperatively. For more information, see Cancellation in managed threads.
Sometimes it is not possible to stop a thread cooperatively, because it runs third-party code not designed for
cooperative cancellation. In this case, you might want to terminate its execution forcibly. To terminate the
execution of a thread forcibly, in .NET Framework you can use the Thread.Abort method. That method raises a
ThreadAbortException on the thread on which it's invoked. For more information, see Destroying threads. The
Thread.Abort method is not supported in .NET Core. If you need to terminate the execution of third-party code
forcibly in .NET Core, run it in the separate process and use Process.Kill.
The System.Threading.CancellationToken is not available before .NET Framework 4. To stop a thread in older .NET
Framework versions, you should implement the cooperative cancellation manually using the thread
synchronization techniques. For example, you can create the volatile boolean field  shouldStop  and use it to
request the code executed by the thread to stop. For more information, see volatile in C# Reference and
System.Threading.Volatile.
Use the Thread.Join method to make the calling thread wait for the termination of the thread being stopped.
You use the Thread.Sleep method to pause the current thread for a specified amount of time. You can interrupt a
blocked thread by calling the Thread.Interrupt method. For more information, see Pausing and interrupting
threads.