Java多线程中的join方法详解与应用实例

在Java多线程编程中，Thread#join()方法是一个非常重要的工具，它允许一个线程等待另一个线程完成执行。本文将通过几个实例详细解释join()方法的工作原理及其在实际开发中的应用。

join方法的基本概念

Thread#join()方法会使调用它的线程（主线程）暂停执行，直到被调用的线程（子线程）执行完毕。例如，aThreadInstance.join()会让主线程等待aThreadInstance线程执行完毕后才继续执行。

实例1：简单的join使用

下面是一个简单的例子，演示了如何使用join()方法：

public class ThreadJoinExample {
    public static void main(String[] args) throws InterruptedException {
        Task task1 = new Task();
        Thread thread1 = new Thread(task1);
        thread1.start();
        thread1.join(); // 主线程在这里等待thread1执行完毕
        System.out.println("after join");
        Task task2 = new Task();
        new Thread(task2).start();
    }

    private static class Task implements Runnable {
        @Override
        public void run() {
            int c = 0;
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + " started.");
            for (int i = 0; i < 1000; i++) {
                c += i;
            }
            System.out.println(threadName + " ended.");
        }
    }
}

输出结果：

Thread-0 started.
Thread-0 ended.
after join
Thread-1 started.
Thread-1 ended.

从输出可以看出，主线程在thread1执行完毕后才继续执行，thread2则在thread1执行完毕后开始执行.

实例2：并行计算阶乘

接下来，我们通过一个更复杂的例子来展示join()方法的实际应用。假设我们需要并行计算多个整数的阶乘，并在所有计算完成后输出结果：

public class ThreadJoinExample2 {
    public static void main(String[] args) {
        final List<Integer> integers = Arrays.asList(10, 12, 13, 14, 15, 20);
        new Thread(new Runnable() { // 线程A
            @Override
            public void run() {
                List<FactorialCalculator> threads = new ArrayList<>();
                for (Integer integer : integers) {
                    FactorialCalculator calc = new FactorialCalculator(integer);
                    threads.add(calc);
                    calc.start();
                }
                for (FactorialCalculator calc : threads) {
                    try {
                        calc.join();
                        System.out.println(calc.getNumber() + "! = " + calc.getFactorial());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

    private static class FactorialCalculator extends Thread {
        private final int number;
        private BigDecimal factorial;

        FactorialCalculator(int number) {
            this.number = number;
        }

        @Override
        public void run() {
            factorial = calculateFactorial(number);
        }

        private static BigDecimal calculateFactorial(int number) {
            BigDecimal factorial = BigDecimal.ONE;
            for (int i = 1; i <= number; i++) {
                factorial = factorial.multiply(new BigDecimal(i));
            }
            return factorial;
        }

        public BigDecimal getFactorial() {
            return factorial;
        }

        public int getNumber() {
            return number;
        }
    }
}

输出结果：

10! = 3628800
12! = 479001600
13! = 6227020800
14! = 87178291200
15! = 1307674368000
20! = 2432902008176640000

在这个例子中，主线程创建了一个线程A，线程A又创建了多个计算阶乘的线程。通过join()方法，线程A等待所有计算线程执行完毕后才输出结果.

其他join方法的重载形式

除了基本的join()方法外，还有一些重载形式：

• void join(long millis): 最多等待millis毫秒，如果为0则无限等待.
• void join(long millis, int nanos): 最多等待millis毫秒加上nanos纳秒.

这些重载方法提供了更灵活的等待时间设置，可以根据实际需求选择使用.

总结

Thread#join()方法在Java多线程编程中具有重要的作用，它可以帮助我们控制线程的执行顺序，确保某些操作在特定线程执行完毕后才进行。通过本文的实例，希望能帮助大家更好地理解和应用join()方法.