Master-Worker Design Pattern_master pattern design-优快云博客

本文链接：https://blog.youkuaiyun.com/rapergod/article/details/126458034

本文介绍了一个基于 Master-Worker 模型的分布式任务调度系统。Master 负责任务的提交、结果聚合，Worker 执行任务。系统使用并发集合和队列确保线程安全，通过 Function 接口处理结果。主要涉及并发编程、任务调度和分布式计算。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Master

import cn.hutool.core.collection.ConcurrentHashSet;
import com.example.redis.masterworker.task.SumTask;
import lombok.extern.slf4j.Slf4j;
import java.util.HashMap;
import java.util.Set;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.function.Function;

@Slf4j
public class Master{
    private final ConcurrentHashSet<Result> results = new ConcurrentHashSet<>();

    private  final ConcurrentLinkedQueue<Task> tasks = new ConcurrentLinkedQueue<>();

    private  final HashMap<String, Worker> workers = new HashMap<>();

    private final int threads;

    private int taskCount;

    private Function<Set<Result>, Result> resultFunction;



    public Master(int threads) {
        this.threads=threads;
        for (int i = 0; i < threads; i++) {
            Worker worker = new Worker();
            worker.setName(""+i);
            workers.put("worker-" + i, worker);
        }
    }

    public void submitTasks(Task task, int count,Function<Set<Result>, Result> resultFunction) {
        this.taskCount = count;
        this.resultFunction = resultFunction;
        for (int i = 0; i < count; i++) {
            tasks.add(task);
        }
    }

    public void cleanTasks() {
        tasks.clear();
    }

    // TODO: 2022/8/21 线程安全问题
    public void handleTasksByLoop() {
        while (!tasks.isEmpty()) {
            Result result = tasks.poll().execute();
            setResult(result);
        }
    }

    public void setResult(Result result) {
        results.add(result);
    }

    public void invoke() {
        workers.values().forEach(worker -> {
            worker.setMaster(this);
            worker.start();
        });
    }

    public Result getAggregationResult() {
        while ((long) tasks.size() > 0) {
            try {
                Thread.sleep(1000);
                System.out.println("等待获取结果");
                System.out.println("剩余任务数:"+ (long) tasks.size());
            } catch (InterruptedException e) {
                log.error("getAggregationResult error",e);
            }
        }
        return resultFunction.apply(results);
    }


    public static void main(String[] args) {
        Master master = new Master(25);

        master.submitTasks(new SumTask(), 10000, new Function<Set<Result>, Result>() {
            @Override
            public Result apply(Set<Result> results) {
                for (Result result : results) {
                    Object value = result.getValue();
                    System.out.println("最终结果"+value.toString());
                }
                return null;
            }
        });
        master.invoke();

    }
}

Task

public interface Task {
    Result execute();
}

Result

public class Result {
    public Object value;

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }

    public Result(Object value) {
        this.value = value;
    }
}

Worker

public class Worker extends Thread {
    private Master master;

    public void setMaster(Master master) {
        this.master=master;
    }

    @Override
    public void run() {
        master.handleTasksByLoop();
    }
}