Java Join：线程同步与协作的关键工具

简介

在多线程编程的世界里，线程之间的同步与协作至关重要。Java 的 join 方法提供了一种强大的机制，使得一个线程可以等待另一个线程执行完毕后再继续执行。这篇博客将深入探讨 join 方法的概念、使用方式、常见实践以及最佳实践，帮助你更好地掌握这一重要的多线程编程工具。

目录

1. 基础概念
2. 使用方法
   • 基本语法
   • 示例代码
3. 常见实践
   • 等待多个线程完成
   • 避免死锁
4. 最佳实践
   • 合理设置超时
   • 处理中断
5. 小结
6. 参考资料

基础概念

在 Java 中，每个线程都有自己独立的执行路径。有时候，一个线程的执行结果可能依赖于另一个线程的执行完成。join 方法允许一个线程等待另一个线程执行结束。具体来说，当调用 thread.join() 时，当前线程会暂停执行，直到被调用 join 方法的 thread 线程执行完毕。

使用方法

基本语法

join 方法有几种重载形式： - void join()：等待调用该方法的线程执行完毕。 - void join(long millis)：等待调用该方法的线程最多 millis 毫秒。如果在 millis 毫秒内线程执行完毕，或者时间到了线程还在执行，join 方法都会返回。 - void join(long millis, int nanos)：等待调用该方法的线程最多 millis 毫秒加 nanos 纳秒。

示例代码

public class JoinExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Child thread: " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        thread.start();

        try {
            // 等待子线程执行完毕
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Main thread continues after child thread finishes.");
    }
}

在上述代码中，主线程启动了一个子线程。然后调用 thread.join()，主线程会暂停执行，直到子线程完成它的 for 循环并结束。之后，主线程才会打印出 "Main thread continues after child thread finishes."。

常见实践

等待多个线程完成

有时候需要等待多个线程都执行完毕后再继续执行主线程。可以通过创建线程数组并依次调用 join 方法来实现。

public class MultipleJoinExample {
    public static void main(String[] args) {
        Thread[] threads = new Thread[3];
        for (int i = 0; i < threads.length; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                System.out.println("Thread " + index + " started");
                try {
                    Thread.sleep((index + 1) * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread " + index + " finished");
            });
            threads[i].start();
        }

        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("All threads have finished.");
    }
}

在这个示例中，创建了三个线程，每个线程睡眠不同的时间。主线程在所有线程启动后，通过循环调用 join 方法等待它们全部完成。

避免死锁

死锁是多线程编程中常见的问题，当两个或多个线程相互等待对方释放资源时就会发生。在使用 join 方法时，需要注意避免死锁。例如，确保线程之间的资源获取顺序一致。

public class DeadlockExample {
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 1 acquired lock1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("Thread 1 acquired lock2");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread 2 acquired lock2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("Thread 2 acquired lock1");
                }
            }
        });

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，如果 thread1 先获取 lock1，thread2 先获取 lock2，然后它们互相等待对方释放锁，就会发生死锁。为了避免死锁，应该确保所有线程以相同的顺序获取锁。

最佳实践

合理设置超时

在调用 join 方法时，合理设置超时时间可以避免线程无限期等待。例如，在执行外部服务调用或长时间任务时，设置超时可以防止程序挂起。

public class TimeoutJoinExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread finished");
        });

        thread.start();

        try {
            // 等待线程最多 3 秒
            thread.join(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        if (thread.isAlive()) {
            System.out.println("Thread is still running after timeout.");
        } else {
            System.out.println("Thread finished within timeout.");
        }
    }
}

在这个示例中，主线程等待子线程最多 3 秒。如果子线程在 3 秒内没有完成，主线程会继续执行并检查子线程的状态。

处理中断

join 方法会抛出 InterruptedException，应该妥善处理这个异常。通常，在捕获到 InterruptedException 时，应该清理资源并正确地结束线程。

public class InterruptibleJoinExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Child thread is running");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
            System.out.println("Child thread stopped");
        });

        thread.start();

        try {
            Thread.sleep(3000);
            // 中断子线程
            thread.interrupt();
            // 等待子线程结束
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，主线程在 3 秒后中断子线程，子线程捕获到 InterruptedException 后，设置中断状态并退出循环。主线程调用 join 方法等待子线程结束。

小结

Java 的 join 方法是多线程编程中实现线程同步与协作的重要工具。通过了解其基础概念、使用方法、常见实践以及最佳实践，你可以更有效地控制线程的执行顺序，避免常见的问题，如死锁，并提高程序的可靠性和性能。

参考资料

• Oracle Java Documentation - Thread.join()
• 《Effective Java》 by Joshua Bloch
• 《Java Concurrency in Practice》 by Brian Goetz

希望这篇博客能帮助你更好地理解和使用 Java 的 join 方法。如果你有任何问题或建议，欢迎在评论区留言。