Thread类的基本用法1_new thread(delegate-CSDN博客

一、 Thread类的基本用法

通过System.Threading.Thread类可以开始新的线程，并在线程堆栈中运行静态或实例方法。可以通过Thread类的的构造方法传递一个无参数，并且不返回值（返回void）的委托(ThreadStart)，这个委托的定义如下：

[ComVisibleAttribute(true)]

public delegate void ThreadStart()

我们可以通过如下的方法来建立并运行一个线程。

 
      
    
using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading;
 
 namespace MyThread
 {
     class Program
      {
         public static void myStaticThreadMethod()
          {
              Console.WriteLine("myStaticThreadMethod");
          }
         static void Main(string[] args)
          {
              Thread thread1 = new Thread(myStaticThreadMethod);
              thread1.Start();  // 只要使用Start方法，线程才会运行
          }
      }
 }
  
      
    

除了运行静态的方法，还可以在线程中运行实例方法，代码如下：

 
      
    
using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading;
 
 namespace MyThread
 {
     class Program
      {
         public void myThreadMethod()
          {
              Console.WriteLine("myThreadMethod");
          }
         static void Main(string[] args)
          {
              Thread thread2 = new Thread(new Program().myThreadMethod);
              thread2.Start();
          }
      }
 }
  
      
    

如果读者的方法很简单，或出去某种目的，也可以通过匿名委托或 Lambda 表达式来为 Thread 的构造方法赋值，代码如下：

 
    Thread thread3  
    = 
      
    new 
     Thread( 
    delegate 
    () { Console.WriteLine( 
    " 
    匿名委托 
    " 
    ); });
 thread3.Start();
 
 Thread thread4  
    = 
      
    new 
     Thread(( )  
    => 
     { Console.WriteLine( 
    " 
    Lambda表达式 
    " 
    ); });
 thread4.Start();
  
   

其中Lambda表达式前面的( )表示没有参数。

为了区分不同的线程，还可以为Thread类的Name属性赋值，代码如下：

 
    Thread thread5  
    = 
      
    new 
     Thread(()  
    => 
     { Console.WriteLine(Thread.CurrentThread.Name); });
 thread5.Name  
    = 
      
    " 
    我的Lamdba 
    " 
    ;
 thread5.Start();
  
   

如果将上面thread1至thread5放到一起执行，由于系统对线程的调度不同，输出的结果是不定的，如图1是一种可能的输出结果。

图1

二、定义一个线程类

我们可以将 Thread 类封装在一个 MyThread 类中，以使任何从 MyThread 继承的类都具有多线程能力。 MyThread 类的代码如下：

 
      
    
using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading;
 namespace MyThread
 {
    abstract class MyThread
      {
         Thread thread = null;
 
        abstract public void run();    
 
         public void start()
          {
             if (thread == null)
                  thread = new Thread(run);
              thread.Start();
          }
      }
 }
  
      
    

可以用下面的代码来使用MyThread类。

 
 class NewThread : MyThread
 {
       override public void run()
        {
            Console.WriteLine("使用MyThread建立并运行线程");
        }
    }
 
   static void Main(string[] args)
    {
 
        NewThread nt = new NewThread();
        nt.start();
    }

我们还可以利用MyThread来为线程传递任意复杂的参数。详细内容见下节。

三、为线程传递参数

Thread类有一个带参数的委托类型的重载形式。这个委托的定义如下：

[ComVisibleAttribute(false)]

public delegate void ParameterizedThreadStart(Object obj)

这个Thread类的构造方法的定义如下：

 
    public 
     Thread(ParameterizedThreadStart start);

下面的代码使用了这个带参数的委托向线程传递一个字符串参数：

 
public static void myStaticParamThreadMethod(Object obj)
 {
     Console.WriteLine(obj);
 }
 
 static void Main(string[] args)
 {
       Thread thread = new Thread(myStaticParamThreadMethod);
       thread.Start("通过委托的参数传值");
 }

要注意的是，如果使用的是不带参数的委托，不能使用带参数的Start方法运行线程，否则系统会抛出异常。但使用带参数的委托，可以使用thread.Start()来运行线程，这时所传递的参数值为null。

也可以定义一个类来传递参数值，如下面的代码如下：

 
      
    
class MyData
 {
     private String d1;
     private int d2;
     public MyData(String d1, int d2)
     {
     this.d1 = d1;
     this.d2 = d2;
     }
     public void threadMethod()
     {
         Console.WriteLine(d1);
       Console.WriteLine(d2);
     }
 }

 MyData myData = new MyData("abcd",1234);
 Thread thread = new Thread(myData.threadMethod);
 thread.Start();
  
      
    

如果使用在第二节定义的 MyThread 类，传递参数会显示更简单，代码如下：

 
      
    
class NewThread : MyThread
 {
     private String p1;
     private int p2;
     public NewThread(String p1, int p2)
      {
         this.p1 = p1;
         this.p2 = p2;
      }
 
     override public void run()
      {
          Console.WriteLine(p1);
          Console.WriteLine(p2);
      }
 }
 
 NewThread newThread = new NewThread("hello world", 4321);
 newThread.start();
  
      
    

四、前台和后台线程

使用 Thread 建立的线程默认情况下是前台线程，在进程中，只要有一个前台线程未退出，进程就不会终止。主线程就是一个前台线程。而后台线程不管线程是否结束，只要所有的前台线程都退出（包括正常退出和异常退出）后，进程就会自动终止。一般后台线程用于处理时间较短的任务，如在一个 Web 服务器中可以利用后台线程来处理客户端发过来的请求信息。而前台线程一般用于处理需要长时间等待的任务，如在 Web 服务器中的监听客户端请求的程序，或是定时对某些系统资源进行扫描的程序。下面的代码演示了前台和后台线程的区别。

 
public static void myStaticThreadMethod()
 {
     Thread.Sleep(3000);
 }
 
 Thread thread = new Thread(myStaticThreadMethod);
 // thread.IsBackground = true;
 thread.Start();