C#多线程学习之Thread

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading;
 
 namespace ThreadTest
 {
     class Program
     {
        static void DoWork()
         {
             Console.WriteLine("DoWork is begin");
 
             for (int i = ; i < ; i++)
             {
                 try
                 {
                     if (i == )
                     {
                         //终止线程，会抛出一个ThreadAbortException 类型的异常
                         Thread.CurrentThread.Abort(i);
                     }
 
                     Console.WriteLine(string.Format("{0} {1}", Thread.CurrentThread.Name, i));
                     Thread.Sleep();
                 }
                 catch (ThreadAbortException e)
                 {
                     Console.WriteLine(string.Format("{0} is Abort when i is {1}", Thread.CurrentThread.Name, e.ExceptionState));
 
                     //取消终止，静态方法
                     Thread.ResetAbort();
                 }
 
             }
 
             Console.WriteLine("DoWork is end");
         }
 
         /// <summary>
         ///
         /// </summary>
         /// <param name="args"></param>
         static void Main(string[] args)
         {
             Console.WriteLine("Main thread begin");
 
             #region  Thread类构造函数的参数是：不带参数的静态方法
 
             Thread myThread1 = new Thread(Program.DoWork);
             myThread1.Name = "thread1";
 
             /*
              *  有关前台线程和后台线程
              *  线程Thread有一个属性IsBackground，通过把此属性设置为true，就可以把线程设置为后台线程！
              *  当一个进程除了主线程之外其他线程都是后台线程时，应用程序域将在主线程完成时就被卸载，而不会等待异步线程的运行。
              * 使用Thread.Start()启动的线程默认为前台线程，而系统必须等待所有前台线程运行结束后，应用程序域才会自动卸载。
              */
 
             //设置为后台线程
             myThread1.IsBackground = true;
 
             myThread1.Start();
 
             #endregion
 
             #region  Thread类构造函数的参数是：带参数的非静态方法
 
             string str = string.Format("test");
             Test myTest = new Test();
 
             //如果Thread的构造函数的参数是带参数的方法，则这个参数要求是object类型
             Thread myThread2 = new Thread(myTest.ShowMessage);
             myThread2.Name = "thread2";
 
             //设置为前台线程，默认为前台线程
             myThread2.IsBackground = false;
 
             myThread2.Start(str);
 
             /*
              * thread线程间的同步：join方法
              *
              * 关于对 Thread类实例的Join方法的理解.
              * 两个线程的关系如下：一个线程（旧的）生成并启动另一个线程（新的）.
              * join方法只能在以下条件被调用：一个新的线程被创建并且调用start方法后.
              * join方法的作用：阻塞。在旧的线程代码里，运行到行新线程实例的join方法时，旧线程将会被阻塞，
              * 直到新线程(不管是前台还是后台线程)执行完成后，旧线程才会继续执行join方法后面的代码。
              *
              * 比喻如下：线程A创建了线程B和线程C并且都调用start方法启动了线程B和C，线程A才能调用线程B和C的join方法，
              * 表示线程A将阻塞等到线程B和C执行完之后再继续执行。但线程B和C之间是不用通过join方法来通信或者同步的。
              *
              * 在本例里，main线程是主线程，创建线程myThread1和myThread2并都启动了，在执行到myThread2.Join();代码时，
              * 主线程main线程将被阻塞，直到myThread2线程执行完之后，再继续执行
              *
              */
 
             myThread2.Join();
 
             #endregion
 
             //其他：Suspend 与 Resume 方法分别表示挂起和恢复线程，已过时，微软不建议继续使用，不做介绍。
 
             Console.WriteLine("Main thread end");
             Thread.Sleep();
        //     Console.ReadKey();
         }
 
     }
 
     class Test
     {
         //要作为Thread的构造函数的参数，则这个参数要求是object类型
         public void ShowMessage(object obj)
         {
             Console.WriteLine("ShowMessage is begin");
 
             string str = obj as string;
             for (int i = ; i < ; i++)
             {
                 Console.WriteLine(string.Format("{0} {1}{2}", Thread.CurrentThread.Name,str, i));
                 Thread.Sleep();
             }
 
             Console.WriteLine("ShowMessage is end");
         }
     }
 }