多线程里面的设计模式

今晚总结一下关于开发中常用的多线程设计模式。

Future设计模式

future相信大家对这个东西都不陌生，那么我们就开门见山的来讲吧。
首先来思考几个问题
future是用来做什么的？
当我们做一些计算机串行化计算的时候，在等待响应的过程中，接收方的线程是处于堵塞状态的，比较浪费资源。
这个时候如果采用future来帮我们异步接收参数，避免同步等待的问题，那么这种方式我们称之为future。
future比较常用功能的方式是futuretask，案例如下：

public static void main(String[] args) throws InterruptedException, ExecutionException {
        FutureTask<String> futureTask=new FutureTask<String>(new RealData("*"));
        ExecutorService executorService= Executors.newFixedThreadPool(1);
        executorService.submit(futureTask);
        System.out.println("请求完毕了");
        Thread.sleep(200);
        System.out.println("真实数据"+futureTask.get());
    }

这段代码在工作中如果有需要可以拿去使用。

如何自己来实现一个future的模型？
future的实现实际上离不开两个东西，一个是futuredata，就是用于get真实数据的一个引用句柄，还有一个就是realdata，真实响应数据。
由于获取真实数据的过程可能会比较耗时，所以通常的做法是在异步线程中去获取响应的数据。
案例代码如下：
首先定义一个用于给future执行的task

/**
 * @author idea
 * @data 2020/2/15
 */
public interface CallableTask<T> {
    T run();
}

然后是futureData

/**
 * @author idea
 * @data 2020/2/15
 */
public class FutureData {
    private RealData realData;
    private boolean isReady=false;
    public synchronized  void setCallableTask(CallableTask callableTask){
        realData=new RealData(callableTask);
        isReady=false;
        notifyAll();
    }
    public synchronized Object get() throws InterruptedException {
        while (!isReady){
            wait();
        }
        return realData.getResult();
    }
}

接下来是真实接收参数的RealData

/**
 * @author idea
 * @data 2020/2/15
 */
public class RealData {
    private CallableTask callableTask;
    private Object result;
    public RealData(CallableTask callableTask) {
        this.callableTask = callableTask;
        this.result = callableTask.run();
    }
    public Object getResult() {
        return result;
    }
}

接下来便是client客户端

/**
 * @author idea
 * @data 2020/2/15
 */
public class Client {
    private FutureData futureData;
    public void request(CallableTask callableTask){
        futureData=new FutureData();
        futureData.setCallableTask(callableTask);
    }
    public Object get() throws InterruptedException {
        if(futureData==null){
            throw new RuntimeException("futureData can not be null!");
        }
        return futureData.get();
    }
    static class job implements CallableTask<String>{
        @Override
        public String run() {
            System.out.println("this is run");
            return "ten";
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Client client=new Client();
        client.request(new job());
        for(int i=0;i<10;i++){
            Thread.sleep(10);
            System.out.println("=======");
        }
        Object result = client.get();
        System.out.println(result);
    }
}

最后执行client里面的main方法便可以验证了。
根据这样的案例，相信你也可以看懂future是怎么运作的了。但是在实际的jdk实现中，future的设计要比这个复杂很多，所以这里就不做具体的讲解了。

Master-Worker模型
如果有接触过大数据的同学，应该就会对这种模式比较熟悉，常见的hadoop就是基于这种模式设计的。
Master-Worker模式是常用的并行模式之一，它的核心思想是：系统由两类进程协同工作，即Master进程和Worker进程，Master负责接收和分配任务，Wroker负责处理子任务。当各个Worker进程将子任务处理完成后，将结果返回给Master进程，由Master进程进行汇总，从而得到最终的结果，其具体处理过程如下图所示。

Master进程为主要进程，它维护一个Worker进程队列、子任务队列和子结果集。Worker进程队列中的Worker进程不停从任务队列中提取要处理的子任务，并将结果写入结果集。
这里我写了一个简单版的master-worker模型供大家学习：
首先是Master

import 重温_Java并发基础.并行程序的设计模式.code.master_worker.Worker;
import java.util.HashMap;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedDeque;
/**
 * @author idea
 * @data 2020/2/15
 */
public class Master {
    protected Queue<Object> workerQueue = new ConcurrentLinkedDeque<>();
    protected Map<String, Thread> threadMap = new HashMap<>();
    protected Map<String, Object> resultMap = new ConcurrentHashMap<>();
    public Master(Worker worker, int countWorker){
        worker.setWorkerQueue(workerQueue);
        worker.setResultMap(resultMap);
        for(int i=0;i<countWorker;i++){
            threadMap.put(Integer.toString(i),new Thread(worker,"worker"+i));
        }
    }
    public boolean isComplete(){
        for(String key:threadMap.keySet()){
            if(threadMap.get(key).getState()!=Thread.State.TERMINATED){
                return false;
            }
        }
        return true;
    }
    public void submit(Object job){
        workerQueue.add(job);
    }
    /**
     * 执行任务
     */
    public void execute(){
        for (Map.Entry<String,Thread> stringThreadEntry : threadMap.entrySet()) {
            stringThreadEntry.getValue().start();
        }
    }
}

master主要是负责工作的分发和结果的合并
接下来是worker部分的设计：

import java.util.Map;
import java.util.Queue;
import java.util.Set;
/**
 * @author idea
 * @data 2020/2/15
 */
public class Worker implements Runnable {
    protected Queue<Object> workerQueue;
    protected Map<String, Object> resultMap;
    public Worker setWorkerQueue(Queue<Object> workerQueue) {
        this.workerQueue = workerQueue;
        return this;
    }
    public Worker setResultMap(Map<String, Object> resultMap) {
        this.resultMap = resultMap;
        return this;
    }
    public Object handle(Object input) throws InterruptedException {
        return input;
    }
    @Override
    public void run() {
        while (true) {
            Object input = workerQueue.poll();
            if (input == null) {
                break;
            }
            Object result = null;
            try {
                result = handle(input);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resultMap.put(String.valueOf(result.hashCode()), result);
        }
    }
    private  void  handle_1(){
        Master master = new Master(new PlusWorker(), 10);
        for (int i = 1; i <= 100; i++) {
            master.submit(i);
        }
        int result = 0;
        master.execute();
        Map<String, Object> resultMap = master.resultMap;
        while (resultMap.size() != 0 || !master.isComplete()) {
            Set<String> keySet = resultMap.keySet();
            String key = null;
            for (String s : keySet) {
                key = s;
                break;
            }
            Integer i = null;
            if (key != null) {
                i = (Integer) resultMap.get(key);
            }
            if (i != null) {
                result += i;
            }
            if (key != null) {
                resultMap.remove(key);
            }
        }
        System.out.println(result);
    }
    //计算1+2+3+4+***+10000
    public static void main(String[] args) {
        Worker w=new Worker();
        w.handle_1();
    }
}

给worker设计一个PlusWorker

/**
 * @author idea
 * @data 2020/2/15
 */
public class PlusWorker extends Worker{
    @Override
    public Object handle(Object input) throws InterruptedException {
        Integer val= (Integer) input;
        Thread.sleep(1000);
        return val;
    }
}

此时一个基本的模型也就完成了。

本文完。转载请注明出处。
参考文献
葛一鸣，Java程序性能优化．清华大学出版社．