JDK多线程基础(15)：并行程序设计模式

Future

1. Future 模式的核心在于去除了主函数中的等待时间，并使得原本需要等待的时间段可以处理其他的业务逻辑从而充分利用计算资源
2. Future 的用法详见 Callable 与 Future 相关博文

Master-Worker

原理

1. 系统有两类进程协作：Master进程和Worker进程。Master负责接收和分配任务，Worker负责处理子任务。当各个Worker进程将子任务处理完成后，将结果返回给 Master进程，由Master做归纳和汇总。
2. Master-Worker 模式的好处是，他能将一个大任务分解成若干个小任务，并行执行，从而提高系统的吞吐量

实现

模式结构

1. Master为主进程，他维护一个 Worker 的队列、子任务队列和子结果队列
2. Worker队列中的Worker进程，不停的从任务队列中提取要处理的子任务，并将子任务处理的结果写入结果集
3. 这边的实现类似与Future，但是这种设计实现是分布式计算的一种思路

代码实现

1. Master：用于任务的分配和最终结果的合成

public class Master {

    /**
     * 任务队列
     */
    protected Queue<Object> workQueue = new ConcurrentLinkedQueue<>();
    /**
     * worker 线程队列
     */
    protected Map<String, Thread> threadMap = new HashMap<>();
    /**
     * 子任务处理处理结果集
     */
    protected Map<String, Object> resultMap = new ConcurrentHashMap<>();


    /**
     * 是否所有的任务都结束了
     *
     * @return
     */
    public boolean isComplete() {
        for (Map.Entry<String, Thread> entry : threadMap.entrySet()) {
            if (entry.getValue().getState() != Thread.State.TERMINATED) {
                return false;
            }
        }
        return true;
    }

    /**
     * Master 的构造
     *
     * @param worker      子任务线程
     * @param countWorker Worker 进程数
     */
    public Master(Worker worker, int countWorker) {
        worker.setWorkQueue(workQueue);
        worker.setResultMap(resultMap);
        for (int i = 0; i < countWorker; i++) {
            threadMap.put(Integer.toString(i), new Thread(worker, Integer.toString(i)));
        }
    }

    /**
     * 提交一个任务
     *
     * @param job
     */
    public void submit(Object job) {
        workQueue.add(job);
    }

    /**
     * 开始运行所有 Worker 进程，进行处理
     */
    public void execute() {
        for (Map.Entry<String, Thread> entry : threadMap.entrySet()) {
            entry.getValue().start();
        }
    }


    public Map<String, Object> getResultMap() {
        return resultMap;
    }


}

2. Worker：用于实际处理一个任务

public class Worker implements Runnable {

    /**
     * 任务队列，用于获取子任务
     */
    protected Queue<Object> workQueue;
    /**
     * 子任务处理结果集
     */
    protected Map<String, Object> resultMap;

    public void setWorkQueue(Queue<Object> workQueue) {
        this.workQueue = workQueue;
    }

    public void setResultMap(Map<String, Object> resultMap) {
        this.resultMap = resultMap;
    }

    /**
     * 子任务处理逻辑，在子类中实现具体逻辑
     *
     * @param input
     * @return
     */
    protected Object handle(Object input) {
        return input;
    }

    @Override
    public void run() {
        while (true) {
            // 获取子任务
            Object input = workQueue.poll();
            if (input == null) {
                break;
            }
            // 处理子任务
            Object result = handle(input);
            // 将处理结果写入结果集
            resultMap.put(Integer.toString(input.hashCode()), result);
        }

    }
}

3. Main：启动系统，调度开启Master

public class MasterWorkerMode {

    public static void main(String[] args) {
        // 使用5个Worker
        Master master = new Master(new PlusWorker(), 5);

        // 提交100个任务
        for (int i = 0; i < 100; i++) {
            master.submit(i);
        }
        // 开始计算
        master.execute();

        // 保存最终结果
        int result = 0;
        Map<String, Object> resultMap = master.getResultMap();
        // 不需要等待所有的Worker 都执行完成，即可开始计算最终结果
        while (!resultMap.isEmpty() || !master.isComplete()) {
            Set<String> keys = resultMap.keySet();
            String key = null;
            for (String k : keys) {
                key = k;
                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~100 的立方和
     *
     */
    static class PlusWorker extends Worker {

        @Override
        protected Object handle(Object input) {
            // 求立方和
            Integer i = (Integer) input;
            return i * i * i;
        }
    }

}

Guarded Suspension 保护暂停、漏斗模型

原理

1. 设想这样的一种场景：服务器可能会在很短的时间内承受大量的客户端请求，客户端请求的数量超过服务器本身的即时处理能力，而服务器程序又不能丢弃任何一个客户请求
2. 这种场景下：最佳的处理为让客户端请求进行排队，由服务器程序一个接一个处理。即保证了所有客户端请求不丢失，同时避免服务器同时处理太多的请求而崩溃
3. 在大型系统中引入消息中间件（MQ），更多的就是出于这样的设计实现

简单实现

1. Request：封装了客户端请求

public class Request {
    private String name;
}

2. RequestQueue：表示客户端请求队列，由两个工作线程ServerThread、ClientThread共同维护。

• ClientThread：负责不断发起请求
• ServerThread：根据自身状态，从RequestQueue中获取对象加以处理

public class RequestQueue {

    private LinkedList<Request> queue = new LinkedList<>();

    public synchronized Request getRequest() {
        while (queue.isEmpty()) {
            try {
                wait();//等待直到有新的 Request 加入
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //返回 Request 队列中的第一个请求
        return (Request) queue.remove();
    }

    public synchronized void addRequest(Request request) {
        //加入新的 Request 请求
        queue.add(request);
        // 通知 getRequest() 方法
        notify();
    }
}

3. Main：主方法。

public class GuardedSuspensionMode {

    public static void main(String[] args) {
        RequestQueue queue = new RequestQueue();

        for (int i = 0; i < 10; i++) {
            new ServerThread("ServerTread#" + i, queue).start();
        }

        for (int i = 0; i < 10; i++) {
            new ClientThread("ClientTread#" + i, queue).start();
        }
    }
    static class ServerThread extends Thread {
        private RequestQueue requestQueue;

        public ServerThread(String name, RequestQueue requestQueue) {
            super(name);
            this.requestQueue = requestQueue;
        }

        @Override
        public void run() {

            while (true) {
                final Request request = requestQueue.getRequest();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName()
                        + " handle " + request);
            }
        }
    }

    static class ClientThread extends Thread {
        private RequestQueue requestQueue;

        public ClientThread(String name, RequestQueue requestQueue) {
            super(name);
            this.requestQueue = requestQueue;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                Request request = new Request("RequestId" + i + "ThreadName "
                        + Thread.currentThread().getName());
                System.out.println(Thread.currentThread().getName() + " requests "
                        + request);

                requestQueue.addRequest(request);

                try {
                    //Client 请求速度大于 server的速度
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("ClientThread Name is :" + Thread.currentThread().getName());
            }
            System.out.println(Thread.currentThread().getName() + " Request end");

        }
    }
}

不变模式 final

不变模式使用场景

1. 当对象被创建后，其内部状态与数据不会再发生任何变化
2. 对象需要被共享、被多线程频繁的访问

不变模式实现

1. 去除 Setter 等可以修改自身属性的方法
2. 将所有属性设置为私有，并使用 final 标记，确保其不可修改
3. 确保没有子类可以重载修改它的行为，使用final修饰类可以实现
4. 有一个可以创建完整对象的构造函数

/**
 * 使用 final 关键字修饰类和所有属性
 */
public final class ObjectClazz{
    private final String name;
    public ObjectClazz(String name) {
        this.name = name;
    }
    
    public String getName() {
        return this.name;
    }
}

JDK中的实现

1. String
2. Long

Producer-Consumer 生产者-消费者

原理分析

1. 生产者-消费者是一个经典的多线程设计模式，它为多线程间的协作提供了良好的解决方案
2. 在生产者-消费者模式中，通常有两类线程，即若干个生产者线程与若干个消费者线程。

• 生产者线程负责提交用户请求
• 消费者线程负责处理生产者提交的任务
• 生产者和消费者通过共享内存缓冲区进行通信

3. 生产者-消费者模式的核心组件是共享缓冲区

• 为生产者与消费者之间的通信桥梁，避免生产者与消费者直接通信，从而将生产者和消费者进行解耦
• 允许生产者和消费者在执行效率上存在时间差，不管是生产者在某一局部时间内速度高于消费者；或是消费者在局部某一时间高于生产者，都可以通过共享缓冲区得到缓解

简单实现

1. 生产者 Producer

public class Producer {

    /**
     * 共享缓冲区
     */
    private static final ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
    private static final Consumer consumer;

    static{
        consumer = new Consumer(queue);
        new Thread(consumer, "consumer-thread").start();
    }

    public static void shutDownThread() {
        consumer.shutDownThread();
    }

    static void addLogs(String str){
//        queue.add(str);//内部调用的offer
        queue.offer(str);
    }


}

2. 消费者

public class Consumer implements Runnable {
    private final List<String> valueList = new ArrayList<>();
    private final ConcurrentLinkedQueue<String> queue;
    private static final int BATCH_FLUSH_NUM = 20;

    public Consumer(ConcurrentLinkedQueue<String> queue) {
        this.queue = queue;
    }

    private volatile boolean runFlag = true;

    public void shutDownThread() {
        runFlag = false;
    }

    @Override
    public void run() {
        long start = System.currentTimeMillis();
        while (runFlag) {
            try {
                String msg = queue.poll();
//               queue.peek() 返回但不移除队列头部的元素
                if (!Strings.isNullOrEmpty(msg)) {
                    valueList.add(msg);
                } else {
                    Thread.sleep(2000L);
                }
                long end = System.currentTimeMillis();
                if ((valueList.size() == BATCH_FLUSH_NUM) || ((end - start) > 3 * 1000 && !valueList.isEmpty())) {
                    System.out.println("拿数据干活~~~");
                    valueList.clear();
                    start = end;
                }
            } catch (Exception e) {
            }
        }
    }
}

参考

1. 源码地址