Java程序中实现等待执行的最佳方法是什么？

在Java编程中,等待一个线程执行完成有多种方法，以下是一些常用的方式：

使用join()方法

join()方法是Thread类中的一个方法，它可以让当前线程等待直到指定的线程结束。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() > {
            System.out.println("子线程开始执行");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程执行完成");
        });
        t.start();
        t.join(); // 等待子线程执行完成
        System.out.println("主线程继续执行");
    }
}

使用wait()和notify()方法

wait()和notify()方法是Object类的一部分，它们用于线程间的通信。

public class Main {
    public static void main(String[] args) {
        Object lock = new Object();
        Thread t = new Thread(() > {
            synchronized (lock) {
                System.out.println("子线程开始执行");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("子线程执行完成");
                lock.notify(); // 通知主线程
            }
        });
        t.start();
        synchronized (lock) {
            System.out.println("主线程等待子线程执行完成");
            try {
                lock.wait(); // 等待子线程通知
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("主线程继续执行");
        }
    }
}

使用CountDownLatch

CountDownLatch是一个同步辅助类，允许一个或多个线程等待一组事件发生。

import java.util.concurrent.CountDownLatch;
public class Main {
    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(1);
        Thread t = new Thread(() > {
            System.out.println("子线程开始执行");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程执行完成");
            latch.countDown(); // 事件发生
        });
        t.start();
        System.out.println("主线程等待子线程执行完成");
        try {
            latch.await(); // 等待事件发生
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程继续执行");
    }
}

使用CyclicBarrier

CyclicBarrier是一个同步辅助类，它允许一组线程在某个点等待，直到所有线程都到达这个点。

import java.util.concurrent.CyclicBarrier;
public class Main {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(2);
        Thread t = new Thread(() > {
            System.out.println("子线程开始执行");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程执行完成");
            barrier.await(); // 等待其他线程
        });
        t.start();
        System.out.println("主线程等待子线程执行完成");
        try {
            barrier.await(); // 等待子线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程继续执行");
    }
}

使用Future

Future是java.util.concurrent包中的一个接口，它代表了异步计算的结果。

import java.util.concurrent.*;
public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(() > {
            System.out.println("子线程开始执行");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程执行完成");
            return "Hello, World!";
        });
        System.out.println("主线程等待子线程执行完成");
        try {
            String result = future.get(); // 等待子线程执行完成
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        executor.shutdown();
    }
}

FAQs

Q1：如何选择合适的等待执行方法？

A1：选择合适的等待执行方法取决于具体的需求，如果只需要等待单个线程执行完成，可以使用join()方法；如果需要线程间通信，可以使用wait()和notify()方法；如果需要等待一组事件发生，可以使用CountDownLatch；如果需要一组线程协同工作，可以使用CyclicBarrier；如果需要异步计算，可以使用Future。

Q2：join()方法和CountDownLatch的区别是什么？

A2：join()方法可以等待单个线程执行完成，而CountDownLatch可以等待一组事件发生，如果只需要等待单个线程执行完成，可以使用join()方法；如果需要等待多个线程执行完成，可以使用CountDownLatch。