多线程设计模式

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

//clientpublic 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;            }        }    }}//masterpublic 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;    }}//workerpublic 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;    }}//子workerpublic 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)