C# System.Threading.Thread再度回顾

刺骨的言语ヽ痛彻心扉 2021-06-24 16:11 288阅读 0赞

最好的参考文档莫过于直接参看Thread 类，由于在.net 中，代码是未开源的，但是我们也是可以通过该类让我们获取一定的信息去使用该类。  
例如初始化Thread实例：

public Thread(ThreadStart start);
        [ComVisible(true)]
        public delegate void ThreadStart();

通过这个构造函数，可以看出，初始化时，参数是一个委托，一个无参无返回值的委托。

再者

[SecuritySafeCritical]
           public Thread(ParameterizedThreadStart start);
    
       [ComVisible(false)]
       public delegate void ParameterizedThreadStart(object obj);

通过这个构造函数，在进行实例化时，便可以使用一个带一个object参数的委托进行实例化。

代码实现：

![2789632-319faf809c16d1ac.png][]

Code：

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    
    namespace ClassThreadDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                Thread t1 = new Thread(Say);
                // t1 = new Thread(new ThreadStart(Say));
                t1.Start();
    
                Thread t2 = new Thread(new ParameterizedThreadStart(Sayx));
                t2.Start(100);
    
                Console.ReadLine();
            }
    
            private static void Sayx(object x)
            {
                Console.WriteLine(x.ToString());
            }
    
            private static void Say()
            {
                Console.WriteLine("x + y");
            }
        }
    }

析构函数:

//
            // 摘要:
            //     确保垃圾回收器回收 System.Threading.Thread 对象时释放资源并执行其他清理操作。
            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
            [SecuritySafeCritical]
            ~Thread();

Thread Class Code：

#region 程序集 mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
    // C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.7.2\mscorlib.dll
    #endregion
    
    using System.Globalization;
    using System.Runtime.ConstrainedExecution;
    using System.Runtime.InteropServices;
    using System.Runtime.Remoting.Contexts;
    using System.Security;
    using System.Security.Principal;
    
    namespace System.Threading
    {
        //
        // 摘要:
        //     创建和控制线程，设置其优先级并获取其状态。
        [ClassInterface(ClassInterfaceType.None)]
        [ComDefaultInterface(typeof(_Thread))]
        [ComVisible(true)]
        public sealed class Thread : CriticalFinalizerObject, _Thread
        {
            //
            // 摘要:
            //     初始化 System.Threading.Thread 类的新实例。
            //
            // 参数:
            //   start:
            //     表示开始执行此线程时要调用的方法的 System.Threading.ThreadStart 委托。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     start 参数为 null。
            [SecuritySafeCritical]
            public Thread(ThreadStart start);
            //
            // 摘要:
            //     初始化 System.Threading.Thread 类的新实例，指定允许对象在线程启动时传递给线程的委托。
            //
            // 参数:
            //   start:
            //     一个委托，它表示此线程开始执行时要调用的方法。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     start 为 null。
            [SecuritySafeCritical]
            public Thread(ParameterizedThreadStart start);
            //
            // 摘要:
            //     初始化 System.Threading.Thread 类的新实例，指定线程的最大堆栈大小。
            //
            // 参数:
            //   start:
            //     表示开始执行此线程时要调用的方法的 System.Threading.ThreadStart 委托。
            //
            //   maxStackSize:
            //     线程要使用的最大堆栈大小（以字节为单位）；如果为 0，则使用可执行文件的文件头中指定的默认最大堆栈大小。 重要事项：对于部分受信任的代码，如果 maxStackSize
            //     大于默认堆栈大小，则将其忽略。 不引发异常。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     start 为 null。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     maxStackSize 小于零。
            [SecuritySafeCritical]
            public Thread(ThreadStart start, int maxStackSize);
            //
            // 摘要:
            //     初始化 System.Threading.Thread 类的新实例，指定允许对象在线程启动时传递给线程的委托，并指定线程的最大堆栈大小。
            //
            // 参数:
            //   start:
            //     表示开始执行此线程时要调用的方法的 System.Threading.ParameterizedThreadStart 委托。
            //
            //   maxStackSize:
            //     线程要使用的最大堆栈大小（以字节为单位）；如果为 0，则使用可执行文件的文件头中指定的默认最大堆栈大小。 重要事项：对于部分受信任的代码，如果 maxStackSize
            //     大于默认堆栈大小，则将其忽略。 不引发异常。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     start 为 null。
            //
            //   T:System.ArgumentOutOfRangeException:
            //     maxStackSize 小于零。
            [SecuritySafeCritical]
            public Thread(ParameterizedThreadStart start, int maxStackSize);
    
            //
            // 摘要:
            //     确保垃圾回收器回收 System.Threading.Thread 对象时释放资源并执行其他清理操作。
            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
            [SecuritySafeCritical]
            ~Thread();
    
            //
            // 摘要:
            //     获取或设置线程的当前负责人（对基于角色的安全性而言）。
            //
            // 返回结果:
            //     表示安全上下文的 System.Security.Principal.IPrincipal 值。
            //
            // 异常:
            //   T:System.Security.SecurityException:
            //     调用方没有设置该主体所需的权限。
            public static IPrincipal CurrentPrincipal { get; set; }
            //
            // 摘要:
            //     获取当前正在运行的线程。
            //
            // 返回结果:
            //     System.Threading.Thread，表示当前正在运行的线程。
            public static Thread CurrentThread { get; }
            //
            // 摘要:
            //     获取线程正在其中执行的当前上下文。
            //
            // 返回结果:
            //     表示当前线程上下文的 System.Runtime.Remoting.Contexts.Context。
            //
            // 异常:
            //   T:System.Security.SecurityException:
            //     调用方没有所要求的权限。
            public static Context CurrentContext { get; }
            //
            // 摘要:
            //     获取或设置当前线程的区域性。
            //
            // 返回结果:
            //     表示当前线程的区域性的对象。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     属性设置为 null。
            public CultureInfo CurrentCulture { get; set; }
            //
            // 摘要:
            //     获取或设置资源管理器使用的当前区域性以便在运行时查找区域性特定的资源。
            //
            // 返回结果:
            //     表示当前区域性的对象。
            //
            // 异常:
            //   T:System.ArgumentNullException:
            //     属性设置为 null。
            //
            //   T:System.ArgumentException:
            //     该属性设置为不能用于定位资源文件的区域性名称。 资源文件名必须仅包含字母、数字、连字符或下划线。
            public CultureInfo CurrentUICulture { get; set; }
            //
            // 摘要:
            //     获取或设置此线程的单元状态。
            //
            // 返回结果:
            //     System.Threading.ApartmentState 值之一。 初始值为 Unknown。
            //
            // 异常:
            //   T:System.ArgumentException:
            //     尝试将此属性设置为不是有效单元状态的状态 （单线程单元 (STA) 或多线程单元 (MTA) 以外的状态）。
            [Obsolete("The ApartmentState property has been deprecated.  Use GetApartmentState, SetApartmentState or TrySetApartmentState instead.", false)]
            public ApartmentState ApartmentState { get; set; }
            //
            // 摘要:
            //     获取或设置一个值，该值指示某个线程是否为后台线程。
            //
            // 返回结果:
            //     如果此线程为或将成为后台线程，则为 true；否则为 false。
            //
            // 异常:
            //   T:System.Threading.ThreadStateException:
            //     线程终止。
            public bool IsBackground { get; set; }
            //
            // 摘要:
            //     获取指示线程是否属于托管线程池的值。
            //
            // 返回结果:
            //     如果此线程属于托管线程池，则为 true；否则为 false。
            public bool IsThreadPoolThread { get; }
            //
            // 摘要:
            //     获取指示当前线程的执行状态的值。
            //
            // 返回结果:
            //     如果此线程已经开始但尚未正常终止或中止，则为 true，否则为 false。
            public bool IsAlive { get; }
            //
            // 摘要:
            //     获取或设置指示线程的调度优先级的值。
            //
            // 返回结果:
            //     System.Threading.ThreadPriority 值之一。 默认值为 System.Threading.ThreadPriority.Normal。
            //
            // 异常:
            //   T:System.Threading.ThreadStateException:
            //     线程已到达最终状态，如 System.Threading.ThreadState.Aborted。
            //
            //   T:System.ArgumentException:
            //     为集运算指定的值不是有效的 System.Threading.ThreadPriority 值。
            public ThreadPriority Priority { get; set; }
            //
            // 摘要:
            //     获取 System.Threading.ExecutionContext 对象，该对象包含有关当前线程的各种上下文的信息。
            //
            // 返回结果:
            //     一个 System.Threading.ExecutionContext 对象，包含当前线程的上下文信息。
            public ExecutionContext ExecutionContext { get; }
            //
            // 摘要:
            //     获取当前托管线程的唯一标识符。
            //
            // 返回结果:
            //     一个整数，表示此托管线程的唯一标识符。
            public int ManagedThreadId { get; }
            //
            // 摘要:
            //     获取一个值，该值包含当前线程的状态。
            //
            // 返回结果:
            //     其中一个表示当前线程的状态的 System.Threading.ThreadState 值。 初始值为 Unstarted。
            public ThreadState ThreadState { get; }
            //
            // 摘要:
            //     获取或设置线程的名称。
            //
            // 返回结果:
            //     包含线程名称的字符串或 null（如果未设置名称）。
            //
            // 异常:
            //   T:System.InvalidOperationException:
            //     已请求集运算，但 Name 属性已设置。
            public string Name { get; set; }
    
            //
            // 摘要:
            //     在所有线程上分配未命名的数据槽。 为了获得更好的性能，请改用以 System.ThreadStaticAttribute 特性标记的字段。
            //
            // 返回结果:
            //     所有线程上已分配的命名数据槽。
            public static LocalDataStoreSlot AllocateDataSlot();
            //
            // 摘要:
            //     在所有线程上分配已命名的数据槽。 为了获得更好的性能，请改用以 System.ThreadStaticAttribute 特性标记的字段。
            //
            // 参数:
            //   name:
            //     要分配的数据槽的名称。
            //
            // 返回结果:
            //     所有线程上已分配的命名数据槽。
            //
            // 异常:
            //   T:System.ArgumentException:
            //     已存在具有指定名称的命名的数据槽。
            public static LocalDataStoreSlot AllocateNamedDataSlot(string name);
            //
            // 摘要:
            //     通知宿主执行将要进入一个代码区域，在该代码区域内线程中止或未经处理异常的影响可能会危害应用程序域中的其他任务。
            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
            [SecuritySafeCritical]
            public static void BeginCriticalRegion();
            //
            // 摘要:
            //     通知宿主托管代码将要执行依赖于当前物理操作系统线程的标识的指令。
            //
            // 异常:
            //   T:System.Security.SecurityException:
            //     调用方没有所要求的权限。
            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
            [SecurityCritical]
            public static void BeginThreadAffinity();
            //
            // 摘要:
            //     通知主机执行将要进入一个代码区域，在该代码区域内线程中止或未经处理异常的影响限于当前任务。
            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
            [SecuritySafeCritical]
            public static void EndCriticalRegion();
            //
            // 摘要:
            //     通知宿主托管代码已执行完依赖于当前物理操作系统线程的标识的指令。
            //
            // 异常:
            //   T:System.Security.SecurityException:
            //     调用方没有所要求的权限。
            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
            [SecurityCritical]
            public static void EndThreadAffinity();
            //
            // 摘要:
            //     为进程中的所有线程消除名称与槽之间的关联。 为了获得更好的性能，请改用以 System.ThreadStaticAttribute 特性标记的字段。
            //
            // 参数:
            //   name:
            //     要释放的数据槽的名称。
            public static void FreeNamedDataSlot(string name);
            //
            // 摘要:
            //     在当前线程的当前域中从当前线程上指定的槽中检索值。 为了获得更好的性能，请改用以 System.ThreadStaticAttribute 特性标记的字段。
            //
            // 参数:
            //   slot:
            //     要从其获取值的 System.LocalDataStoreSlot。
            //
            // 返回结果:
            //     检索到的值。
            public static object GetData(LocalDataStoreSlot slot);
            //
            // 摘要:
            //     返回当前线程正在其中运行的当前域。
            //
            // 返回结果:
            //     表示正在运行的线程的当前应用程序域的 System.AppDomain。
            [SecuritySafeCritical]
            public static AppDomain GetDomain();
            //
            // 摘要:
            //     返回唯一的应用程序域标识符。
            //
            // 返回结果:
            //     唯一标识应用程序域的 32 位有符号整数。
            public static int GetDomainID();
            //
            // 摘要:
            //     查找命名的数据槽。 为了获得更好的性能，请改用以 System.ThreadStaticAttribute 特性标记的字段。
            //
            // 参数:
            //   name:
            //     本地数据槽的名称。
            //
            // 返回结果:
            //     为此线程分配的 System.LocalDataStoreSlot。
            public static LocalDataStoreSlot GetNamedDataSlot(string name);
            //
            // 摘要:
            //     按如下方式同步内存访问：执行当前线程的处理器在对指令重新排序时，不能采用先执行 System.Threading.Thread.MemoryBarrier
            //     调用之后的内存存取，再执行 System.Threading.Thread.MemoryBarrier 调用之前的内存存取的方式。
            [SecuritySafeCritical]
            public static void MemoryBarrier();
            //
            // 摘要:
            //     取消当前线程所请求的 System.Threading.Thread.Abort(System.Object)。
            //
            // 异常:
            //   T:System.Threading.ThreadStateException:
            //     未在当前线程上调用 Abort。
            //
            //   T:System.Security.SecurityException:
            //     调用方没有当前线程要求的安全权限。
            [SecuritySafeCritical]
            public static void ResetAbort();
            //
            // 摘要:
            //     在当前正在运行的线程上为此线程的当前域在指定槽中设置数据。 为了提高性能，请改用用 System.ThreadStaticAttribute 属性标记的字段。
            //
            // 参数:
            //   slot:
            //     在其中设置值的 System.LocalDataStoreSlot。
            //
            //   data:
            //     要设置的值。
            public static void SetData(LocalDataStoreSlot slot, object data);
            //
            // 摘要:
            //     将当前线程挂起指定的时间。
            //
            // 参数:
            //   timeout:
            //     挂起线程的时间量。 如果 millisecondsTimeout 参数的值为 System.TimeSpan.Zero，则该线程会将其时间片的剩余部分让给任何已经准备好运行的、具有同等优先级的线程。
            //     如果没有其他已经准备好运行的、具有同等优先级的线程，则不会挂起当前线程的执行。
            //
            // 异常:
            //   T:System.ArgumentOutOfRangeException:
            //     timeout 的值为负数，且不等于 System.Threading.Timeout.Infinite（以毫秒为单位），或大于 System.Int32.MaxValue
            //     毫秒。
            public static void Sleep(TimeSpan timeout);
            //
            // 摘要:
            //     将当前线程挂起指定的毫秒数。
            //
            // 参数:
            //   millisecondsTimeout:
            //     挂起线程的毫秒数。 如果 millisecondsTimeout 参数的值为零，则该线程会将其时间片的剩余部分让给任何已经准备好运行的、具有同等优先级的线程。
            //     如果没有其他已经准备好运行的、具有同等优先级的线程，则不会挂起当前线程的执行。
            //
            // 异常:
            //   T:System.ArgumentOutOfRangeException:
            //     超时值为负且不等于 System.Threading.Timeout.Infinite。
            [SecuritySafeCritical]
            public static void Sleep(int millisecondsTimeout);
            //
            // 摘要:
            //     导致线程等待由 iterations 参数定义的时间量。
            //
            // 参数:
            //   iterations:
            //     定义线程等待的时间长短的 32 位有符号整数。
            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
            [SecuritySafeCritical]
            public static void SpinWait(int iterations);
            //
            // 摘要:
            //     读取字段值。 无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。
            //
            // 参数:
            //   address:
            //     要读取的字段。
            //
            // 返回结果:
            //     由任何处理器写入字段的最新值。
            [CLSCompliant(false)]
            public static ulong VolatileRead(ref ulong address);
            //
            // 摘要:
            //     读取字段值。 无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。
            //
            // 参数:
            //   address:
            //     要读取的字段。
            //
            // 返回结果:
            //     由任何处理器写入字段的最新值。
            public static double VolatileRead(ref double address);
            //
            // 摘要:
            //     读取字段值。 无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。
            //
            // 参数:
            //   address:
            //     要读取的字段。
            //
            // 返回结果:
            //     由任何处理器写入字段的最新值。
            public static object VolatileRead(ref object address);
            //
            // 摘要:
            //     读取字段值。 无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。
            //
            // 参数:
            //   address:
            //     要读取的字段。
            //
            // 返回结果:
            //     由任何处理器写入字段的最新值。
            [CLSCompliant(false)]
            public static UIntPtr VolatileRead(ref UIntPtr address);
            //
            // 摘要:
            //     读取字段值。 无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。
            //
            // 参数:
            //   address:
            //     要读取的字段。
            //
            // 返回结果:
            //     由任何处理器写入字段的最新值。
            public static IntPtr VolatileRead(ref IntPtr address);
            //
            // 摘要:
            //     读取字段值。 无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。
            //
            // 参数:
            //   address:
            //     要读取的字段。
            //
            // 返回结果:
            //     由任何处理器写入字段的最新值。
            [CLSCompliant(false)]
            public static uint VolatileRead(ref uint address);
            //
            // 摘要:
            //     读取字段值。 无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。
            //
            // 参数:
            //   address:
            //     要读取的字段。
            //
            // 返回结果:
            //     由任何处理器写入字段的最新值。
            [CLSCompliant(false)]
            public static ushort VolatileRead(ref ushort address);
            //
            // 摘要:
            //     读取字段值。 无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。
            //
            // 参数:
            //   address:
            //     要读取的字段。
            //
            // 返回结果:
            //     由任何处理器写入字段的最新值。
            public static float VolatileRead(ref float address);
            //
            // 摘要:
            //     读取字段值。 无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。
            //
            // 参数:
            //   address:
            //     要读取的字段。
            //
            // 返回结果:
            //     由任何处理器写入字段的最新值。
            public static long VolatileRead(ref long address);
            //
            // 摘要:
            //     读取字段值。 无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。
            //
            // 参数:
            //   address:
            //     要读取的字段。
            //
            // 返回结果:
            //     由任何处理器写入字段的最新值。
            [CLSCompliant(false)]
            public static sbyte VolatileRead(ref sbyte address);
            //
            // 摘要:
            //     读取字段值。 无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。
            //
            // 参数:
            //   address:
            //     要读取的字段。
            //
            // 返回结果:
            //     由任何处理器写入字段的最新值。
            public static byte VolatileRead(ref byte address);
            //
            // 摘要:
            //     读取字段值。 无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。
            //
            // 参数:
            //   address:
            //     要读取的字段。
            //
            // 返回结果:
            //     由任何处理器写入字段的最新值。
            public static short VolatileRead(ref short address);
            //
            // 摘要:
            //     读取字段值。 无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。
            //
            // 参数:
            //   address:
            //     要读取的字段。
            //
            // 返回结果:
            //     由任何处理器写入字段的最新值。
            public static int VolatileRead(ref int address);
            //
            // 摘要:
            //     立即向字段写入一个值，以使该值对计算机中的所有处理器都可见。
            //
            // 参数:
            //   address:
            //     将向其中写入值的字段。
            //
            //   value:
            //     要写入的值。
            public static void VolatileWrite(ref double address, double value);
            //
            // 摘要:
            //     立即向字段写入一个值，以使该值对计算机中的所有处理器都可见。
            //
            // 参数:
            //   address:
            //     将向其中写入值的字段。
            //
            //   value:
            //     要写入的值。
            public static void VolatileWrite(ref object address, object value);
            //
            // 摘要:
            //     立即向字段写入一个值，以使该值对计算机中的所有处理器都可见。
            //
            // 参数:
            //   address:
            //     将向其中写入值的字段。
            //
            //   value:
            //     要写入的值。
            public static void VolatileWrite(ref float address, float value);
            //
            // 摘要:
            //     立即向字段写入一个值，以使该值对计算机中的所有处理器都可见。
            //
            // 参数:
            //   address:
            //     将向其中写入值的字段。
            //
            //   value:
            //     要写入的值。
            [CLSCompliant(false)]
            public static void VolatileWrite(ref UIntPtr address, UIntPtr value);
            //
            // 摘要:
            //     立即向字段写入一个值，以使该值对计算机中的所有处理器都可见。
            //
            // 参数:
            //   address:
            //     将向其中写入值的字段。
            //
            //   value:
            //     要写入的值。
            public static void VolatileWrite(ref IntPtr address, IntPtr value);
            //
            // 摘要:
            //     立即向字段写入一个值，以使该值对计算机中的所有处理器都可见。
            //
            // 参数:
            //   address:
            //     将向其中写入值的字段。
            //
            //   value:
            //     要写入的值。
            [CLSCompliant(false)]
            public static void VolatileWrite(ref uint address, uint value);
            //
            // 摘要:
            //     立即向字段写入一个值，以使该值对计算机中的所有处理器都可见。
            //
            // 参数:
            //   address:
            //     将向其中写入值的字段。
            //
            //   value:
            //     要写入的值。
            [CLSCompliant(false)]
            public static void VolatileWrite(ref ushort address, ushort value);
            //
            // 摘要:
            //     立即向字段写入一个值，以使该值对计算机中的所有处理器都可见。
            //
            // 参数:
            //   address:
            //     将向其中写入值的字段。
            //
            //   value:
            //     要写入的值。
            [CLSCompliant(false)]
            public static void VolatileWrite(ref ulong address, ulong value);
            //
            // 摘要:
            //     立即向字段写入一个值，以使该值对计算机中的所有处理器都可见。
            //
            // 参数:
            //   address:
            //     将向其中写入值的字段。
            //
            //   value:
            //     要写入的值。
            public static void VolatileWrite(ref long address, long value);
            //
            // 摘要:
            //     立即向字段写入一个值，以使该值对计算机中的所有处理器都可见。
            //
            // 参数:
            //   address:
            //     将向其中写入值的字段。
            //
            //   value:
            //     要写入的值。
            public static void VolatileWrite(ref int address, int value);
            //
            // 摘要:
            //     立即向字段写入一个值，以使该值对计算机中的所有处理器都可见。
            //
            // 参数:
            //   address:
            //     将向其中写入值的字段。
            //
            //   value:
            //     要写入的值。
            public static void VolatileWrite(ref short address, short value);
            //
            // 摘要:
            //     立即向字段写入一个值，以使该值对计算机中的所有处理器都可见。
            //
            // 参数:
            //   address:
            //     将向其中写入值的字段。
            //
            //   value:
            //     要写入的值。
            public static void VolatileWrite(ref byte address, byte value);
            //
            // 摘要:
            //     立即向字段写入一个值，以使该值对计算机中的所有处理器都可见。
            //
            // 参数:
            //   address:
            //     将向其中写入值的字段。
            //
            //   value:
            //     要写入的值。
            [CLSCompliant(false)]
            public static void VolatileWrite(ref sbyte address, sbyte value);
            //
            // 摘要:
            //     导致调用线程执行准备好在当前处理器上运行的另一个线程。 由操作系统选择要执行的线程。
            //
            // 返回结果:
            //     如果操作系统转而执行另一个线程，则为 true；否则为 false。
            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
            [SecuritySafeCritical]
            public static bool Yield();
            //
            // 摘要:
            //     引发在其上调用的线程中的 System.Threading.ThreadAbortException 以开始处理终止线程，同时提供有关线程终止的异常信息。
            //     调用此方法通常会终止线程。
            //
            // 参数:
            //   stateInfo:
            //     一个对象，它包含应用程序特定的信息（如状态），该信息可供正被中止的线程使用。
            //
            // 异常:
            //   T:System.Security.SecurityException:
            //     调用方没有所要求的权限。
            //
            //   T:System.Threading.ThreadStateException:
            //     正在中止的线程当前已挂起。
            [SecuritySafeCritical]
            public void Abort(object stateInfo);
            //
            // 摘要:
            //     在调用此方法的线程上引发 System.Threading.ThreadAbortException，以开始终止此线程的过程。 调用此方法通常会终止线程。
            //
            // 异常:
            //   T:System.Security.SecurityException:
            //     调用方没有所要求的权限。
            //
            //   T:System.Threading.ThreadStateException:
            //     正在中止的线程当前已挂起。
            [SecuritySafeCritical]
            public void Abort();
            //
            // 摘要:
            //     对于当前线程关闭运行时可调用包装 (RCW) 的自动清理。
            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
            [SecurityCritical]
            public void DisableComObjectEagerCleanup();
            //
            // 摘要:
            //     返回表示单元状态的 System.Threading.ApartmentState 值。
            //
            // 返回结果:
            //     其中一个表示托管线程的单元状态的 System.Threading.ApartmentState 值。 默认值为 System.Threading.ApartmentState.Unknown。
            [SecuritySafeCritical]
            public ApartmentState GetApartmentState();
            //
            // 摘要:
            //     返回 System.Threading.CompressedStack 对象，此对象可用于获取当前线程的堆栈。
            //
            // 返回结果:
            //     无。
            //
            // 异常:
            //   T:System.InvalidOperationException:
            //     在所有情况下。
            [Obsolete("Thread.GetCompressedStack is no longer supported. Please use the System.Threading.CompressedStack class")]
            [SecurityCritical]
            public CompressedStack GetCompressedStack();
            //
            // 摘要:
            //     返回当前线程的哈希代码。
            //
            // 返回结果:
            //     整数哈希代码值。
            [ComVisible(false)]
            public override int GetHashCode();
            //
            // 摘要:
            //     中断处于 WaitSleepJoin 线程状态的线程。
            //
            // 异常:
            //   T:System.Security.SecurityException:
            //     调用方没有适当的 System.Security.Permissions.SecurityPermission。
            [SecuritySafeCritical]
            public void Interrupt();
            //
            // 摘要:
            //     在继续执行标准的 COM 和 SendMessage 消息泵处理期间，阻止调用线程，直到由该实例表示的线程终止或经过了指定时间为止。
            //
            // 参数:
            //   millisecondsTimeout:
            //     等待线程终止的毫秒数。
            //
            // 返回结果:
            //     如果线程已终止，则为 true；如果 false 参数指定的时间量已过之后还未终止线程，则为 millisecondsTimeout。
            //
            // 异常:
            //   T:System.ArgumentOutOfRangeException:
            //     millisecondsTimeout 的值为负数，且不等于 System.Threading.Timeout.Infinite（以毫秒为单位）。
            //
            //   T:System.Threading.ThreadStateException:
            //     该线程尚未启动。
            [SecuritySafeCritical]
            public bool Join(int millisecondsTimeout);
            //
            // 摘要:
            //     在继续执行标准的 COM 和 SendMessage 消息泵处理期间，阻止调用线程，直到由该实例表示的线程终止。
            //
            // 异常:
            //   T:System.Threading.ThreadStateException:
            //     调用方尝试加入处于 System.Threading.ThreadState.Unstarted 状态的线程。
            //
            //   T:System.Threading.ThreadInterruptedException:
            //     线程在等待时中断。
            [SecuritySafeCritical]
            public void Join();
            //
            // 摘要:
            //     在继续执行标准的 COM 和 SendMessage 消息泵处理期间，阻止调用线程，直到由该实例表示的线程终止或经过了指定时间为止。
            //
            // 参数:
            //   timeout:
            //     设置等待线程终止的时间量的 System.TimeSpan。
            //
            // 返回结果:
            //     如果线程已终止，则为 true；如果 false 参数指定的时间量已过之后还未终止线程，则为 timeout。
            //
            // 异常:
            //   T:System.ArgumentOutOfRangeException:
            //     timeout 的值为负数，且不等于 System.Threading.Timeout.Infinite（以毫秒为单位），或大于 System.Int32.MaxValue
            //     毫秒。
            //
            //   T:System.Threading.ThreadStateException:
            //     调用方尝试加入处于 System.Threading.ThreadState.Unstarted 状态的线程。
            public bool Join(TimeSpan timeout);
            //
            // 摘要:
            //     继续已挂起的线程。
            //
            // 异常:
            //   T:System.Threading.ThreadStateException:
            //     该线程尚未启动、 已死或未处于挂起状态。
            //
            //   T:System.Security.SecurityException:
            //     调用方没有适当的 System.Security.Permissions.SecurityPermission。
            [Obsolete("Thread.Resume has been deprecated.  Please use other classes in System.Threading, such as Monitor, Mutex, Event, and Semaphore, to synchronize Threads or protect resources.  http://go.microsoft.com/fwlink/?linkid=14202", false)]
            [SecuritySafeCritical]
            public void Resume();
            //
            // 摘要:
            //     在线程启动前设置其单元状态。
            //
            // 参数:
            //   state:
            //     新的单元状态。
            //
            // 异常:
            //   T:System.ArgumentException:
            //     state 不是有效的单元状态。
            //
            //   T:System.Threading.ThreadStateException:
            //     线程已启动。
            //
            //   T:System.InvalidOperationException:
            //     已初始化单元状态。
            [SecuritySafeCritical]
            public void SetApartmentState(ApartmentState state);
            //
            // 摘要:
            //     将捕获的 System.Threading.CompressedStack 应用到当前线程。
            //
            // 参数:
            //   stack:
            //     将被应用到当前线程的 System.Threading.CompressedStack 对象。
            //
            // 异常:
            //   T:System.InvalidOperationException:
            //     在所有情况下。
            [Obsolete("Thread.SetCompressedStack is no longer supported. Please use the System.Threading.CompressedStack class")]
            [SecurityCritical]
            public void SetCompressedStack(CompressedStack stack);
            //
            // 摘要:
            //     导致操作系统将当前实例的状态更改为 System.Threading.ThreadState.Running，并选择提供包含线程执行的方法要使用的数据的对象。
            //
            // 参数:
            //   parameter:
            //     一个对象，包含线程执行的方法要使用的数据。
            //
            // 异常:
            //   T:System.Threading.ThreadStateException:
            //     线程已启动。
            //
            //   T:System.OutOfMemoryException:
            //     内存不足，无法启动此线程。
            //
            //   T:System.InvalidOperationException:
            //     该线程是使用 System.Threading.ThreadStart 委托而不是 System.Threading.ParameterizedThreadStart
            //     委托创建的。
            public void Start(object parameter);
            //
            // 摘要:
            //     导致操作系统将当前实例的状态更改为 System.Threading.ThreadState.Running。
            //
            // 异常:
            //   T:System.Threading.ThreadStateException:
            //     线程已启动。
            //
            //   T:System.OutOfMemoryException:
            //     内存不足，无法启动此线程。
            public void Start();
            //
            // 摘要:
            //     挂起线程，或者如果线程已挂起，则不起作用。
            //
            // 异常:
            //   T:System.Threading.ThreadStateException:
            //     线程尚未启动或已终止。
            //
            //   T:System.Security.SecurityException:
            //     调用方没有适当的 System.Security.Permissions.SecurityPermission。
            [Obsolete("Thread.Suspend has been deprecated.  Please use other classes in System.Threading, such as Monitor, Mutex, Event, and Semaphore, to synchronize Threads or protect resources.  http://go.microsoft.com/fwlink/?linkid=14202", false)]
            [SecuritySafeCritical]
            public void Suspend();
            //
            // 摘要:
            //     在线程启动前设置其单元状态。
            //
            // 参数:
            //   state:
            //     新的单元状态。
            //
            // 返回结果:
            //     如果设置了单元状态，则为 true；否则为 false。
            //
            // 异常:
            //   T:System.ArgumentException:
            //     state 不是有效的单元状态。
            //
            //   T:System.Threading.ThreadStateException:
            //     线程已启动。
            [SecuritySafeCritical]
            public bool TrySetApartmentState(ApartmentState state);
        }
    }

![2789632-422941d30fb3c28c.png][]

![2789632-eed6a0dd6f53874c.jpg][]

[2789632-319faf809c16d1ac.png]: /images/20210615/243709593bbd42df8e3b3cc195a59f1a.png
[2789632-422941d30fb3c28c.png]: /images/20210615/1431ac2b2da545c68569ebcc7c06a011.png
[2789632-eed6a0dd6f53874c.jpg]: /images/20210615/87e0526492e6457285cbb72f5dc326f7.png