一个类似树要用多线程下执行怎么做，求解！

Question

                                                                        A

                                          

 

                                                            B                C

                       

 

 

                                                                     D

 

 

 

 

                                                    E                 F             G

 

 

 

 

由于公司不能上传东西，也不能上其他网站；

现在想用多线程去执行，由于数据量很大，A下面有节点B 、C（如图），A执行完后才能执行B C，只有当B C两个节点都执行完了才能执行到D，如果B C有一个没执行完都不能执行D，只有当父节点执行完才能执行下面子节点，下面依次类推，必须用多线程，第一次发帖，大伙们不要笑话哦！

Answer 1

用文字讲太麻烦了，弄个简单的，楼主看看好了，个人感觉还可以改进。
简单的代码示例：
[code="java"]
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class MT {

private final Map<String, Boolean> flags = new ConcurrentHashMap<String, Boolean>();

private boolean hasDone(Operation... operations) {
    for (Operation operation : operations) {
        if (!flags.get(operation.getOperationName())) {
            return false;
        }
    }
    return true;
}

public static void main(String[] args) {
    MT mt = new MT();
    mt.flags.put("A", false);
    mt.flags.put("B", false);
    mt.flags.put("C", false);
    mt.flags.put("D", false);
    mt.A.run();
}

private Operation D = new Operation() {

    protected boolean isPrepareFinished() {
        return hasDone(D);
    }

    protected String getOperationName() {
        return "D";
    }

    protected void doing() {
        flags.put(getOperationName(), true);
    }
};

private Operation C = new Operation(D) {

    protected boolean isPrepareFinished() {
        return hasDone(B, C);
    }

    protected String getOperationName() {
        return "C";
    }

    protected void doing() {
        flags.put(getOperationName(), true);
    }
};

private Operation B = new Operation(D) {

    protected boolean isPrepareFinished() {
        return hasDone(B, C);
    }

    protected String getOperationName() {
        return "B";
    }

    protected void doing() {
        flags.put(getOperationName(), true);
    }
};

private Operation A = new Operation(B,C) {

    protected boolean isPrepareFinished() {
        return hasDone(A);
    }

    protected String getOperationName() {
        return "A";
    }

    protected void doing() {
        flags.put(getOperationName(), true);
    }
};



abstract class Operation implements Runnable {

    protected abstract String getOperationName();

    protected abstract void doing();

    protected abstract boolean isPrepareFinished();

    private Operation[] afterOperations;

    public Operation(Operation... afterOperations) {
        this.afterOperations = afterOperations;
    }

    public void run() {
        System.out.println("doing " + getOperationName() + " ...");
        doing();
        if (isPrepareFinished()) {
            Thread[] threads = new Thread[afterOperations.length];
            for (int i = 0; i < threads.length; i++) {
                threads[i] = new Thread(afterOperations[i]);
            }
            for (Thread thread : threads) {
                thread.run();
            }
        }
    }
}

}
[/code]