Java多线程(ExecutorService), 等待所有线程执行完毕.

这篇文章非原创,来自两位大神的代码:

常用的两种方式:

第一种方式:来自大神cletus的回答, 原文链接

ExecutorService taskExecutor = Executors.newFixedThreadPool(4);
while(...) {
  taskExecutor.execute(new MyTask());
}
taskExecutor.shutdown();
try {
  taskExecutor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
} catch (InterruptedException e) {
  ...
}

第二种方式:来自大神ChssPly76的回答, 原文链接

CountDownLatch latch = new CountDownLatch(totalNumberOfTasks);
ExecutorService taskExecutor = Executors.newFixedThreadPool(4);
while(...) {
  taskExecutor.execute(new MyTask());
}

try {
  latch.await();
} catch (InterruptedException E) {
   // handle
}

然后在线程方法中加入:

       try {
            ...
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            countDownLatch.countDown();
        }

作者建议用第二种方式,即用  CountDownLatch 来实现。

完整实例如下:

我们先定义一个 Runnable 类:CountDownLatchRunnable

关键点1:我们要通过 CountDownLatch  来计数,因此我需要把 CountDownLatch  对象传到这个 Runnable 类中。

关键点2:每次执行完后,一定要 countDownLatch.countDown()


@Slf4j
public class CountDownLatchRunnable implements Runnable {
    private final String command;
    private final CountDownLatch countDownLatch;

    public CountDownLatchRunnable(String command, CountDownLatch countDownLatch) {
        this.command = command;
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        log.info(Thread.currentThread().getName() + " start. Command = " + command);
        processCommand(command);
        log.info(Thread.currentThread().getName() + " finish.");
    }

    private void processCommand(String command) {
        log.info(Thread.currentThread().getName() + ":, doing work:" + command);
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            countDownLatch.countDown();
        }
    }
}
然后实现运行:

@Slf4j
public class Run {

    public static void main(String[] args) throws InterruptedException {

        log.info("Main thread start.");

        int theadNum = 3;
        // CountDownLatch 需要将对象传入需要'等待完成'的线程对象中
        CountDownLatch countDownLatch = new CountDownLatch(theadNum);
        ExecutorService executorService = Executors.newFixedThreadPool(theadNum);
        Runnable worker = new CountDownLatchRunnable("Task", countDownLatch);

        // 创建5个线程, 提交到线程池
        for (int i = 0; i < theadNum; i++) {
            executorService.execute(worker); // 同一个实例对象
        }
        // 等待所有线程执行完成(线程阻塞)
        countDownLatch.await();

        log.info("Main thread finish.");

        // 停止接受新任务,当已有任务将执行完,关闭线程池
        executorService.shutdown();
        // 等待线程池中所有的任务执行完成, 前提是执行了 shutdown
        while (!executorService.isTerminated()) {
            // 等待所有线程执行完成
        }
        log.info("exit");
    }
}

运行结果如下:

Connected to the target VM, address: '127.0.0.1:32229', transport: 'socket'
[zhang-console] INFO 2023-11-18 03:07:48 j.b.j.t.t.t2_wait_countdownlatch.Run: Main thread start.
[zhang-console] INFO 2023-11-18 03:07:48 j.b.j.t.t.t.CountDownLatchRunnable: pool-1-thread-1 start. Command = Task
[zhang-console] INFO 2023-11-18 03:07:48 j.b.j.t.t.t.CountDownLatchRunnable: pool-1-thread-1:, doing work:Task
[zhang-console] INFO 2023-11-18 03:07:48 j.b.j.t.t.t.CountDownLatchRunnable: pool-1-thread-2 start. Command = Task
[zhang-console] INFO 2023-11-18 03:07:48 j.b.j.t.t.t.CountDownLatchRunnable: pool-1-thread-2:, doing work:Task
[zhang-console] INFO 2023-11-18 03:07:48 j.b.j.t.t.t.CountDownLatchRunnable: pool-1-thread-3 start. Command = Task
[zhang-console] INFO 2023-11-18 03:07:48 j.b.j.t.t.t.CountDownLatchRunnable: pool-1-thread-3:, doing work:Task
[zhang-console] INFO 2023-11-18 03:07:49 j.b.j.t.t.t.CountDownLatchRunnable: pool-1-thread-3 finish.
[zhang-console] INFO 2023-11-18 03:07:49 j.b.j.t.t.t2_wait_countdownlatch.Run: Main thread finish.
[zhang-console] INFO 2023-11-18 03:07:49 j.b.j.t.t.t.CountDownLatchRunnable: pool-1-thread-1 finish.
[zhang-console] INFO 2023-11-18 03:07:49 j.b.j.t.t.t.CountDownLatchRunnable: pool-1-thread-2 finish.
[zhang-console] INFO 2023-11-18 03:07:49 j.b.j.t.t.t2_wait_countdownlatch.Run: exit
Disconnected from the target VM, address: '127.0.0.1:32229', transport: 'socket'

  • 9
    点赞
  • 18
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
Java中,可以使用ExecutorService来实现多线程插入数据。ExecutorServiceJava中用于管理线程池的高级工具类。通过使用ExecutorService,我们可以创建和管理线程池,并且可以方便地提交任务给线程执行。 首先,你需要在代码中引入java.util.concurrent.ExecutorServicejava.util.concurrent.Executors类。然后,你可以使用Executors类的静态方法来创建一个ExecutorService实例。例如,可以使用Executors.newFixedThreadPool()方法创建一个固定大小的线程池。 在创建ExecutorService实例之后,你可以使用submit()方法提交任务给线程执行。在每个任务中,你可以使用线程池提供的线程来插入数据。当任务执行完成之后,线程会自动返回线程池供下一个任务使用。 下面是一个示例代码,展示了如何使用ExecutorService实现多线程插入数据: ```java import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class DataInsertion { public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(10); // 创建一个固定大小的线程池 // 提交任务给线程执行 for (int i = 0; i < 100; i++) { executorService.submit(() -> { // 在这里编写插入数据的逻辑 // ... System.out.println("插入数据"); }); } // 关闭线程executorService.shutdown(); } } ``` 在上面的代码中,我们创建了一个固定大小为10的线程池,然后使用submit()方法提交了100个任务给线程执行。每个任务中可以编写具体的插入数据逻辑。 值得注意的是,当任务提交完毕后,需要调用executorService.shutdown()方法来关闭线程池。这样可以确保所有的任务都执行完毕后,线程池会被安全关闭。 这样,你就可以使用ExecutorService实现多线程插入数据了。同时,可以根据自己的需求调整线程池的大小和其他参数,以优化性能和资源管理。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值