java多线程实现主线程等待所有子线程执行完毕

       最近项目中用到线程框架，需要主线程等待所有子线程执行完毕，小编突发奇想，结合设计模式中的复合模式和装饰模式写了这个deamo，这个例子最大的特点是，它不但可以实现最基本的需求，它还拥有像junit一样灵活的使用方法。

 以下是源代码和详解：

import java.util.List;
import java.util.Vector;

public class ThreadSuite extends Thread {
    private List threadUnits = new Vector();
    private int threadCount = 0;
    private boolean waitEnable = true;
    private long timeout = 0;
    private boolean excuteEnable = true;

    public ThreadSuite() {
    }
    public ThreadSuite(long timeout) {
        this.timeout = timeout;
    }
    public ThreadSuite(String threadName) {
        super(threadName);
    }
    public ThreadSuite(String threadName, long timeout) {
        super(threadName);
        this.timeout = timeout;
    }
    @Override
    public void run() {
        synchronized (this) {
            for (ThreadUnit threadUnit : threadUnits) {
                if (!threadUnit.isAlive()) {                   threadUnit.start();                }
            }
            if (waitEnable) {
                try {
                    this.wait(timeout);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public synchronized void add(ThreadUnit threadUnit) {
        threadCount++;
        threadUnit.setThreadSuite(this);
        threadUnits.add(threadUnit);
    }
    public synchronized void anotice() {
        threadCount--;
        if (threadCount < 1) {
            waitEnable = false;
            this.notify();
        } else {
            waitEnable = true;
        }
    }
    public void excute() {
        if (excuteEnable) {           excuteEnable = false;           this.run();        }
    }
}

public class ThreadUnit extends Thread {
    private ThreadSuite threadSuite = null;
    private Thread thread = null;
    public ThreadUnit(Thread thread) {
        this.thread = thread;
    }
    @Override
    public void run() {
        try {
            this.thread.run();
        } catch (Exception e) {
        } finally {
            if (threadSuite != null) {               threadSuite.anotice();            }
        }
    }
    public void setThreadSuite(ThreadSuite threadSuite) {
        this.threadSuite = threadSuite;
    }
}

import java.util.Random;
public class ThreadTest extends Thread {
    private Random random = new Random();
    public ThreadTest(String threadName) {
        super(threadName);
    }
    @Override
    public void run() {
        System.out.println(new StringBuffer("Thread:    ").append(
                this.getName()).append("       begin."));
        try {

            Thread.sleep(random.nextInt(1000) + 2000);
        } catch (InterruptedException e) {
        }
        System.out.println(new StringBuffer("Thread:    ").append(
                this.getName()).append(" end."));
    }
}

import java.util.ArrayList;
import java.util.List;
public class Program {
    public static void main(String[] args) {
        List list = new ArrayList();
        ThreadSuite ts1 = getThreadSuite("a", 5);
        ThreadSuite ts2 = getThreadSuite("b", 5);
        list.add(new ThreadUnit(ts1));
        list.add(new ThreadUnit(ts2));
        ThreadSuite threadSuite = new ThreadSuite();
        for (ThreadUnit tu : list) {
            threadSuite.add(tu);
        }
//      threadSuite.excute();
        ts1.excute();
        ts2.excute();
        System.out.println("main end.");
    }
    public static ThreadSuite getThreadSuite(String threadMark,int threadCount) {
        List list = new ArrayList();
        for (int i = 1; i <= threadCount; i++) {
            list.add(new ThreadUnit(new ThreadTest(threadMark + i)));
        }
        ThreadSuite threadSuite = new ThreadSuite();
        for (ThreadUnit tu : list) {
            threadSuite.add(tu);
        }
        return threadSuite;
    }
}

 如果main方法中最后几行的代码是这样的：

//      threadSuite.excute();
        ts1.excute();
        ts2.excute();
        System.out.println("main end.");

则执行结果为：

Thread:    a2       begin.
Thread:    a1       begin.
Thread:    a3       begin.
Thread:    a5       begin.
Thread:    a4       begin.
Thread:    a2 end.
Thread:    a5 end.
Thread:    a4 end.
Thread:    a1 end.
Thread:    a3 end.
Thread:    b1       begin.
Thread:    b3       begin.
Thread:    b5       begin.
Thread:    b2       begin.
Thread:    b4       begin.
Thread:    b4 end.
Thread:    b1 end.
Thread:    b2 end.
Thread:    b3 end.
Thread:    b5 end.
main end.

 

 如果main方法中最后几行的代码是这样的：

 

        threadSuite.excute();
//      ts1.excute();
//      ts2.excute();
        System.out.println("main end.");

则执行结果为：

Thread:    b1       begin.
Thread:    a1       begin.
Thread:    a2       begin.
Thread:    a3       begin.
Thread:    a4       begin.
Thread:    a5       begin.
Thread:    b2       begin.
Thread:    b3       begin.
Thread:    b4       begin.
Thread:    b5       begin.
Thread:    b5 end.
Thread:    b4 end.
Thread:    b3 end.
Thread:    b1 end.
Thread:    a1 end.
Thread:    a2 end.
Thread:    a5 end.
Thread:    a4 end.
Thread:    b2 end.
Thread:    a3 end.
main end.

从以上执行结果可以看出：

        ThreadSuite类的excute()方法其实是直接调用了它自身的run方法，并且ThreadSuite线程类会等待所有加入到它的管理队列中的Thread类执行完毕后，它的run方法才会运行完毕。因此，完全可以把ThreadSuite类当成是普通的Thread类对待，这样的话，可以把生成的多个ThreadSuite类实例当作普通线程类经过ThreadUnit类包装后放入新的ThreadSuite类管理队列当中

需要注意的是：

       这个deamo其实也不算是个完全的复合模式，因为子线程是经过ThreadUnit类装饰过的，但是你也完全可以理解为：是ThreadSuite类对Thread类的复合，因为Thread类也是ThreadUnit类的父类，也就是说向上转型。在每一个Thread类实例经过ThreadUnit类包装后并加入到ThreadSuite类管理队列中时，ThreadSuite类会把当前线程计数加1。ThreadUnit类其实是Thread类的一个包装类，它会在加入到它的Thread类实例的run方法运行完毕后调用ThreadSuite类的anotice()方法通知ThreadSuite类自己的线程任务已经完成，并请求线程计数减1，这样的话，ThreadSuite类会判断当前所有的加入到它的管理队列中的线程是否全部执行完毕，如果执行完毕，它会调用自身的notice()方法停止等待。如果加入到ThreadSuite类管理队列中的所有Thread类执行完毕后，ThreadSuite类才调用它自身的wait()方法（这种情况出现的几率很小），这样的话，ThreadSuite类会一直等待下去，直到等待超时，因为已经没有可用的Thread类试图唤醒ThreadSuite类的等待，为了防止这种情况出现，ThreadSuite类引入了waitEnable字段，它的初始值是true，当线程计数小于1的时候，它会被设为false，这样的话，在所有的Thead类执行完毕后，ThreadSuite类的wait()方法将不会被调用。