C#中的线程四（System.Threading.Thread）

C#中的线程四（System.Threading.Thread）

1.最简单的多线程调用

System.Threading.Thread类构造方法接受一个ThreadStart委托，改委托不带参数，无返回值

 public static void Start1()
    {
       Console.WriteLine("this is main thread!:{0},{1}", System.Threading.Thread.CurrentThread.CurrentCulture, Thread.CurrentThread.Name);
       System.Threading.ThreadStart start = Method1;
       Thread thread = new Thread(start);
       thread.IsBackground = true;
       thread.Start();
       Console.WriteLine("main thread other thing...");
    }
 public static void Method1()
    {
       Console.WriteLine("this is sub thread!:{0},{1}", System.Threading.Thread.CurrentThread.CurrentCulture, Thread.CurrentThread.Name);
       Thread.Sleep(TimeSpan.FromSeconds());
       Console.WriteLine("sub thread other thing...");
    }

注意thread.IsBackground=true，利用Thread创建的线程默认是前台线程，即IsBackground=false,而线程池中的线程是后台线程。

 前台线程和后台线程的区别在于：当主线程执行结束时，若任然有前台线程在执行，则应用程序的进程任然处于激活状态，直到前台线程执行完毕；而换成后台线程，当主线程结束时，后台线程也跟着结束了。

2.给线程传送数据

这是使用ParameterizedThreadStart 委托来代替ThreadStart委托，ParameterizedThreadStart 委托接受一个带object的参数，无返回值

 public static void Start2()
  {
     Customer c = new Customer { ID = "aaa", Name = "name" };
     Console.WriteLine("this is main thread!:{0},{1}", System.Threading.Thread.CurrentThread.CurrentCulture, Thread.CurrentThread.Name);
     ParameterizedThreadStart start = Method2;
     Thread thread = new Thread(start);
     thread.Start(c);
     Console.WriteLine("main thread other thing...");
  }
  public static void Method2(object o)
   {
     Console.WriteLine("this is sub thread!:{0},{1}", System.Threading.Thread.CurrentThread.CurrentCulture, Thread.CurrentThread.Name);
     Console.WriteLine(o.ToString());
     Thread.Sleep(TimeSpan.FromSeconds());
     Console.WriteLine("sub thread other thing...");
   }

由此实例可以看出，我们将一个Customer 实例传入了新线程中，新线程可以直接读取此参数的信息。
    当然还有另一种方法也可以将数据传入线程中，创建一个类，把线程的方法定义为实例方法，这样就可以初始化实例的数据，之后启动线程,还是看实例代码：

 public static void Start4()
    {
       Customer c = new Customer();
       //调用同一个对象，从而实现资源共享
       ThreadStart ts = c.Increase;
       Thread[] tArray = new Thread[];
       for (int i = ; i < ; i++)
        {
           tArray[i] = new Thread(ts);
           tArray[i].Start();
         }
        for (int i = ; i < ; i++)
         {
            tArray[i].Join();
         }
        Console.WriteLine(c.Number.ToString());
         }
  public static void Method3(object o)
    {
        Customer c = o as Customer;
        //若不上锁，所以每次结果都不同
        //应该重新建立一个object进行上锁，因为外边还有可能访问到c这个实例
        lock (c)
        {
           for (int j = ; j < ; j++)
             {
                c.Number++;
              }
        }
    }

Customer类的定义如下：

 public class Customer
     {
         public int Number
         {
             get;
             set;
         }
         public string ID
         {
             get;
             set;
         }
 
         public string Name
         {
             get;
             set;
         }
         public Customer()
         {
             Number = ;
         }
         public void Increase()
         {
             object o = new object();
             lock (o)
             {
                 for (int i = ; i < ; i++)
                 {
                     Number++;
                 }
             }
         }
     }

3.竞态条件

来看竞态条件的定义： 如果两个或多个线程访问相同的对象，或者访问不同步的共享状态，就会出现竞态条件。

竞态条件也是多线程编程的常犯的错误，如果代码不够健壮，多线程编码会出现一些预想不到的结果，我们来根据一个实例来看：

 public static void RaceCondition()
   {
      ThreadStart method = ChangeState;
      //这里放出20个线程
      for (int i = ; i < ; i++)
      {
         Thread t = new Thread(method);
         t.Name = i.ToString() + "aa";
         t.Start();
       }
    }
    //2.线程调用的方法，改变状态值
  public static void ChangeState()
    {
       for (int loop = ; loop < ; loop++)
       {
          int state = ;
          if (state == )
          {
           //此处第一个线程进入后没来得及++操作，第二个线程又进入，此时第一个线程做了++操作，第二个
           //线程继续++,state的值变成7
             state++;
              if (state == )
              {
                //没有试验成功
                Console.WriteLine("state={0},loop={1}", state, loop);
                Console.WriteLine("thread name:{0}", Thread.CurrentThread.Name);
               }
               //Console.WriteLine(state.ToString());
           }
        }
    }

最简单的解决竞态条件的办法就是使用上锁-lock,锁定共享的对象。用lock语句锁定在线程中共享的变量state,只有一个线程能在锁定块中处理共享的state对象。由于这个对象由所有的线程共享，因此如果一个线程锁定了state,另一个线程就必须等待该锁定的解除。

 public static void ChangeState2()
    {
       object o = new object();
       for (int loop = ; loop < ; loop++)
        {
           int state = ;
           lock (o)
            {
              if (state == )
                {
                   state++;
                   if (state == )
                    {
                       //没有试验成功
                     Console.WriteLine("state={0},loop={1}", state, loop);
                     Console.WriteLine("thread name:{0}", Thread.CurrentThread.Name);
                     }
                 }
          }
       }
   }

 4.死锁

在死锁中，至少有两个线程被挂起，等待对方解除锁定。由于两个线程都在等待对方，就出现了死锁，线程将无限等待下去。

 5.几种同步方法

上面介绍了两种线程数据共享的办法，一旦需要共享数据，就必须使用同步技术，确保一次只有一个线程访问和改变共享状态。上面介绍了使用lock的方法防止竞态条件的发生，但是如果用不好的话会产生死锁。那么下面再介绍几种针对不同情况使用的线程同步方法。

(1)SyncRoot模式

下面创建一个类的两个版本，一个同步版本，一个异步版本

 public class GeneralDemo
  {
     public virtual bool IsSynchronized
       {
         get { return false; }
        }
     public static GeneralDemo Synchronized(GeneralDemo demo)
      {
          if (demo.IsSynchronized)
           {
             return new SyncDemo(demo);
            }
           return demo;
       }
     public virtual void DoThis()
      { }
    public virtual void DoThat()
      { }
  }

 //同步版本
         private class SyncDemo : GeneralDemo
         {
             private object syncRoot = new object();
             private GeneralDemo demo;
             private int state = ;
 
             public int State
             {
                 get { return state; }
                 set { state = value; }
             }
             public SyncDemo(GeneralDemo demo)
             {
                 this.demo = demo;
             }
             public override bool IsSynchronized
             {
                 get
                 {
                     return true;
                 }
             }
             public override void DoThat()
             {
                 lock (syncRoot)
                 {
                     demo.DoThis();
                 }
             }
             public override void DoThis()
             {
                 lock (syncRoot)
                 {
                     demo.DoThis();
                 }
             }

需要注意的是在SyncDemo类中，只有方法是同步的，对于这个类的成员调用并没有同步,如果试图用SyncRoot模式锁定对属性的访问，对state的访问变成线程安全的，仍会出现竞态条件

即这样做是不可取的:

 //public int State
  //{
      //    get { lock (syncRoot) { return state; } }
      //    set { lock (syncRoot) { state = value; } }
   //}

最好的办法是把lock添加到调用State的地方,当然锁定状态递增还有一种更快的方式

(2)Interlocked

 public int State
   {
     get
      {
        return Interlocked.Increment(ref state);
      }
    }

(3)Monitor类

 public override void DoThis()
 {
     if (Monitor.TryEnter(syncRoot, ))
     {
         try
         {
             //acquired the lock
             //synchroized region for syncRoot
         }
         finally
         {
             Monitor.Exit(syncRoot);
         }
     }
     else
     {
         //didn't get the lock,do something else
     }
 }