创建线程(From MSDN)

最新推荐文章于 2022-08-23 21:18:43 发布

hyde82

最新推荐文章于 2022-08-23 21:18:43 发布

阅读量1.1k

点赞数

分类专栏： Dot NET Code 文章标签： thread callback class printing integer constructor

本文链接：https://blog.csdn.net/hyde82/article/details/572176

版权

Dot NET Code 专栏收录该内容

60 篇文章 0 订阅

订阅专栏

这贴-----为了不用去看MSDN，所以贴了上来！

在创建操作系统进程时，操作系统将插入一个线程以执行该进程（包括任何原始应用程序域）中的代码。从此刻起，就可以创建和销毁应用程序域，而不必创建或销毁任何操作系统线程。如果正在执行的代码是托管代码，则可以通过在线程类 tabindex="0" keywords="frlrfSystemThreadingThreadClassCurrentThreadTopic">Thread.CurrentThread 上检索静态属性来获取正在当前应用程序域中执行的线程的 tabindex="0" keywords="frlrfSystemThreadingThreadClassTopic">Thread 对象。

创建 Thread 对象的新实例时，将创建新的托管线程。Thread 的构造函数采用 tabindex="0" keywords="frlrfSystemThreadingThreadStartClassTopic">ThreadStart 委托作为其唯一参数，该委托用于包装在调用 tabindex="0" keywords="frlrfSystemThreadingThreadClassStartTopic">Thread.Start 时由新的 Thread 调用的方法。多次调用 Thread.Start 将引发 tabindex="0" keywords="frlrfSystemThreadingThreadStateExceptionClassTopic">ThreadStateException。

Thread.Start 向系统提交异步请求，并且该调用可能在新的线程实际启动之前立即返回。可以使用 tabindex="0" keywords="frlrfSystemThreadingThreadClassThreadStateTopic">Thread.ThreadState 和 tabindex="0" keywords="frlrfSystemThreadingThreadClassIsAliveTopic">Thread.IsAlive 在任一时刻确定线程的状态。 tabindex="0" keywords="frlrfSystemThreadingThreadClassAbortTopic">Thread.Abort 中止线程，并对其进行标记以进行垃圾回收。下面的代码示例创建两个新线程以调用另一个对象上的实例和静态方法。

[Visual Basic]
Imports System
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.")
      Thread.Sleep(3000) ' Pause for a moment to provide a delay to make threads more apparent.
      Console.WriteLine("The instance method called by the worker thread has ended.")
   End Sub 'InstanceMethod
   
   Public Shared Sub StaticMethod()
      Console.WriteLine("ServerClass.StaticMethod is running on another thread.")
      Thread.Sleep(5000) ' Pause for a moment to provide a delay to make threads more apparent.
      Console.WriteLine("The static method called by the worker thread has ended.")
   End Sub 'StaticMethod
End Class 'ServerClass

Public Class Simple
   
   Public Shared Sub Main() 
      Console.WriteLine("Thread Simple Sample")
      
      Dim serverObject As New ServerClass()
      
      ' Create the thread object, passing in the 
      ' serverObject.InstanceMethod method using a
      ' ThreadStart delegate.
      Dim InstanceCaller As New Thread(New ThreadStart(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.StaticMethod 
      ' method using a ThreadStart delegate.
      Dim StaticCaller As New Thread(New ThreadStart(AddressOf ServerClass.StaticMethod))
      
      ' Start the thread.
      StaticCaller.Start()
      
      Console.WriteLine("The Main() thread calls this after starting the new StaticCaller threads.")
      
   End Sub 'Main
End Class 'Simple

[C#]
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 int Main(String[] args){
      Console.WriteLine("Thread Simple Sample");

      ServerClass serverObject = new ServerClass();

      // Create the thread object, passing in the 
      // serverObject.InstanceMethod method using a ThreadStart delegate.
      Thread InstanceCaller = new Thread(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 Thread(new ThreadStart(ServerClass.StaticMethod));

      // Start the thread.
      StaticCaller.Start();

      Console.WriteLine("The Main() thread calls this after starting the new StaticCaller threads.");

      return 0;
   }
}

向线程传递数据

ThreadStart 委托既没有参数也没有返回值。这意味着不可以使用需要参数的方法启动线程，或从方法中获得返回值。

为向线程传递数据，需要创建一个用来保持数据和线程方法的对象，如下面的两个代码示例所示。
为检索线程方法的结果，您可以使用回调方法，如第二个代码示例中所示。

[Visual Basic]
Imports System
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 value As Integer

    ' The constructor obtains the state information.
    Public Sub New(ByVal text As String, ByVal number As Integer)
        boilerplate = text
        value = number
    End Sub
           
    ' The thread procedure performs the task, such as formatting 
    ' and printing a document.
    Public Sub ThreadProc()
        Console.WriteLine(boilerplate, value) 
    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(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

[C#]
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 value;

    // The constructor obtains the state information.
    public ThreadWithState(string text, int number) {
        boilerplate = text;
        value = number;
    }
           
    // The thread procedure performs the task, such as formatting 
    // and printing a document.
    public void ThreadProc() {
        Console.WriteLine(boilerplate, value); 
    }
}

// Entry point for the example.
//
public class Example {
    public static void Main() {
        // Supply the state information required by the task.
        ThreadWithState tws =
            new ThreadWithState("This report displays the number {0}.", 42);
        // Create a thread to execute the task, and then
        // start the thread.
        Thread t = new Thread(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.");  
    }
}

用回调方法检索数据

下面的示例演示了一个从线程中检索数据的回调方法。包含数据和线程方法的类的构造函数也接受代表回调方法的委托；在线程方法结束前，它调用该回调委托。

[Visual Basic]
Imports System
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 value 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(ByVal text As String, ByVal number As Integer, _
                   ByVal callbackDelegate As ExampleCallback)
        boilerplate = text
        value = 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, value) 
        If Not callback Is Nothing Then callback(1)
    End Sub
End Class

' Delegate that defines the signature for the callback method.
'
Public Delegate Sub ExampleCallback(ByVal lineCount As Integer)

' 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, _
            New ExampleCallback(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

    ' The callback method must match the signature of the
    ' callback delegate.
    '
    Public Shared Sub ResultCallback(ByVal lineCount As Integer)
        Console.WriteLine("Independent task printed {0} lines.", lineCount)  
    End Sub
End Class

[C#]
using System;
using 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 string boilerplate;
    private int value;
    // 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 ThreadWithState(string text, int number, 
                   ExampleCallback callbackDelegate) 
    {
        boilerplate = text;
        value = 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, value);
        if (callback != null)
            callback(1);
    }
}

// Delegate that defines the signature for the callback method.
//
public delegate void ExampleCallback(int lineCount);

// Entry point for the example.
//
public class Example {
    public static void Main() {
        // Supply the state information required by the task.
        ThreadWithState tws = new ThreadWithState(
            "This report displays the number {0}.",
            42,
            new ExampleCallback(ResultCallback)
        );

        Thread t = new Thread(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 {0} lines.", lineCount);  
    }
}