多线程笔记 - Master-Worker
多线程的 Master-Worker 从字面上也是可以理解的.
Master 相当于领导, 一个就够了, 如果是多个, 那么听谁的, 是个大问题. Master负责指派任务给 Worker. 然后对每个人完成的情况进行汇总.
Worker 相当于具体干活的人, 完成领导分配的任务, 然后把成果交给领导.
这种模式, 有点类似大数据的 MapReduce. 但是比那个简单很多.
这里有个例子:
计算 1²+2²+......+100²的结果.
假如使用 Master-Worker 的方式来计算, 先假设 平方计算 比较耗时, 此处假设每一次平方运算耗时为 100ms.
那么此处要得到计算结果, 就至少需要 100 * 100ms = 10000 ms, 也就是 10s 的时间.
如果此处通过 Master-Worker 的模式来解决此问题, 那么时间会大大缩短.
MyTask 用来存储待计算的数值, 如: 1, 2, 3
public class MyTask implements Serializable { private int id; private int num; public MyTask(int id, int num) { this.id = id; this.num = num; } ...... @Override public String toString() { return "MyTask{" + "id=" + id + ", num=" + num + '}'; } }
Master既然是领导, 肯定需要知道来了哪些任务, 要分配给哪些下属, 且下属干活的成果是什么
public class MyMaster { //1. 需要一个容器来存储待执行任务 private final ConcurrentLinkedQueue<MyTask> tasks = new ConcurrentLinkedQueue<>(); //2. 需要一个容器来存储执行任务的线程 <线程名称, 线程> private HashMap<String, Thread> workThreads = new HashMap<>(); //3. 需要一个容器来存储每一个线程执行后的结果 <任务id, 任务结果> private ConcurrentHashMap<Integer, Object> resMap = new ConcurrentHashMap<>(); //4. 构造函数, 将 Worker 传入, 让每个线程都执行相同的方法 public MyMaster(AbstractWorker myWorker, int workerCount) { myWorker.setTasks(tasks); myWorker.setResMap(resMap); for (int i = 1; i <= workerCount; i++) { String name = "worker" + i; workThreads.put(name, new Thread(myWorker)); } } //5. 任务提交到容器中 public boolean addTask(MyTask task) { return tasks.add(task); } //6. 任务开始执行方法 public void execute(){ for (Map.Entry<String, Thread> worker : workThreads.entrySet()) { worker.getValue().start(); } } //7. 判断所有线程是否执行完毕 public boolean isComplated(){ for (Map.Entry<String, Thread> worker : workThreads.entrySet()) { if(worker.getValue().getState() != Thread.State.TERMINATED){ return false; } } return true; } //8. 总结归纳, 获取结果 public int getResult(){ int res = 0; for (Map.Entry<Integer, Object> resItem : resMap.entrySet()) { res += (int) resItem.getValue(); } return res; } }
Worker 作为干活的人, 也需要知道任务列表, 当干完一个之后, 可以再领取一个任务撸起袖子加油干. 然后还需要知道需要将干活的成果放到哪里去.
public abstract class AbstractWorker implements Runnable { // <线程名称, 线程>, 子类持有 Master 的任务列表, 从中拿取任务 private ConcurrentLinkedQueue<MyTask> tasks; //<任务id, 任务结果>, 子类持有 Master 的结果列表, 将计算结果放进去 private ConcurrentHashMap<Integer, Object> resMap; public void setTasks(ConcurrentLinkedQueue<MyTask> tasks) { this.tasks = tasks; } public void setResMap(ConcurrentHashMap<Integer, Object> resMap) { this.resMap = resMap; } @Override public void run() { while (true) { MyTask task = tasks.poll(); if (task == null) { break; } Object res = handle(task); resMap.put(task.getId(), res); System.out.println(Thread.currentThread().getName() + " 计算 " + task.getNum() + " 结果为 : " + res); } } //这里将具体的实现逻辑放到子类里去, 可以增加扩展性, 此例中现在是算平方, 那通过传入不同的Worker, 也可以算开方 public abstract Object handle(MyTask task); } public class SquareWorker extends AbstractWorker { public Object handle(MyTask task) { int res= task.getNum() * task.getNum(); try { //模拟运算耗时 Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } return res; } }
测试:
public static void main(String[] args) throws InterruptedException { SquareWorker worker = new SquareWorker(); MyMaster master = new MyMaster(worker, 10); String outPrint = ""; for (int i = 1; i <= 100; i++) { MyTask task = new MyTask(i, i); master.addTask(task); outPrint += i + "²" ; if(i < 100){ outPrint += " + "; } } System.out.println(outPrint);
//统计下计算时间 long startTime = System.currentTimeMillis(); master.execute(); while (true){ if(!master.isComplated()){ Thread.sleep(50); continue; } int result = master.getResult(); System.out.println("计算的结果为 : " + result + ", 耗时为 : " + (System.currentTimeMillis() - startTime)); break; } }
结果:
可以看到, 耗时才 1s 多一点, 比之前的 10s 中, 确实缩短了很多.
此处的输出顺序, 并不是有序的. 这也是多线程的一个特点, 正常情况下代码书写顺序和多线程的执行顺序, 往往不是一致的.
当然任何方式, 都是有优点和缺点的.
优点是缩短了执行时间
缺点却是起了更多的线程, 要知道起线程(还有的优化)是有开销的. 起了更多的线程, 就占了更多的空间. 相当于是用空间换时间的一种干法.
这里可以先做一个小优化, 将线程交给线程池托管. 可以不用知道下面具体是那些人干活, 有点外包的意思. master 只要发布任务, 然后拿到自己想要的结果就行了.
先对 Master 进行改写:
public class MyMaster { // <线程名称, 线程>, 子类持有 Master 的任务列表, 从中拿取任务 private final ConcurrentLinkedQueue<MyTask> tasks = new ConcurrentLinkedQueue<>(); //2. 需要线程池来对线程进行托管 private ThreadPoolExecutor pool; //3. 具体干活的标准 private AbstractWorker worker; //4. 雇佣几个人干活 private int workerCount ; //3. 需要一个容器来存储每一个线程执行后的结果 <任务id, 任务结果> private ConcurrentHashMap<Integer, Object> resMap = new ConcurrentHashMap<>(); //4. 构造函数, 将 Worker 传入, 让每个线程都执行相同的方法 public MyMaster(AbstractWorker worker, int workerCount) { this.worker = worker; worker.setResMap(resMap); worker.setTasks(tasks); this.workerCount = workerCount; pool = new ThreadPoolExecutor(workerCount, workerCount, 0, TimeUnit.SECONDS, new LinkedBlockingQueue()); } public void addTask(MyTask task) { tasks.add(task); } public void execute(){ for (int i = 0; i < workerCount; i++) { pool.execute(worker); } } //7. 判断所有线程是否执行完毕 public void finish() { pool.shutdown(); } public boolean isFinished() { return pool.isTerminated(); } //8. 总结归纳, 获取结果 public int getResult() { int res = 0; for (Map.Entry<Integer, Object> resItem : resMap.entrySet()) { res += (int) resItem.getValue(); } return res; } }
测试方法:
public static void main(String[] args) throws InterruptedException { SquareWorker worker = new SquareWorker(); MyMaster master = new MyMaster(worker, 10); String outPrint = ""; long startTime = System.currentTimeMillis(); for (int i = 1; i <= 100; i++) { MyTask task = new MyTask(i, i); master.addTask(task); outPrint += i + "²"; if (i < 100) { outPrint += " + "; } } System.out.println(outPrint); master.execute(); master.finish(); while (!master.isFinished()){ Thread.sleep(10); } int res = master.getResult(); System.out.println("计算的结果为 : " + res + ", 耗时为 : " + (System.currentTimeMillis() - startTime)); }
结果:
