【Java 笔试题】创建十个线程，每个线程随机睡眠1–10秒，最终主线程统计十个线程共计休眠时间，打印输出，程序结束。

2022-9-21

这是在我近几天参加的笔试过程中遇到的一道Java多线程相关的笔试题，不过正好在前几天，我有重新去复习Java并发编程相关的知识，而且这道题目并不是太难，就是考察基础的JUC编程基本功。在这里记录一下，总之无论是笔试或者面试，JUC编程都是重中之重。

题目

具体记不太清了，大概意思就是如题所说：让你创建十个线程，然后在每个线程中随机睡眠1--10秒，最终由主线程统计十个线程共计休眠时间，打印输出，程序结束。

题解

首先，我认为应该有很多种实现方案，但是，我有尝试几种，并没正确实现，主要是我太菜。。。下面就记录下我写出来的解决方法。

因为题意好像并没有说清楚，是让十个线程同时启动执行，还是同步执行最后由主线程统计结果。所以首先我写出的是让十个线程同步去执行后再去统计结果的代码。

public class Test{
    public static void main(String[] args){
        Integer integer = 0;

        for (int i = 0; i < 10; i++) {
            FutureTask<Integer> futureTask = new FutureTask<>(new MyThread());
            new Thread(futureTask).start();
            try {
                integer += futureTask.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        System.out.println(integer);
    }
}

class MyThread implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int randomTime = (int) ((Math.random() * 10) + 1);
        System.out.println(Thread.currentThread().getName() + "线程随机休眠：" + randomTime + "秒");
        TimeUnit.SECONDS.sleep(randomTime);
        return randomTime;
    }
}

打印结果：

Thread-0线程随机休眠：3秒
Thread-1线程随机休眠：1秒
Thread-2线程随机休眠：5秒
Thread-3线程随机休眠：4秒
Thread-4线程随机休眠：7秒
Thread-5线程随机休眠：6秒
Thread-6线程随机休眠：7秒
Thread-7线程随机休眠：2秒
Thread-8线程随机休眠：9秒
Thread-9线程随机休眠：2秒
46

Process finished with exit code 0

当然以上代码可以使用线程池实现，代码如下：

public class ThreadPoolTest {

    public static void main(String[] args) {
        Integer integer = 0;
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        MyThread1 myThread1 = new MyThread1();
        for (int i = 0; i < 10; i++) {
            Future<Integer> submit = executorService.submit(myThread1);
            try {
                integer += submit.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        System.out.println(integer);
        executorService.shutdown();
    }
}

class MyThread1 implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int randomTime = (int) ((Math.random() * 10) + 1);
        System.out.println(Thread.currentThread().getName() + "线程随机休眠：" + randomTime + "秒");
        TimeUnit.SECONDS.sleep(randomTime);
        return randomTime;
    }
}

结果与上面一样，都是等待几十秒后，全部线程执行结束，打印结果程序结束。在以上线程池的基础上，可以改进一下，让十个线程同时启动执行，很快就可以打印统计结果。

public class Test2 {

    public static void main(String[] args) {
        Integer sum = 0;
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Future<Integer>[] futures = new Future[10];
        for (int i = 0; i < 10; i++) {
            futures[i] = executorService.submit(new MyThread3());
        }
        try {
            for (int i = 0; i < 10; i++) {
                sum += futures[i].get();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println(sum);
        executorService.shutdown();
    }
}
class MyThread3 implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int randomTime = (int) ((Math.random() * 10) + 1);
        System.out.println(Thread.currentThread().getName() + "线程随机休眠：" + randomTime + "秒");
        TimeUnit.SECONDS.sleep(randomTime);
        return randomTime;
    }
}

代码执行结果与上面类似，但是效果不同，会在刚启动时就直接打印：

pool-1-thread-4线程随机休眠：4秒
pool-1-thread-3线程随机休眠：7秒
pool-1-thread-2线程随机休眠：8秒
pool-1-thread-5线程随机休眠：4秒
pool-1-thread-1线程随机休眠：6秒
pool-1-thread-7线程随机休眠：5秒
pool-1-thread-6线程随机休眠：8秒
pool-1-thread-8线程随机休眠：1秒
pool-1-thread-9线程随机休眠：3秒
pool-1-thread-10线程随机休眠：3秒

在等待8秒后，打印统计结果，程序结束。