在实例化Thread的实例，需要提供一个委托，在实例化这个委托时所用到的参数是线程将来启动时要运行的方法。在.net中提供了两种启动线程的方式，一种是不带参数的启动方式，另一种是带参数的启动的方式。

 不带参数的启动方式

1. using System;  
2.     using System.Collections.Generic;  
3.     using System.Text;  
4.     using System.Threading;  
5.       
6.     namespace StartThread  
7.     {  
8.         class Program  
9.         {  
10.             int interval = 200;  
11.             static void Main(string[] args)  
12.             {  
13.                 Program p = new Program();  
14.                 Thread nonParameterThread = new Thread(new ThreadStart(p.NonParameterRun));  
15.                 nonParameterThread.Start();  
16.             }  
17.             /// <summary>  
18.             /// 不带参数的启动方法  
19.             /// </summary>  
20.             public void NonParameterRun()  
21.             {  
22.                 for (int i = 0; i < 10; i++)  
23.                 {  
24.                     Console.WriteLine("系统当前时间毫秒值："+DateTime.Now.Millisecond.ToString());  
25.                     Thread.Sleep(interval);//让线程暂停  
26.                 }  
27.         }  
28.     } 

 带参数的启动方法
 如果要在实例化线程时要带一些参数，就不能用ThreadStart委托作为构造函数的参数来实例化Thread了，而要ParameterizedThreadStart委托，和ThreadStart一样的是它也是线程启动时要执行的方法，和ThreadStart不同的是，它在实例化时可以用一个带有一个Object参数的方法作为构造函数的参数，而实例化ThreadStart时所用到的方法是没有参数的。
 为什么是Object这样的参数呢？很简单，因为在.net中Object是所有类型的基类，用它可以表示Array(数组）、Interface（接口）、ValueType（值类型，如bool,byte,char,short,int,float,long,double等）、class(类）等.net中的类型。当然，这也意味着如果你要启动一个线程，给它传递一个int类型参数时，必须在启动方法中进行相应的类型转换。

1. using System;  
2.     using System.Collections.Generic;  
3.     using System.Text;  
4.     using System.Threading;  
5.       
6.     namespace StartThread  
7.     {  
8.         class Program  
9.         {  
10.             int interval = 200;  
11.             static void Main(string[] args)  
12.             {  
13.                 Program p = new Program();  
14.       
15.                 Thread parameterThread = new Thread(new ParameterizedThreadStart(p.ParameterRun));  
16.                 parameterThread.Name = "Thread A:";  
17.                 parameterThread.Start(30);  
18.             }  
19.          
20.             /// <summary>  
21.             /// 带参数的启动方法  
22.             /// </summary>  
23.             /// <param name="ms">让线程在运行过程中的休眠间隔</param>  
24.             public void ParameterRun(object ms)  
25.             {  
26.                 int j = 10;  
27.                 int.TryParse(ms.ToString(), out j);//这里采用了TryParse方法，避免不能转换时出现异常  
28.                 for (int i = 0; i < 10; i++)  
29.                 {  
30.                     Console.WriteLine(Thread.CurrentThread.Name+"系统当前时间毫秒值：" + DateTime.Now.Millisecond.ToString());  
31.                     Thread.Sleep(j);//让线程暂停  
32.                 }  
33.             }  
34.         }  
35.     } 

上面是一种

（2）创建自定义类

using System;
using System.Threading;

namespace ThreadWithParameters
{
    public class MyThread
    {
        private string data;

        public MyThread(string data)
        {
            this.data = data;
        }

        public void ThreadMain()
        {
            Console.WriteLine("Running in a thread,data: {0}", data);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyThread myThread = new MyThread("hello world");

            Thread thread = new Thread(myThread.ThreadMain);
            thread.Start();

            Console.Read();
        }
    }
}

（3）使用匿名方法

class Program
{
    static void Main(string[] args)
    {
        string hello = "hello world";

        //如果写成Thread thread = new Thread(ThreadMainWithParameters(hello));这种形式，编译时就会报错
        Thread thread = new Thread(() => ThreadMainWithParameters(hello));
        thread.Start();

        Console.Read();
    }

    static void ThreadMainWithParameters(string str)
    {
         Console.WriteLine("Running in a thread,received: {0}", str);
    }

如果在启动线程时需要参数，而且在启动线程时不但要指定线程的暂停间隔，还需要指定循环次数（即多参数）

首先可以继续在ParameterizedThreadStart这里做文章，因为这里可以使用一个Object类型的参数，那么可以通过一个类来解决

1. using System;  
2.     using System.Collections.Generic;  
3.     using System.Text;  
4.     using System.Threading;  
5.       
6.     namespace StartThread  
7.     {  
8.         class MyThreadParameter  
9.         {  
10.             private int interval;  
11.             private int loopCount;  
12.             /// <summary>  
13.             /// 循环次数  
14.             /// </summary>  
15.             public int LoopCount  
16.             {  
17.                 get { return loopCount; }  
18.             }  
19.           
20.             /// <summary>  
21.             /// 线程的暂停间隔  
22.             /// </summary>  
23.             public int Interval  
24.             {  
25.                 get { return interval; }  
26.             }  
27.             /// <summary>  
28.             /// 构造函数  
29.             /// </summary>  
30.             /// <param name="interval">线程的暂停间隔</param>  
31.             /// <param name="loopCount">循环次数</param>  
32.             public MyThreadParameter(int interval,int loopCount)  
33.             {  
34.                 this.interval = interval;  
35.                 this.loopCount = loopCount;  
36.             }  
37.         }  
38.         class Program  
39.         {  
40.             int interval = 200;  
41.             static void Main(string[] args)  
42.             {  
43.                 Program p = new Program();  
44.       
45.                 Thread parameterThread = new Thread(new ParameterizedThreadStart(p.MyParameterRun));  
46.                 parameterThread.Name = "Thread A:";  
47.                 MyThreadParameter paramter = new MyThreadParameter(50, 20);  
48.                 parameterThread.Start(paramter);  
49.             }  
50.        
51.       
52.             /// <summary>  
53.             /// 带多个参数的启动方法  
54.             /// </summary>  
55.             /// <param name="ms">方法参数</param>  
56.             public void MyParameterRun(object ms)  
57.             {  
58.                 MyThreadParameter parameter = ms as MyThreadParameter;//类型转换  
59.                 if (parameter != null)  
60.                 {  
61.                     for (int i = 0; i < parameter.LoopCount; i++)  
62.                     {  
63.                         Console.WriteLine(Thread.CurrentThread.Name + "系统当前时间毫秒值：" + DateTime.Now.Millisecond.ToString());  
64.                         Thread.Sleep(parameter.Interval);//让线程暂停  
65.                     }  
66.                 }  
67.             }  
68.         }  
69.     }