正文

主线程如何耐心等待子线程完成任务，揭秘高效同步技巧

/0 浏览量
0413

在多线程编程中，主线程等待子线程完成任务的同步是一个常见的场景。正确处理这个同步问题不仅能够保证程序的正确性，还能提升程序的效率。以下是一些高效同步技巧的揭秘。

1. 使用join()方法

在Java中，当创建一个线程时，我们可以通过调用join()方法来使主线程等待这个子线程的结束。这是一个非常直接和简单的方法。

public class Main {
    public static void main(String[] args) {
        Thread childThread = new Thread(new Runnable() {
            @Override
            public void run() {
                // 子线程的任务
            }
        });

        childThread.start();
        try {
            childThread.join(); // 等待子线程结束
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

2. 使用CountDownLatch

CountDownLatch是一个同步辅助类，允许一个或多个线程等待一组事件完成。在所有线程都到达某个点之后，主线程会继续执行。

import java.util.concurrent.CountDownLatch;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        int numberOfThreads = 5;
        CountDownLatch latch = new CountDownLatch(numberOfThreads);

        for (int i = 0; i < numberOfThreads; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    // 子线程任务
                    latch.countDown();
                }
            }).start();
        }

        latch.await(); // 等待所有子线程完成
    }
}

3. 使用Semaphore

Semaphore是一个计数信号量，可以用来控制对共享资源的访问。在等待子线程完成时，我们可以使用acquire()方法来阻塞主线程，直到子线程释放信号量。

import java.util.concurrent.Semaphore;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore = new Semaphore(1);

        semaphore.acquire(); // 阻塞主线程

        new Thread(new Runnable() {
            @Override
            public void run() {
                // 子线程任务
                semaphore.release(); // 释放主线程
            }
        }).start();
    }
}

4. 使用Future和Callable

Future和Callable接口提供了异步计算的结果。在子线程执行完毕后，主线程可以通过Future对象获取结果，并等待子线程完成。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<String> future = executorService.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                // 子线程任务
                return "结果";
            }
        });

        try {
            String result = future.get(); // 等待子线程完成并获取结果
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        executorService.shutdown();
    }
}

总结

掌握这些同步技巧对于编写高效的多线程程序至关重要。合理使用这些方法可以确保程序的稳定性和性能。在实际开发中，应根据具体场景选择最合适的同步方法。

-- 展开阅读全文 --