多線程設計模式

Future(類似AJAX請求，異步獲取數據)

//調用類
public class Main {
    public static void main(String[] args) throws InterruptedException {
        FutureClient fc = new FutureClient();
        Data data = fc.request("請求參數");
        System.out.println("請求發送成功!");
        System.out.println("做其他的事情...");
        String result = data.getRequest();
        System.out.println(result);
    }
}

//接口
public interface Data {
    String getRequest();
}

//包裝類
public class FutureClient {
    public Data request(final String queryStr){
        //1 我想要一個代理對象（Data接口的實現類）先返回給發送請求的客戶端，告訴他請求已經接收到，可以做其他的事情
        final FutureData futureData = new FutureData();
        //2 啓動一個新的線程，去加載真實的數據，傳遞給這個代理對象
        new Thread(new Runnable() {
            @Override
            public void run() {
                //3 這個新的線程可以去慢慢的加載真實對象，然後傳遞給代理對象
                RealData realData = new RealData(queryStr);
                futureData.setRealData(realData);
            }
        }).start();
        return futureData;
    }
}

//真實數據處理類
public class RealData implements Data{
    private String result ;
    public RealData (String queryStr){
        System.out.println("根據" + queryStr + "進行查詢，這是一個很耗時的操作..");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("操作完畢，獲取結果");
        result = "查詢結果";
    }

    @Override
    public String getRequest() {
        return result;
    }
}

Master-Worker

//client
public class Main {
    public static void main(String[] args) {
        System.out.println("我的機器可用Processor數量:" + Runtime.getRuntime().availableProcessors());
        Master master = new Master(new MyWorker(), Runtime.getRuntime().availableProcessors());
        Random r = new Random();
        for(int i = 1; i<= 100; i++){
            Task t = new Task();
            t.setId(i);
            t.setName("任務"+i);
            t.setPrice(r.nextInt(1000));
            master.submit(t);
        }
        master.execute();
        long start = System.currentTimeMillis();
        while(true){
            if(master.isComplete()){
                long end = System.currentTimeMillis() - start;
                int ret = master.getResult();
                System.out.println("最終結果：" + ret + "， 執行耗時：" + end);
                break;
            }
        }
    }
}

//master
public class Master {
    //1 應該有一個承裝任務的集合
    private ConcurrentLinkedQueue<Task> workQueue = new ConcurrentLinkedQueue<Task>();
    //2 使用HashMap去承裝所有的worker對象
    private HashMap<String, Thread> workers = new HashMap<String, Thread>();
    //3 使用一個容器承裝每一個worker並非執行任務的結果集
    private ConcurrentHashMap<String, Object> resultMap = new ConcurrentHashMap<String, Object>();
    //4 構造方法
    public Master(Worker worker, int workerCount){
        // 每一個worker對象都需要有Master的引用 workQueue用於任務的領取，resultMap用於任務的提交
        worker.setWorkerQueue(this.workQueue);
        worker.setResultMap(this.resultMap);
        for(int i = 0 ; i < workerCount; i++){
            //key表示每一個worker的名字, value表示線程執行對象
            workers.put("子節點" + Integer.toString(i), new Thread(worker));
        }
    }
    //5 提交方法
    public void submit(Task task){
        this.workQueue.add(task);
    }
    //6 需要有一個執行的方法（啓動應用程序 讓所有的worker工作）
    public void execute(){
        for(Map.Entry<String, Thread> me : workers.entrySet()){
            me.getValue().start();
        }
    }
    //8 判斷線程是否執行完畢
    public boolean isComplete() {
        for(Map.Entry<String, Thread> me : workers.entrySet()){
            if(me.getValue().getState() != Thread.State.TERMINATED){
                return false;
            }
        }       
        return true;
    }
    //9 返回結果集數據
    public int getResult() {
        int ret = 0;
        for(Map.Entry<String, Object> me : resultMap.entrySet()){
            //彙總的邏輯..
            ret += (Integer)me.getValue();
        }
        return ret;
    }
}

//worker
public class Worker implements Runnable {
    private ConcurrentLinkedQueue<Task> workQueue;
    private ConcurrentHashMap<String, Object> resultMap;
    public void setWorkerQueue(ConcurrentLinkedQueue<Task> workQueue) {
        this.workQueue = workQueue;
    }
    public void setResultMap(ConcurrentHashMap<String, Object> resultMap) {
        this.resultMap = resultMap;
    }
    @Override
    public void run() {
        while(true){
            Task input = this.workQueue.poll();
            if(input == null) break;
            //真正的去做業務處理
            Object output = MyWorker.handle(input);
            this.resultMap.put(Integer.toString(input.getId()), output);
        }
    }
    public static Object handle(Task input) {
        return null;
    }
}

//子worker
public class MyWorker extends Worker {
    public static Object handle(Task input) {
        Object output = null;
        try {
            //表示處理task任務的耗時，可能是數據的加工，也可能是操作數據庫...
            Thread.sleep(500);
            output = input.getPrice();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return output;
    }
}

//任務
public class Task {
    private int id ;
    private String name;
    private int 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 int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
}

生產者消費者模式(mq:Activemq，kcxp)

直連模式(mina/netty)