设计模式-MasterWork-优快云博客

简介

简介

Master-Worker模式是常用的并行计算模式
Master负责接收和分配任务
Worker负责处理子任务Worker子进程处理完成后将结果返回给Master
适合将一个大任务分解成若干个小任务，并行执行，从而提高系统的吞吐量

Task类

package com.example.demo.design.masterwork;

import lombok.Data;

@Data
public class Task {

    private  String  id;
    private  String  name;

    public Task(String id, String name) {
        this.id = id;
        this.name = name;
    }
}

Master类

package com.example.demo.design.masterwork;

import lombok.Getter;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;

public class Master {


    /**
     * 装载任务的队列，线程并发去取task并执行，为了保证线程安全需要用到ConcurrentLinkedQueue
     */
    private  final ConcurrentLinkedQueue<Task> tasks = new ConcurrentLinkedQueue<>();


    /**
     * 整体分配的工作数，比如100个任务分配10个work去执行
     */
    private  final HashMap<String, Thread> works = new HashMap<>();

    @Getter
    private final ConcurrentHashMap<String, Object> results = new ConcurrentHashMap<>();

    private CountDownLatch latch;

    /**
     * 构造函数
     *
     * @param work  工作线程需要继承runnable
     * @param count 一共需要多少个线程
     */
    public Master(Work work, int count) {

        work.setTasks(this.tasks);
        work.setResults(this.results);
        for (int i = 0; i < count; i++) {
            this.works.put(i + "", new Thread(work));
        }

    }


    /**
     * 添加任务
     */
    public void addTask(Task task) {
        this.tasks.add(task);
    }

    /**
     * 执行，让所有work线程工作起来
     */

    public void execute(Work work) {
        this.latch = new CountDownLatch(tasks.size());
        work.latch = this.latch;
        for (Map.Entry<String, Thread> entry : works.entrySet()) {
            entry.getValue().start();
        }
    }

    /**
     * 是否完成 调用后，如果没有完成会阻塞
     */
    public void isComplete() {
        try {
            latch.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

}

Work类

package com.example.demo.design.masterwork;

import lombok.Setter;
import java.util.Random;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;

public class Work   implements Runnable{


    @Setter
    private ConcurrentLinkedQueue<Task> tasks = new ConcurrentLinkedQueue<>();
    @Setter
    private ConcurrentHashMap<String,Object>  results = new ConcurrentHashMap<>();

    public CountDownLatch latch;

    @Override
    public void run() {
                while (true){
                    //因为是阻塞队列，保证多个线程去队列取得时候不会重复取到一条
                    Task task = tasks.poll();
                    if(task == null){
                        break;
                    }
                    Object  result= null;
                    try {
                        result = handle(task);
                        latch.countDown();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    results.put(task.getId(), result);
                }
    }


    private final Random  random = new Random();
    public Object handle(Task task) throws InterruptedException {
        long time=    1000* random.nextInt(5);
        Thread.sleep(time);
        System.out.println(task.getName()+"执行完成");
        return  task.getName()+"执行耗时："+time;
    }



}

测试类：Client

package com.example.demo.design.masterwork;

import java.util.Map;

public class Client
{

    public static void main(String[] args) {
       //创建两个线程去执行10个任务
        Work  work=new Work();
        Master master = new Master(work,2);
        int  tasSize=10;
        for (int i=0;i<tasSize;i++){
            master.addTask(new Task("id"+i,"task"+i));
        }
        long  begin = System.currentTimeMillis();
        master.execute(work);
        master.isComplete();
        long end = System.currentTimeMillis();
        for (Map.Entry<String,Object>  item:master.getResults().entrySet()){
            System.out.println(item.getKey()+":"+item.getValue());
        }
        System.out.println("执行耗时："+(end-begin));
    }

}

执行结果

task1执行完成
task0执行完成
task2执行完成
task4执行完成
task3执行完成
task5执行完成
task6执行完成
task8执行完成
task7执行完成
task9执行完成
id0:task0执行耗时：1000
id2:task2执行耗时：1000
id1:task1执行耗时：0
id4:task4执行耗时：1000
id3:task3执行耗时：1000
id6:task6执行耗时：3000
id5:task5执行耗时：1000
id8:task8执行耗时：1000
id7:task7执行耗时：4000
id9:task9执行耗时：2000
执行耗时：8055