import java.util.Random;  

public class Main {  

    public static void main(String[] args) {  
        Master master = new Master(new MyWorker(), 10);  
        Random random = new Random();  
        for (int i = 0; i < 100; i++) {  
            Task task = new Task();  
            task.setId(i);  
            task.setName("task_" + i);  
            task.setPrice(random.nextInt());  
            master.submit(task);  
        }  
        master.execute();  
        while (true) {  
            if (master.isComplete()) {  
                System.out.println(master.getResult());  
                break;  
            } else  
                System.out.println("還有" + master.isNotCompletedCount() + "個任務未完成");  
        }  
    }  

}  

public class Task {  

    private int id;  
    private String name;  
    private long price;  
  
    public int getId() {  
        return id;  
    }  
    public void setId(int id) {  
        this.id = id;  
    }  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public long getPrice() {  
        return price;  
    }  
    public void setPrice(long price) {  
        this.price = price;  
    }  
}  

import java.util.HashMap;  
import java.util.Map;  
import java.util.concurrent.ConcurrentHashMap;  
import java.util.concurrent.ConcurrentLinkedQueue;

public class Master {  
  
    protected ConcurrentLinkedQueue<Task> workerQueue = new ConcurrentLinkedQueue();  
    protected Map<String, Thread> workers = new HashMap<String, Thread>();  
    protected ConcurrentHashMap<String, Object> resultMap = new ConcurrentHashMap();  
  
    public Master(Worker worker, int workCounts) {  
        worker.setResultMap(this.resultMap);  
        worker.setWorkerQueue(this.workerQueue);  
        for (int i = 0; i < workCounts; i++) {  
            workers.put("任務" + i, new Thread(worker));  
        }  
    }  
  
    //判斷所有的子任務是否結束  
    protected boolean isComplete() {  
        for (Map.Entry<String, Thread> set : workers.entrySet()) {  
            if (set.getValue().getState() != Thread.State.TERMINATED) {  
                return false;  
            }  
        }  
        return true;  
    }  

    //總共有多少個未完成工作  
    protected int isNotCompletedCount() {  
        int count = 0;  
        for (Map.Entry<String, Thread> set : workers.entrySet()) {  
            if (set.getValue().getState() != Thread.State.TERMINATED) {  
                count++;  
            }  
        }  
        return count;  
    }  

    public void submit(Task task) {  
        workerQueue.add(task);  
    }  

    public void execute() {  
        for (Map.Entry<String, Thread> set : workers.entrySet()) {  
            set.getValue().start();  
        }  
    }  

    public Integer getResult() {  
        Integer result = 0;  
        for (Map.Entry result_ : resultMap.entrySet()) {  
            result += Integer.valueOf(result_.getValue().toString());  
        }  
        return result;  
    }  

}  

public class MyWorker extends Worker {  
      
    @Override  
    public Object hanlder(Task task) {  
        System.out.println("aaaaaaaa");
        return 0;  
    }  

}  

import java.util.HashMap;  
import java.util.Map;  
import java.util.concurrent.ConcurrentLinkedQueue;  
  
public class Worker implements Runnable {  
  
    private Map<String, Object> resultMap = new HashMap<String, Object>();  
    ConcurrentLinkedQueue<Task> workerQueue = new ConcurrentLinkedQueue<Task>();  
  
    public void run() {  
        while (true) {  
            Task task = workerQueue.poll();  
            if (task == null) {  
                break;  
            }  
            Object object = hanlder(task);  
            resultMap.put(String.valueOf(task.getId()), task.getPrice());  
        }  
    }  
  
    public Object hanlder(Task task) {  
        return null;  
    }  

    public Map<String, Object> getResultMap() {  
        return resultMap;  
    }  
  
    public void setResultMap(Map<String, Object> resultMap) {  
        this.resultMap = resultMap;  
    }  
  
    public void setWorkerQueue(ConcurrentLinkedQueue<Task> workerQueue) {  
        this.workerQueue = workerQueue;  
    }  

}