以做家务的角度来看Java并发

背景：996的秃头程序猿（小猿）周天想打英雄联盟，女朋友说玩游戏的前提是，先做家务。

家务活有做饭、洗衣服、烧水、扫地等等，前提是小猿完全不知道这些家务分别需要干多长时间。于是小猿就很苦恼了，并且抱怨得想：“妈的，我天天996还要受你这个娘们儿的气，不过了”，但是这个危险的念头很快消失了，毕竟女朋友这么多年不离不弃得跟着自己这个矮穷搓，不能辜(变)负(单)了(身)她(狗)。

家务列表

// BoilingWater Task
public class BoilingWater implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        Thread.sleep(2000);
        System.out.println("烧开水花了20分钟时间");
        return true;
    }
}
// MakeDinner Task
public class MakeDinner implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        Thread.sleep(4000);
        System.out.println("做饭花了40分钟时间");
        return true;
    }
}
// SweepFloor Task
public class SweepFloor implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        Thread.sleep(2000);
        System.out.println("扫地花了20分钟时间");
        return true;
    }
}
// WashClothes Task
public class WashClothes implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        Thread.sleep(4000);
        System.out.println("洗衣服花了40分钟时间");
        return true;
    }
}

踏踏实实一件事一件事干（同步）

小猿考虑用串行(Serial)的方式一件一件做(One-By-One)，他决定先写一段代码测试一下他需要花多长时间去完成家务：

// 如果你的女朋友很贤惠，可以让你女朋友做家务，类名可以改成MyWifeHouseWork
public class MyHouseWork {
    // 同步做家务线程池
    static ExecutorService syncPool = Executors.newSingleThreadExecutor();

    public static void doHouseWork(ExecutorService executor) throws ExecutionException, InterruptedException {
        // 计时的秒表
        Stopwatch stopwatch = Stopwatch.createStarted();
        Future<Boolean> boilingWaterResult = executor.submit(new BoilingWater());
        Future<Boolean> makeDinnerResult = executor.submit(new MakeDinner());
        Future<Boolean> washClothesResult = executor.submit(new WashClothes());
        Future<Boolean> sweepFloorResult = executor.submit(new SweepFloor());
        boilingWaterResult.get();
        makeDinnerResult.get();
        washClothesResult.get();
        sweepFloorResult.get();
        System.out.println(MessageFormat.format("我做家务总共花了{0}分钟", String.valueOf(10 * stopwatch.elapsed(TimeUnit.SECONDS))));
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("现在开始同步方式做家务");
        doHouseWork(syncPool);
    }
}

执行结果是，小猿需要花120分钟去做家务，导致他没有时间玩游戏，怎么办呢？

现在开始同步方式做家务
烧开水花了20分钟时间
做饭花了40分钟时间
洗衣服花了40分钟时间
扫地花了20分钟时间
我做家务总共花了120分钟

几件事同时做（异步）

于是乎小猿想用并行(Parallel)的方式来模拟一下，看看是否会能有所优化：

	// 异步做家务线程池
    static ExecutorService asyncPool = Executors.newFixedThreadPool(4);
	public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("现在开始异步方式做家务");
        doHouseWork(asyncPool);
    }

执行结果出乎意料，居然只需要40分钟，大大缩短了家务时间，就可以在保住女朋友的情况下安心去玩游戏了。

现在开始异步方式做家务
扫地花了20分钟时间
烧开水花了20分钟时间
洗衣服花了40分钟时间
做饭花了40分钟时间
我做家务总共花了40分钟

思考

1.为什么可以优化这么多呢？
我们把小猿看成CPU，小猿其实只需要去完成少部分的计算任务，比如打开电饭煲开关，打开洗衣机开关，打开电水壶开关，打开扫地机器人的开关。只需要等待IO结果就行了，做饭是交给电饭煲去完成的，洗衣服是交给洗衣机完成的，烧水是交给开水壶完成的，扫地是交给扫地机器人去完成的。
2.我们的异步线程池设置的是4，刚好对应4件家务活，如果线程数换成3会怎么样呢？
把线程池换成3之后，还是40分钟，因为线程A做饭40分钟，线程B洗衣40分钟，线程C烧水&拖地40分钟，刚好还是40分钟。
3.如果线程数换成2会怎么样呢？
对，没错，60分钟。