天去面试的时候,遇到一个问题。我三个任务,ABC,我怎么让A执行完执行B,B执行完执行C 3个并行线程,如何解决。程池的核心运行原理和参数。

今天去面试的时候,遇到一个问题。我三个任务,ABC,我怎么让A执行完执行B,B执行完执行C 3个并行线程,如何解决。程池的核心运行原理和参数。

1.线程池核心的参数

1.线程核心数- 线程池中始终保持的活动线程数量。
2.最大线程数- 线程池能够容纳的最大线程数量。
3.等待队列- 用于存储等待执行的任务的队列。
4.线程存活时间- 没有任务额外的线程会保持活动状态的时间。
5.时间单位-可以是毫秒,秒。
6.线程工厂- 创建一个线程工厂。
7.拒绝策略- 线程池的任务队列已满,新任务的处理方式。
举个列子:
private static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10,
            0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>(),
            new ThreadFactoryBuilder()
                    .setThreadFactory(new DefaultThreadFactory("task-inspection"))
                    .setUncaughtExceptionHandler((t, e) -> log.error("{}", t, e)).build()
    );   

2.线程池的运行原理

想象你是一家快餐店的老板,你的店里经常有顾客需要服务。你有一些员工,每个员工可以为顾客制作食物。但是,你不可能每次有顾客来的时候都去雇佣新员工,因为雇佣和解雇都需要花费时间和金钱。
于是,你决定采用一种聪明的方式来管理员工:你雇佣了一组员工,让他们一直待在店里,准备着做食物的工作。当有顾客来了,你只需要把订单交给员工,他们就会按照订单制作食物。这样,你节省了雇佣和解雇的麻烦,员工也可以充分利用自己的时间,不必一直等着顾客。
线程池就像是这家快餐店的员工组合。线程池会事先创建一些线程,就像员工待在店里准备做工作。当有任务需要执行时,就把任务交给线程池,就像把订单交给员工。线程池的线程会按顺序执行任务,然后再继续执行下一个任务,就像员工按照订单制作食物。
线程池的运行原理可以分为以下几个步骤:
  1. 线程池的创建:在程序初始化或需要使用线程池时,创建一个线程池对象。这个线程池对象会根据配置参数来初始化一定数量的线程,以及一个任务队列用于存放待执行的任务。
  2. 任务提交:当有任务需要执行时,应用程序通过将任务对象提交给线程池。这些任务会被放入任务队列中,等待线程池中的空闲线程来执行。
  3. 线程池的管理:线程池会根据配置的核心线程数和最大线程数来管理线程的数量。如果任务数量小于核心线程数,线程池会创建新线程来执行任务。如果任务数量大于核心线程数,但小于最大线程数,线程池会将任务放入任务队列中等待执行,而不会创建新线程。如果任务数量超过最大线程数,线程池会根据拒绝策略来处理任务,例如丢弃任务或抛出异常。
  4. 任务执行:线程池中的线程会从任务队列中取出任务并执行。线程池会不断地从任务队列中取任务,确保所有任务都得到执行。执行完任务后,线程会继续从队列中取下一个任务。
  5. 线程回收:在任务执行完毕后,线程池会根据一定的策略来决定是否回收线程。如果线程池的活动线程数量超过核心线程数,空闲的线程会在一定时间内保持活动状态,以备下次任务使用。如果空闲时间超过一定阈值,额外的线程可能会被终止以节省资源。

3.如何解决这样的问题,我考虑使用 CountDownLatch

1、为什么我会使用 CountDownLatch ?
在上一家公司实际开发过程当中,就遇到过并行的问题。那个时候是要多个任务都执行,但是并没有去保证他的一个执行的顺序。于是我们就使用到了CountDownLatch 使用计数器去判断这些所有的业务逻辑是否都执行完毕,从而进行下一步操作。
部分的代码代码如下:
private static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10,
            0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>(),
            new ThreadFactoryBuilder()
                    .setThreadFactory(new DefaultThreadFactory("task-inspection"))
                    .setUncaughtExceptionHandler((t, e) -> log.error("{}", t, e)).build()
    );   


@Override
    @Transactional(rollbackFor = Exception.class)
    public void asyncInitiatingInspection(InspectionRecordsBO bo) {
        CountDownLatch countDownLatch = new CountDownLatch(inspectionBaseServiceList.size());
        inspectionBaseServiceList.forEach(inspectionBaseService -> {
            threadPoolExecutor.execute(() -> {
                try {
                    MDCUtil.putMDCKey(IdGenUtils.generateRequestId());
                    inspectionBaseService.addInspection(bo);
                } catch (Exception e) {
                    log.error("发起巡检信息失败类:{},发起巡检信息失败:{}", inspectionBaseService.getClass().getName(), e);
                } finally {
                    countDownLatch.countDown();
                    MDCUtil.removeMDCKey();
                }
            });
        });
        try {
            // 等待所有线程执行完毕
            countDownLatch.await();
        } catch (InterruptedException e) {
            log.error("线程计数器失败:" + e);
            Thread.currentThread().interrupt();
        }
        // 判断是否所有巡检已完
        this.updateInspectionResult(bo);
    }
2、什么是 CountDownLatch ?

CountDownLatch 是 Java 标准库中的一个同步工具,用于在多个线程之间进行协调和控制。它可以帮助一个或多个线程等待其他线程完成一组操作,然后再继续执行。

你可以将 CountDownLatch 想象成一个倒计时计数器,可以设置一个初始计数值,然后多个线程可以等待这个计数器减为零,之后再继续执行。

主要的操作方法有两个:

  • await() 方法:调用这个方法的线程会被阻塞,直到计数器减到零。其他线程完成一定操作后,调用 countDown() 方法来减小计数器的值。当计数器变为零时,被阻塞的线程会继续执行。
  • countDown() 方法:这个方法用于减小计数器的值。当一个线程完成了一个操作,可以调用这个方法来减小计数器的值。

CountDownLatch 在多线程编程中常常用于实现“等待所有线程完成某个任务后再继续”的场景。例如,在主线程中等待多个子线程都完成某些操作后再进行下一步操作。

3.解决方案
package com.aq.test;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestCountDownLatch {
    public static void main(String[] args) {
        CountDownLatch latch1 = new CountDownLatch(0);
        CountDownLatch latch2 = new CountDownLatch(1);
        CountDownLatch latch3 = new CountDownLatch(1);

        ExecutorService executor = Executors.newFixedThreadPool(3);

        executor.submit(() -> {
            try {
                latch1.await();
                System.out.println("线程A执行完毕");

                // todo 业务逻辑

            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                latch2.countDown();
            }
        });

        executor.submit(() -> {
            try {
                latch2.await();
                System.out.println("线程B执行完毕");

                // todo 业务逻辑

            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                latch3.countDown();
            }
        });

        executor.submit(() -> {
            try {
                latch3.await();
                System.out.println("线程C执行完毕");

                // todo 业务逻辑


            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        latch1.countDown();

        executor.shutdown();
    }
}

我们使用了三个 CountDownLatch,分别用于控制三个线程的执行顺序。每个线程在执行之前都会通过 await 方法等待前一个线程的 CountDownLatch 计数减为0,然后执行自己的任务。

通过适时的 countDown 调用,我们确保了线程的顺序执行。在这个例子中,线程A会先执行,然后是线程B,最后是线程C。

总结,通过自己的理解和在网上寻找答案。以上就是我对于这几个问题的解决方案和解决思路。

你可能感兴趣的:(java)