创建操作系统进程时，操作系统会注入一个线程以在该进程中执行代码，包括任何原始的应用程序域。 从此开始，可以创建和销毁应用程序域，而无需创建或销毁任何作系统线程。 如果所执行的代码是托管代码，那么可以通过检索Thread类型的静态CurrentThread属性来获取当前应用程序域中执行线程的Thread对象。 本主题介绍线程创建，并讨论将数据传递到线程过程的替代方法。
创建线程
Thread创建新对象会创建新的托管线程。 该 Thread 类具有采用 ThreadStart 委托或 ParameterizedThreadStart 委托的构造函数，委托封装了在调用 Start 方法时由新线程调用的方法。 多次调用Start会导致引发ThreadStateException。
该方法 Start 会立即返回，通常在新线程实际启动之前返回。 可以使用 ThreadState 和 IsAlive 属性确定线程在任何时刻的状态，但这些属性不应用于同步线程的活动。
注释
启动线程后，无需保留对对象的 Thread 引用。 线程继续执行，直到线程过程结束。
下面的代码示例创建两个新线程来调用另一个对象的实例和静态方法。
using System;
using System.Threading;
public class ServerClass
{
// The method that will be called when the thread is started.
public void InstanceMethod()
{
Console.WriteLine(
"ServerClass.InstanceMethod is running on another thread.");
// Pause for a moment to provide a delay to make
// threads more apparent.
Thread.Sleep(3000);
Console.WriteLine(
"The instance method called by the worker thread has ended.");
}
public static void StaticMethod()
{
Console.WriteLine(
"ServerClass.StaticMethod is running on another thread.");
// Pause for a moment to provide a delay to make
// threads more apparent.
Thread.Sleep(5000);
Console.WriteLine(
"The static method called by the worker thread has ended.");
}
}
public class Simple
{
public static void Main()
{
ServerClass serverObject = new ServerClass();
// Create the thread object, passing in the
// serverObject.InstanceMethod method using a
// ThreadStart delegate.
Thread InstanceCaller = new(new ThreadStart(serverObject.InstanceMethod));
// Start the thread.
InstanceCaller.Start();
Console.WriteLine("The Main() thread calls this after "
+ "starting the new InstanceCaller thread.");
// Create the thread object, passing in the
// serverObject.StaticMethod method using a
// ThreadStart delegate.
Thread StaticCaller = new(new ThreadStart(ServerClass.StaticMethod));
// Start the thread.
StaticCaller.Start();
Console.WriteLine("The Main() thread calls this after "
+ "starting the new StaticCaller thread.");
}
}
// The example displays the output like the following:
// The Main() thread calls this after starting the new InstanceCaller thread.
// The Main() thread calls this after starting the new StaticCaller thread.
// ServerClass.StaticMethod is running on another thread.
// ServerClass.InstanceMethod is running on another thread.
// The instance method called by the worker thread has ended.
// The static method called by the worker thread has ended.
Imports System.Threading
Public class ServerClass
' The method that will be called when the thread is started.
Public Sub InstanceMethod()
Console.WriteLine(
"ServerClass.InstanceMethod is running on another thread.")
' Pause for a moment to provide a delay to make
' threads more apparent.
Thread.Sleep(3000)
Console.WriteLine(
"The instance method called by the worker thread has ended.")
End Sub
Public Shared Sub SharedMethod()
Console.WriteLine(
"ServerClass.SharedMethod is running on another thread.")
' Pause for a moment to provide a delay to make
' threads more apparent.
Thread.Sleep(5000)
Console.WriteLine(
"The Shared method called by the worker thread has ended.")
End Sub
End Class
Public class Simple
Public Shared Sub Main()
Dim serverObject As New ServerClass()
' Create the thread object, passing in the
' serverObject.InstanceMethod method using a
' ThreadStart delegate.
Dim InstanceCaller As New Thread(AddressOf serverObject.InstanceMethod)
' Start the thread.
InstanceCaller.Start()
Console.WriteLine("The Main() thread calls this after " _
+ "starting the new InstanceCaller thread.")
' Create the thread object, passing in the
' serverObject.SharedMethod method using a
' ThreadStart delegate.
Dim SharedCaller As New Thread( _
New ThreadStart(AddressOf ServerClass.SharedMethod))
' Start the thread.
SharedCaller.Start()
Console.WriteLine("The Main() thread calls this after " _
+ "starting the new SharedCaller thread.")
End Sub
End Class
' The example displays output like the following:
' The Main() thread calls this after starting the new InstanceCaller thread.
' The Main() thread calls this after starting the new StaticCaller thread.
' ServerClass.StaticMethod is running on another thread.
' ServerClass.InstanceMethod is running on another thread.
' The instance method called by the worker thread has ended.
' The static method called by the worker thread has ended.
将数据传递到线程
委托 ParameterizedThreadStart 提供了在调用 Thread.Start(Object)时将包含数据的对象传递给线程的简单方法。 请参阅 ParameterizedThreadStart 代码示例。
使用ParameterizedThreadStart委托不是传递数据的类型安全方法，因为Thread.Start(Object)方法可以接受任何类型的对象。 另一种方法是封装帮助程序类中的线程过程和数据，并使用 ThreadStart 委托执行线程过程。 以下示例演示了以下技术：
using System;
using System.Threading;
// The ThreadWithState class contains the information needed for
// a task, and the method that executes the task.
//
public class ThreadWithState
{
// State information used in the task.
private string _boilerplate;
private int _numberValue;
// The constructor obtains the state information.
public ThreadWithState(string text, int number)
{
_boilerplate = text;
_numberValue = number;
}
// The thread procedure performs the task, such as formatting
// and printing a document.
public void ThreadProc()
{
Console.WriteLine(_boilerplate, _numberValue);
}
}
// Entry point for the example.
public class Example
{
public static void Main()
{
// Supply the state information required by the task.
ThreadWithState tws = new("This report displays the number {0}.", 42);
// Create a thread to execute the task, and then
// start the thread.
Thread t = new(new ThreadStart(tws.ThreadProc));
t.Start();
Console.WriteLine("Main thread does some work, then waits.");
t.Join();
Console.WriteLine(
"Independent task has completed; main thread ends.");
}
}
// The example displays the following output:
// Main thread does some work, then waits.
// This report displays the number 42.
// Independent task has completed; main thread ends.
Imports System.Threading
' The ThreadWithState class contains the information needed for
' a task, and the method that executes the task.
Public Class ThreadWithState
' State information used in the task.
Private boilerplate As String
Private numberValue As Integer
' The constructor obtains the state information.
Public Sub New(text As String, number As Integer)
boilerplate = text
numberValue = number
End Sub
' The thread procedure performs the task, such as formatting
' and printing a document.
Public Sub ThreadProc()
Console.WriteLine(boilerplate, numberValue)
End Sub
End Class
' Entry point for the example.
'
Public Class Example
Public Shared Sub Main()
' Supply the state information required by the task.
Dim tws As New ThreadWithState( _
"This report displays the number {0}.", 42)
' Create a thread to execute the task, and then
' start the thread.
Dim t As New Thread(New ThreadStart(AddressOf tws.ThreadProc))
t.Start()
Console.WriteLine("Main thread does some work, then waits.")
t.Join()
Console.WriteLine( _
"Independent task has completed main thread ends.")
End Sub
End Class
' The example displays the following output:
' Main thread does some work, then waits.
' This report displays the number 42.
' Independent task has completed; main thread ends.
无论ThreadStart还是ParameterizedThreadStart委托都没有返回值，因为异步调用没有返回数据的地方。 若要检索线程方法的结果，可以使用回调方法，如下一部分所示。
使用回调方法从线程检索数据
以下示例演示从线程检索数据的回调方法。 包含数据的类的构造函数和线程方法也接受表示回调方法的委托;在线程方法结束之前，它会调用回调委托。
using System;
using System.Threading;
// The ThreadWithState2 class contains the information needed for
// a task, the method that executes the task, and a delegate
// to call when the task is complete.
public class ThreadWithState2
{
// State information used in the task.
private string _boilerplate;
private int _numberValue;
// Delegate used to execute the callback method when the
// task is complete.
private ExampleCallback _callback;
// The constructor obtains the state information and the
// callback delegate.
public ThreadWithState2(string text, int number,
ExampleCallback callbackDelegate)
{
_boilerplate = text;
_numberValue = number;
_callback = callbackDelegate;
}
// The thread procedure performs the task, such as
// formatting and printing a document, and then invokes
// the callback delegate with the number of lines printed.
public void ThreadProc()
{
Console.WriteLine(_boilerplate, _numberValue);
_callback?.Invoke(1);
}
}
// Delegate that defines the signature for the callback method.
public delegate void ExampleCallback(int lineCount);
// Entry point for the example.
public class Example2
{
public static void Main()
{
// Supply the state information required by the task.
ThreadWithState2 tws = new(
"This report displays the number {0}.",
42,
new ExampleCallback(ResultCallback)
);
Thread t = new(new ThreadStart(tws.ThreadProc));
t.Start();
Console.WriteLine("Main thread does some work, then waits.");
t.Join();
Console.WriteLine(
"Independent task has completed; main thread ends.");
}
// The callback method must match the signature of the
// callback delegate.
public static void ResultCallback(int lineCount)
{
Console.WriteLine($"Independent task printed {lineCount} lines.");
}
}
// The example displays the following output:
// Main thread does some work, then waits.
// This report displays the number 42.
// Independent task printed 1 lines.
// Independent task has completed; main thread ends.
Imports System.Threading
' The ThreadWithState class contains the information needed for
' a task, the method that executes the task, and a delegate
' to call when the task is complete.
Public Class ThreadWithState
' State information used in the task.
Private boilerplate As String
Private numberValue As Integer
' Delegate used to execute the callback method when the
' task is complete.
Private callback As ExampleCallback
' The constructor obtains the state information and the
' callback delegate.
Public Sub New(text As String, number As Integer, _
callbackDelegate As ExampleCallback)
boilerplate = text
numberValue = number
callback = callbackDelegate
End Sub
' The thread procedure performs the task, such as
' formatting and printing a document, and then invokes
' the callback delegate with the number of lines printed.
Public Sub ThreadProc()
Console.WriteLine(boilerplate, numberValue)
If Not (callback Is Nothing) Then
callback(1)
End If
End Sub
End Class
' Delegate that defines the signature for the callback method.
'
Public Delegate Sub ExampleCallback(lineCount As Integer)
Public Class Example
Public Shared Sub Main()
' Supply the state information required by the task.
Dim tws As New ThreadWithState( _
"This report displays the number {0}.", _
42, _
AddressOf ResultCallback)
Dim t As New Thread(AddressOf tws.ThreadProc)
t.Start()
Console.WriteLine("Main thread does some work, then waits.")
t.Join()
Console.WriteLine( _
"Independent task has completed; main thread ends.")
End Sub
Public Shared Sub ResultCallback(lineCount As Integer)
Console.WriteLine( _
"Independent task printed {0} lines.", lineCount)
End Sub
End Class
' The example displays the following output:
' Main thread does some work, then waits.
' This report displays the number 42.
' Independent task printed 1 lines.
' Independent task has completed; main thread ends.
