Thread2

五 判断多个线程是否都结束的两种方法

确定所有线程是否都完成了工作的方法有很多，如可以采用类似于对象计数器的方法，所谓对象计数器，就是一个对象被引用一次，这个计数器就加1，销毁引用就减1，如果引用数为0，则垃圾搜集器就会对这些引用数为0的对象进行回收。

方法一

    线程也可以采用计数器的方法，即为所有需要监视的线程设一个线程计数器每开始一个线程，在线程执行方法中为这个计数器加1，如果某个线程结束（在线程执行的方法最后为这个计数器减1），为这个计数器减1，然后在开始一个线程，按着一定的时间间隔来监视这个计数器，如是总的计数器为0，说明所有的线程都结束了。当然，也可以不用这个监视线程，而在每一个工作线程的最后（在为计数器减1的代码的后面）来监视这个计数器，也就是说，每一个工作线程在退出之前，还要负责检测这个计数器。使用这种方法不要忘了同步这个计数器变量啊，否则会产生意想不到的后果。

方法二：使用Thread.join方法

join方法只有在线程结束时才继续执行下面的语句。可以对每一个线程调用它的join方法，但要注意，这个调用要在另一个线程里，而不要在主线程，否则程序会被阻塞的。

个人感觉这种方法比较好。

线程计数器方法演示：

class ThreadCounter : MyThread
     {
        private static int count = 0;
        private int ms;
        private static void increment()
         {
            lock (typeof(ThreadCounter))  // 必须同步计数器
             {
                 count++;
             }
         }
        private static void decrease()
         {
            lock (typeof(ThreadCounter))
             {
                 count--;
             }
         }
        private static int getCount()
         {
            lock (typeof(ThreadCounter))
             {
                return count;
             }
         }
        public ThreadCounter(int ms)
         {
            this.ms = ms;
         }
        override public void run()
         {
             increment();
             Thread.Sleep(ms);
             Console.WriteLine(ms.ToString()+"毫秒任务结束");
             decrease();
            if (getCount() == 0)
                 Console.WriteLine("所有任务结束");
         }
     }


ThreadCounter counter1 = new ThreadCounter(3000);
ThreadCounter counter2 = new ThreadCounter(5000);
ThreadCounter counter3 = new ThreadCounter(7000);

counter1.start();
counter2.start();
counter3.start();

   上面的代码虽然在大多数的时候可以正常工作，但却存在一个隐患，就是如果某个线程，假设是counter1，在运行后，由于某些原因，其他的线程并未运行，在这种情况下，在counter1运行完后，仍然可以显示出“所有任务结束”的提示信息，但是counter2和counter3还并未运行。为了消除这个隐患，可以将increment方法从run中移除，将其放到ThreadCounter的构造方法中，在这时，increment方法中的lock也可以去掉了。代码如：

        public ThreadCounter(int ms)
         {
            this.ms = ms;
            increment();
         }

运行上面的程序后，将显示如图2的结果。

使用Thread.join方法演示

private static void threadMethod(Object obj)
{
     Thread.Sleep(Int32.Parse(obj.ToString()));
     Console.WriteLine(obj + "毫秒任务结束");
}
private static void joinAllThread(object obj)
{
     Thread[] threads = obj as Thread[];
    foreach (Thread t in threads)
        t.Join();
     Console.WriteLine("所有的线程结束");
}

static void Main(string[] args)
{
     Thread thread1 = new Thread(threadMethod);
     Thread thread2 = new Thread(threadMethod);
     Thread thread3 = new Thread(threadMethod);

      thread1.Start(3000);
      thread2.Start(5000);
      thread3.Start(7000);

      Thread joinThread = new Thread(joinAllThread);
      joinThread.Start(new Thread[] { thread1, thread2, thread3 });

}

  在运行上面的代码后，将会得到和图2同样的运行结果。上述两种方法都没有线程数的限制，当然，仍然会受到操作系统和硬件资源的限制。