线程的创建、Lambda函数式接口?Runnable和Callable之间的适配?动态修改线程任务?这里带你图解Java线程池

线程的创建、Lambda函数式接口?Runnable和Callable之间的适配?动态修改线程任务?这里带你图解Java线程池

Java线程创建的方式

  • 继承Thread类,重写run方法
  • 重写Runnable接口,交给Tread类静态代理实现
  • 实现Callable接口,用FutureTask封装
  • 实现Runnable接口,用FutureTask封装
  • 继承FutureTask类,重写run方法(猜想、偏方,你非要实现其实也可以,hhh)
  • 线程池创建

前三种创建方式

这里为了便于叙述,毕竟不是本次的重点,我直接上源码,没基础的可以去找些其他资料来补一补

public class ThreadpoolApplication {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 1. 继承Thread类实现
        Thread impl =new ThreadImpl();
        impl.start();
        // 2. 实现Runnable接口
        // 对于有 @FunctionalInterface 的类 or 接口,我们可以使用lambda表达式来简化,当然
        // 没有这个注解也可以,但是一定要符合函数式编程的规范
        //      1. 只能有1个待实现的方法
        //      2. 允许有默认方法
        //      3. 只能是接口
        // @FunctionalInterface 可有可无,但是为了规范建议写上,起一个标记作用,告诉编译器这是一个函数式接口
        // 可以让IDE帮你检测你的函数式接口是否符合规范
        Thread runnableImpl = new Thread(new Runnable() {

            // 这里可以用函数式接口lambda表达式来简写,具体的内容这里不做过多解释,
            // 你可以理解lambda实现为是对接口的简单实现,因为你用lambda返回的也是个Runnable实现对象
            // 后面我就直接用Lambda表达式来简写了。
            @Override
            public void run() {

            }
        });

        runnableImpl.start();

        // 实现Callable接口,带返回值
        FutureTask<Integer> futureTask= new FutureTask<>(()->{
            return 1;
        });
        new Thread(futureTask).start();
        System.out.println(futureTask.get());
        Integer result=0;

        // 实现Runnable接口,带返回值
        futureTask=new FutureTask<>(()->{

        },result);
        new Thread(futureTask).start();
        futureTask.get();   // 其实这个值就是你设置的值,可以去看一下源码,这里只是为了方便任务管理

        return ;
    }

}

浅说函数式编程 —— Lambda的魔法

大家可能对函数式编程有点懵,其实就是符合上面所说的规范

对于有 @FunctionalInterface 的接口,我们可以使用lambda表达式来简化,当然没有这个注解也可以,但是一定要符合函数式编程的规范

  • 只能有1个待实现的方法
  • 允许有默认方法
  • 只能是接口,抽象类也不行

@FunctionalInterface 可有可无,但是为了规范建议写上,起一个标记作用,告诉编译器这是一个函数式接口可以让IDE帮你检测你的函数式接口是否符合规范

比如这样子:

@FunctionalInterface
public interface MethodInterface {
    void print();

    default MethodInterface andThen(MethodInterface methodInterface){
        // 想一下有什么区别
        //  print();
        //  methodInterface.print();
        //  return methodInterface;
        return ()->{
            print();
            methodInterface.print();;
        };
        // 不用lambda表达式,那么就是在andThen里面进行执行的,每次执行andThen的时候都会自动执行print方法,而且总体上每次           
        // methodInterface.print()会执行两次,那么methodInterface.print()不写的话最后需要再执行一次applay
        // 如果你是使用的lambda表达式返回,那么返回的是一个全新的接口,如果我们需要链式调用完,那么在最后还要执行一下
        // print方法,当然你也可以选择实现一个end()方法来表示结束,相当于另外起一个名
    }
}

其实上面的函数式接口和Cusumer一样,不过Cusumer多了一个判空的过程,除此之外还有另外几个常用的函数式接口(统一规范),如下:

Cusumer

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

Function

@FunctionalInterface
public interface Function<T, R> {

    R apply(T t);

    // 执行一个before操作,类似于AOP思想
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        // 将执行完成before的结果再带入当前的Fuction进行运算
        // nnd, 这不是指针啊!!!,lambda表达是只有一行的时候可以不用写大括号
        return (V v) -> apply(before.apply(v));
        // 相当于这样
        // return (V v) -> {
        //     apply(before.apply(v));
        // }
    }

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        // 在本次执行完之后再执行after
        return (T t) -> after.apply(apply(t));
    }

    // 这又是个什么玩意儿,别急,看我代码补全,构造一个传入和返回同类型的接口
    // 这有啥用,呃呃呃,简写而已,这个是对apply的实现就是给啥还啥,但是只能过用在Function接口上
    // 其他接口不适用,因为接口返回类型,但是你都可以用 t -> t 来表示
    static <T> Function<T, T> identity() {
        // return t -> return t;
        return t -> t;
    }
}

BiFunction

@FunctionalInterface
public interface BiFunction<T, U, R> {

    // 对t和u进行运算,返回R类型,nnd,不就是sort函数的第三个cmp参数吗,不说了
    R apply(T t, U u);

    // 这一块就不说了
    default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t, U u) -> after.apply(apply(t, u));
    }

Supplier

工厂模式,要什么可以现在这类面配置好,最后再来一个beanFactory.get()就行

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

Predicate

@FunctionalInterface
public interface Predicate<T> {

    // 实现一个原子性的判断,也就是说我们可以把这个放在if里面来玩儿
    boolean test(T t);

    // 与运算   
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    // 非
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    // 或
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    // 判断相等
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }

    // 类似于上面Function的identity()方法
    @SuppressWarnings("unchecked")
    static <T> Predicate<T> not(Predicate<? super T> target) {
        Objects.requireNonNull(target);
        return (Predicate<T>)target.negate();
    }
}

也许你有一个疑问,为什么最后又会返回一个函数式接口?而不是使用直接执行,拿这个方法来说

 default MethodInterface andThen(MethodInterface methodInterface){
        // 想一下有什么区别
        //  print();
        //  return methodInterface;
        return ()->{
            print();
            methodInterface.print();;
        };
        // 不用lambda表达式,那么就是在andThen里面进行执行的,每次执行andThen的时候都会自动执行print方法,而且总体上每次           
        // methodInterface.print()会执行两次,那么methodInterface.print()不写的话最后需要再执行一次applay
        // 如果你是使用的lambda表达式返回,那么返回的是一个全新的接口,如果我们需要链式调用完,那么在最后还要执行一下
        // print方法,当然你也可以选择实现一个end()方法来表示结束,相当于另外起一个名
    }

对于直接返回method,最后再来执行一次,那么就像排队一样,一步一步执行,那么你调试的时候,就会频繁的在上下文跳来跳去。

如果你使用接口封装,那么调用print()相当于是一次组合,什么还不懂?

那么好,如果说我要用这个结合来做很多次(比如放入异步任务,当然这里不可能,我是说如果),你不用接口组合,而是用面向过程来实现

那么我们每次放进去都要放

a.andThen()
    .andThen()
    .andThen()
    .andThen()
    ...
    .andThen().print();

// 重新运行只能这样做
a.andThen()
    .andThen()
    .andThen()
    .andThen()
    ...
    .andThen().print();

那么如果我们是用组合

我们只需要这样做

MethodInterface mi=a.andThen()
    .andThen()
    .andThen()
    .andThen()
    ...
    .andThen();

// 每次要重复执行的时候只需要运行一下,一行代码解决
mi.print();

关于函数式编程在stream中的运用,我给大家推荐一篇文章,这里我就不做过多的讲解了,毕竟就是写调用的问题,上面的能看懂,那么我相信你看源代码的时候都能够迎刃而解!

FutureTask源码浅析

一个线程一个Thread对象,那么Thread对象的创建和销毁就太频繁了,那么有没有优化的方案呢?

之前我们不是将FutureTask给放入了Thread进行运行吗?也就是说FutureTask能够管理我们的任务方法

没错,我们可以用FutureTask来对线程进行封装,再放入Thread,每次任务结束的时候控制FutrueTask就可以了,完全不用管Thread对象的创建

那么FutureTask的任务创建是啥?

来看看源码吧,先来看看是如何做到Runnable和Callable之间的适配的

public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;       // 如果是callable,那么直接静态代理,能够理解
        this.state = NEW;       // ensure visibility of callable
    }

public FutureTask(Runnable runnable, V result) {
    this.callable = Executors.callable(runnable, result);   // 如果是runnable,那么采用适配器模式转换一下
    /**
    public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }
    **/
    this.state = NEW;       // ensure visibility of callable
}

// runnable适配器
private static final class RunnableAdapter<T> implements Callable<T> {
        private final Runnable task;
        private final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;  // 这里可以看到只是使用适配器模式对task进行一个代理,返回的result的值是固定的,当然有异常的话就没有返回
        }
        public String toString() {
            return super.toString() + "[Wrapped task = " + task + "]";
        }
    }
        public void run() {
        if (state != NEW ||
            !RUNNER.compareAndSet(this, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();      // 不管是哪个类型,都适配成call来被代理
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

来看看FutureTask的继承

image-20230810122254018

但是找了一圈儿也没有找到一个可以设置callable的方法,都是初始化,那么就自己实现吧,参考上面的实现一个

package fyi.wzl.threadpool.threadimpl;

import org.springframework.util.ObjectUtils;

import java.util.concurrent.Callable;

public class CallableImpl<T> implements Callable {

    private Callable<T> callable;
    @Override
    public T call() throws Exception {
        if (ObjectUtils.isEmpty(callable)) return null;
        return callable.call();
    }

    public CallableImpl(Callable<T> callable) {
        this.callable = callable;
    }

    public CallableImpl(Runnable runnable,T res) {
        this.callable = new RunnableAdpter(runnable,res);
    }

    public CallableImpl<T> setCallable(Callable<T> callable) {
        this.callable = callable;
        return this;
    }

    public CallableImpl<T> setCallable(Runnable runnable,T res) {
        this.callable = new RunnableAdpter(runnable,res);
        return this;
    }

    private class RunnableAdpter implements Callable<T> {
        Runnable runnable;
        T res;

        public RunnableAdpter(Runnable runnable, T res) {
            this.runnable = runnable;
            this.res = res;
        }

        @Override
        public T call() throws Exception {
            this.runnable.run();
            return res;
        }
    }
}

当然,你也可以写一个CallableAdpter来适配Callable为Runnable

因为Java引用传递,那么我们可以通过修改callble来达到修改任务的目的,那么貌似不用FutureTask也可以了?当然你也可以实现一个类似FutrueTask的实现,这样就不用FutrueTask,直接交给Thread进行管理也可以。

那么FutrueTask的作用是啥?

FutureTask一个可取消的异步计算,FutureTask 实现了Future的基本方法,提供 start cancel 操作,可以查询计算是否已经完成,并且可以获取计算的结果。结果只可以在计算完成之后获取,get方法会阻塞当计算没有完成的时候,一旦计算已经完成,那么计算就不能再次启动或是取消。

再看看FutrueTask的源码,又有AQS这些东东,这些东西我们在以后的文章里面细说。

如何动态修改Thread的run方法 —— 线程池实现的猜想(结果肯定是事与愿违,只是鼠人的一种猜想罢了)

好了,刚才讲到,我们可以用FutrueTask来封装Runnable和Callable(那么我封装自己也可以吧),那么我们也可以手写一个实现来实现可变换任务的封装(其实这里不太严谨,但是为了照顾新手,就讲的简单点,我们直接使用)

  CallableImpl<Integer> callable = new CallableImpl<>(() -> {
            System.out.println("没改");
            return 1;
        });
        FutureTask futureTask = new FutureTask<Integer>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        callable.setCallable(()->{
            System.out.println("改了");
            return 2;
        });
        System.out.println(futureTask.get());

但是注意的是Thread中start只能执行一次,那么怎么做?

重写Thread来判断任务状态,然后没有任务的时候进行阻塞,有任务的时候进行唤醒,下面来简单实现一下(其实这里也可以实现一个任务队列,然后异步监控来判断实现notifyall)

public class ThreadpoolApplication {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CallableImpl<Integer> callable = new CallableImpl<>(() -> {
            System.out.println("没改,线程ID为:"+Thread.currentThread().getId());
            return 1;
        });
        ThreadImpl thread=new ThreadImpl(callable);
        // 线程开始后是死循环,没执行一次后进行阻塞,等到新任务进入后进再执行
        thread.start();
        AtomicInteger i= new AtomicInteger(0);
        while(true){
            // 这里是每次设定不同的任务
                callable.setCallable(thread.getId(),()->{
                    System.out.println("改了"+i.getAndIncrement()+"线程ID为:"+Thread.currentThread().getId());
                    return 2;
                });
        }
    }
}

来看一看对于Thread的重新实现吧

public class ThreadImpl extends Thread{

    // 自己实现的一个Callble接口,模仿FutrueTask实现
    CallableImpl callable=null;

    public ThreadImpl(CallableImpl callable) {
        this.callable = callable;
    }

    // 其实主要是对run方法进行的修改,这里有一点AOP那个味道了,好好好
    @Override
    public void run() {
        while (true){
            // 多线程代码
            String intern = String.valueOf(this.getId()).intern();
            synchronized (intern){
              try {
                  this.callable.call();
              } catch (Exception e) {
                  throw new RuntimeException(e);
              } finally {
                  try {
                      intern.wait();
                  } catch (InterruptedException e) {
                      throw new RuntimeException(e);
                  }
              }
          }

        }
    }
}
// 这个方法可能有点偏离原始实现Thread的思想,现在感觉应该是以实现RUnnable接口为主,难得改了,有兴趣的朋友可以写一下
public class CallableImpl<T> implements Callable {

    private Callable<T> callable;
    @Override
    public T call() throws Exception {
        if (ObjectUtils.isEmpty(callable)) return null;
        return callable.call();
    }

    public CallableImpl(Callable<T> callable) {
        this.callable = callable;
    }

    public CallableImpl(Runnable runnable,T res) {
        this.callable = new RunnableAdpter(runnable,res);
    }

    public CallableImpl<T> setCallable(long threadId,Callable<T> callable) throws InterruptedException {
        String id=String.valueOf(threadId).intern();
        synchronized (id) {
            this.callable = callable;
            id.intern().notify();
            // notify需要等待锁释放完成后才会对其它锁进行唤醒操作,不信的话可以把注释删掉跑一边
//            while (true){
//                if (id==null)break;
//            }
        }
        return this;
    }

    public CallableImpl<T> setCallable(Runnable runnable,T res) {
        this.callable = new RunnableAdpter(runnable,res);
        return this;
    }

    private class RunnableAdpter implements Callable<T> {
        Runnable runnable;
        T res;

        public RunnableAdpter(Runnable runnable, T res) {
            this.runnable = runnable;
            this.res = res;
        }

        @Override
        public T call() throws Exception {
            this.runnable.run();
            return res;
        }
    }
}

看看执行结果

image-20230810164019956

第四种线程创建方式 —— 线程池

核心概念

上面只是提到了对于Thread执行任务的一种动态实现方法,肯定还有其他的。

那么动态实现有什么好处呢?

当我们有很多个任务的时候,我们如果一直使用new,再让gc的话,那么对于系统资源的消耗无疑是巨大的。

那么这个时候,如果我们固定一下,专门拿几个线程来处理并发任务呢?但是当并发任务很多又该怎么办?

这个时候就引入了池化思想 —— Pool

什么是池?

在学JDBC的时候我们知道了连接池,在学Spring的时候,我们又接触到了对象池。

其实按理来说线程池应该是大家在初学JavaSE的时候应该就遇到的,这里我们再来讲一下。

线程池,就是用一个容器来管理线程,这个容器叫做池(Pool)。

pool里面的线程数量是固定的,我们拿着固定的线程数量区执行不同的任务,下面来看一个思维图。

image-20230810220812599

这里要引入几概念:

  • 最大线程数

    线程池允许创建的最大线程数量。

  • 核心线程数

    线程池维护的最小线程数量,核心线程创建后不会被回收(注意:设置allowCoreThreadTimeout=true后,空闲的核心线程超过存活时间也会被回收)。

  • 阻塞队列

    一个用于存放任务的队列

当最开始有任务到达的时候,会抢先占用核心线程,当核心线程占用满了以后进入任务队列,任务队列满了以后还有新的线程,那么启用临时线程来进行处理,注意的是临时线程不会处理阻塞队列中的任务,并且临时线程拥有一个存活时间,当长时间没有任务的时候,就会进行自动销毁。

如果临时线程也满了,就是说超过了最大线程数,这也代表着阻塞队列满了,那么采用拒绝策略。

拒绝策略

下面我们堆四大拒绝策略来展开说说

AbortPolicy

终止策略,这是ThreadPoolExecutor线程池默认的拒绝策略,程序将会抛出RejectedExecutionException异常。

    public static class AbortPolicy implements RejectedExecutionHandler {

        public AbortPolicy() { }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }

CallerRunsPolicy

调用者运行策略,线程池中没办法运行,那么就由提交任务的这个线程运行(嗯,也就相当于变成了原来的单线程串行执行)。

    public static class CallerRunsPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code CallerRunsPolicy}.
         */
        public CallerRunsPolicy() { }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();    // 直接就在这里运行了,并且不会爬出异常
            }
        }
    }

DiscardOldestPolicy

丢弃最早未处理请求策略,丢弃最先进入阻塞队列的任务以腾出空间让新的任务入队列。
有一点像滑动窗口那个感觉了

    public static class DiscardOldestPolicy implements RejectedExecutionHandler {

        public DiscardOldestPolicy() { }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);       // 在这里面执行了入队操作
            }
        }
    }

DiscardPolicy

丢弃策略,什么都不做,即丢弃新提交的任务。

    public static class DiscardPolicy implements RejectedExecutionHandler {

        public DiscardPolicy() { }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }

总结一下,上面其实可以看出一个优先级:

任务总是按照如下优先级进入:

核心线程>阻塞队列>临时线程>拒绝策略

创建线程池

说了这么多,那么我们如何创建线程池呢?

我们只需要new一个对象就可以了

ThreadPoolExecutor

这里我们来玩儿个好玩儿的,玩儿玩儿阻塞,哈哈,组省赛策略我们选择CallerRunsPlicy,也就是哪来的回哪里去

public class ThreadpoolApplication {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        int corePoolSize=3;
        int maximumPoolSize=6;
        long keepAliveTime=7000L;
        TimeUnit unit=TimeUnit.MILLISECONDS;
        BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue<>(10);
        ExecutorService executorService = new ThreadPoolExecutor(corePoolSize,
                maximumPoolSize,
                keepAliveTime,
                unit,
                workQueue,new ThreadPoolExecutor.CallerRunsPolicy());
        int i=0;
        Thread local=Thread.currentThread();
        while (i++<3){
            int j=0;
            while(j++<6){
                executorService.execute(()->{
                    Thread thread = Thread.currentThread();
                    System.out.println(thread +"完成,时间:"+new Date());
                    try {
                        if (!thread.equals(local)){
                            Thread.sleep(5000);
                        }
                        else {
                            Thread.sleep(2000);
                        }
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                });
            }
        }
    }
}

我们可以看一下运行结果

Thread[pool-1-thread-3,5,main]完成,时间:Fri Aug 11 05:55:03 CST 2023
Thread[pool-1-thread-6,5,main]完成,时间:Fri Aug 11 05:55:03 CST 2023
Thread[pool-1-thread-2,5,main]完成,时间:Fri Aug 11 05:55:03 CST 2023
Thread[pool-1-thread-5,5,main]完成,时间:Fri Aug 11 05:55:03 CST 2023
Thread[main,5,main]完成,时间:Fri Aug 11 05:55:03 CST 2023
Thread[pool-1-thread-4,5,main]完成,时间:Fri Aug 11 05:55:03 CST 2023
Thread[pool-1-thread-1,5,main]完成,时间:Fri Aug 11 05:55:03 CST 2023
Thread[main,5,main]完成,时间:Fri Aug 11 05:55:05 CST 2023
Thread[pool-1-thread-6,5,main]完成,时间:Fri Aug 11 05:55:08 CST 2023
Thread[pool-1-thread-1,5,main]完成,时间:Fri Aug 11 05:55:08 CST 2023
Thread[pool-1-thread-5,5,main]完成,时间:Fri Aug 11 05:55:08 CST 2023
Thread[pool-1-thread-3,5,main]完成,时间:Fri Aug 11 05:55:08 CST 2023
Thread[pool-1-thread-4,5,main]完成,时间:Fri Aug 11 05:55:08 CST 2023
Thread[pool-1-thread-2,5,main]完成,时间:Fri Aug 11 05:55:08 CST 2023
Thread[pool-1-thread-4,5,main]完成,时间:Fri Aug 11 05:55:13 CST 2023
Thread[pool-1-thread-5,5,main]完成,时间:Fri Aug 11 05:55:13 CST 2023
Thread[pool-1-thread-2,5,main]完成,时间:Fri Aug 11 05:55:13 CST 2023
Thread[pool-1-thread-6,5,main]完成,时间:Fri Aug 11 05:55:13 CST 2023

可以看到我们在主线程也产生了阻塞,那么我们把阻塞时间给换一下,看看会发生啥(qwq,就是玩儿)

这个时候的输出如下

Thread[pool-1-thread-1,5,main]完成,时间:Fri Aug 11 05:56:43 CST 2023
Thread[main,5,main]完成,时间:Fri Aug 11 05:56:43 CST 2023
Thread[pool-1-thread-4,5,main]完成,时间:Fri Aug 11 05:56:43 CST 2023
Thread[pool-1-thread-6,5,main]完成,时间:Fri Aug 11 05:56:43 CST 2023
Thread[pool-1-thread-3,5,main]完成,时间:Fri Aug 11 05:56:43 CST 2023
Thread[pool-1-thread-5,5,main]完成,时间:Fri Aug 11 05:56:43 CST 2023
Thread[pool-1-thread-2,5,main]完成,时间:Fri Aug 11 05:56:43 CST 2023
Thread[pool-1-thread-3,5,main]完成,时间:Fri Aug 11 05:56:45 CST 2023
Thread[pool-1-thread-4,5,main]完成,时间:Fri Aug 11 05:56:45 CST 2023
Thread[pool-1-thread-2,5,main]完成,时间:Fri Aug 11 05:56:45 CST 2023
Thread[pool-1-thread-5,5,main]完成,时间:Fri Aug 11 05:56:45 CST 2023
Thread[pool-1-thread-6,5,main]完成,时间:Fri Aug 11 05:56:45 CST 2023
Thread[pool-1-thread-1,5,main]完成,时间:Fri Aug 11 05:56:45 CST 2023
Thread[pool-1-thread-2,5,main]完成,时间:Fri Aug 11 05:56:47 CST 2023
Thread[pool-1-thread-4,5,main]完成,时间:Fri Aug 11 05:56:47 CST 2023
Thread[pool-1-thread-3,5,main]完成,时间:Fri Aug 11 05:56:47 CST 2023
Thread[pool-1-thread-1,5,main]完成,时间:Fri Aug 11 05:56:47 CST 2023
Thread[pool-1-thread-5,5,main]完成,时间:Fri Aug 11 05:56:48 CST 2023

其实这里也可以看到,lambda表达式其实就是将函数封装成接口,但是让我们用函数的方法来书写,方便看,然后直接传入,其实任务的提交很快,先提交,再消费,所以说主线程就算阻塞了也不会影响其他线程的运行

其实出了execute以外还有一个方法。

executorService.submit

这里有一个submit和一个execute,有什么区别呢?

submit会有一个Futrue\<?>的返回值,我们可以通过Futrue\<T>.get()来获取T类型的返回值,来看看演示吧

我们稍微改一下循环

        while (i++<3){
            int j=0;
            while(j++<6){
                int finalJ = j;
                Future<?> submit = executorService.submit(() -> {
                    Thread thread = Thread.currentThread();
                    System.out.println(thread + "完成,时间:" + new Date());
                    try {
                        if (!thread.equals(local)) {
                            Thread.sleep(5000);
                        } else {
                            Thread.sleep(2000);
                        }
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    return finalJ;
                });
                System.out.println(String.valueOf(i)+","+submit.get()+",时间:"+new Date());
            }

运行结果

Thread[pool-1-thread-1,5,main]完成,时间:Fri Aug 11 06:18:10 CST 2023
1,1,时间:Fri Aug 11 06:18:15 CST 2023
Thread[pool-1-thread-2,5,main]完成,时间:Fri Aug 11 06:18:15 CST 2023
1,2,时间:Fri Aug 11 06:18:20 CST 2023
Thread[pool-1-thread-3,5,main]完成,时间:Fri Aug 11 06:18:20 CST 2023
1,3,时间:Fri Aug 11 06:18:25 CST 2023
Thread[pool-1-thread-1,5,main]完成,时间:Fri Aug 11 06:18:25 CST 2023
1,4,时间:Fri Aug 11 06:18:30 CST 2023
Thread[pool-1-thread-2,5,main]完成,时间:Fri Aug 11 06:18:30 CST 2023
1,5,时间:Fri Aug 11 06:18:35 CST 2023
Thread[pool-1-thread-3,5,main]完成,时间:Fri Aug 11 06:18:35 CST 2023
1,6,时间:Fri Aug 11 06:18:40 CST 2023
Thread[pool-1-thread-1,5,main]完成,时间:Fri Aug 11 06:18:40 CST 2023
2,1,时间:Fri Aug 11 06:18:45 CST 2023
Thread[pool-1-thread-2,5,main]完成,时间:Fri Aug 11 06:18:45 CST 2023
2,2,时间:Fri Aug 11 06:18:50 CST 2023
Thread[pool-1-thread-3,5,main]完成,时间:Fri Aug 11 06:18:50 CST 2023
2,3,时间:Fri Aug 11 06:18:55 CST 2023
Thread[pool-1-thread-1,5,main]完成,时间:Fri Aug 11 06:18:55 CST 2023
2,4,时间:Fri Aug 11 06:19:00 CST 2023
Thread[pool-1-thread-2,5,main]完成,时间:Fri Aug 11 06:19:00 CST 2023
2,5,时间:Fri Aug 11 06:19:05 CST 2023
Thread[pool-1-thread-3,5,main]完成,时间:Fri Aug 11 06:19:05 CST 2023
2,6,时间:Fri Aug 11 06:19:10 CST 2023
Thread[pool-1-thread-1,5,main]完成,时间:Fri Aug 11 06:19:10 CST 2023
3,1,时间:Fri Aug 11 06:19:15 CST 2023
Thread[pool-1-thread-2,5,main]完成,时间:Fri Aug 11 06:19:15 CST 2023
3,2,时间:Fri Aug 11 06:19:20 CST 2023
Thread[pool-1-thread-3,5,main]完成,时间:Fri Aug 11 06:19:20 CST 2023
...

通过调试,发现get方法是阻塞的,没错和上面FutrueTask一样,因为它们都实现于Futrue接口,当然各自也有实现。

那么这里我们如何才能异步获取结果而不印象主线程的运行呢,把Futrue放在一个数组里面就可以了,哈哈。

这里其实也有一些小细节,看代码都能理解,但还是得根据实际来解释

public class ThreadpoolApplication {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        int corePoolSize=3;
        int maximumPoolSize=6;
        long keepAliveTime=7000L;
        TimeUnit unit=TimeUnit.MILLISECONDS;
        BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue<>(10);
        ExecutorService executorService = new ThreadPoolExecutor(corePoolSize,
                maximumPoolSize,
                keepAliveTime,
                unit,
                workQueue,new ThreadPoolExecutor.CallerRunsPolicy());
        int i=0;
        Thread local=Thread.currentThread();
        List<List<Future>> list=new ArrayList<>();
        list.add(new ArrayList<>());
        System.out.println("任务提交开始,时间:"+new Date().getTime());
        while (i++<3){
            list.add(new ArrayList<>());
            int j=0;
            while(j++<6){
                int finalJ = j;
                int finalI1 = i;
                System.out.println(finalI1 +","+finalJ+","+Thread.currentThread()+"提交,时间:" + new Date().getTime());
                Future<?> submit = executorService.submit(() -> {
                    Thread thread = Thread.currentThread();
                    try {
                        System.out.println(finalI1 +","+finalJ+","+thread +"开始处理,时间:" + new Date().getTime());
                        if (!thread.equals(local)) {
                            Thread.sleep(5000);
                        } else {
                            Thread.sleep(2000);
                        }
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    } finally {
                        System.out.println(finalI1 +","+finalJ+","+thread + "完成,时间:" + new Date().getTime());
                    }
                    return finalJ;
                });
                list.get(i).add(submit);
            }
        }
        System.out.println("任务提交完成,时间:"+new Date().getTime());
        for (i=1;i<list.size();i++){
            int finalI = i;
            list.get(i).forEach(v->{
                try {
                    System.out.println(finalI+","+v.get()+",获取结果,时间:"+new Date().getTime());
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } catch (ExecutionException e) {
                    throw new RuntimeException(e);
                }
            });
        }
    }
}

来看看结果(时间戳前面的几位1691710我就删了,都一样,懒得看)

任务提交开始,时间:1691713108082
1,1,Thread[main,5,main]提交,时间:1691713108082
1,2,Thread[main,5,main]提交,时间:1691713108161
1,3,Thread[main,5,main]提交,时间:1691713108161
1,1,Thread[pool-1-thread-1,5,main]开始处理,时间:1691713108161
1,2,Thread[pool-1-thread-2,5,main]开始处理,时间:1691713108161
1,4,Thread[main,5,main]提交,时间:1691713108161
1,5,Thread[main,5,main]提交,时间:1691713108161
1,6,Thread[main,5,main]提交,时间:1691713108162
1,3,Thread[pool-1-thread-3,5,main]开始处理,时间:1691713108162
2,1,Thread[main,5,main]提交,时间:1691713108162
2,2,Thread[main,5,main]提交,时间:1691713108162
2,3,Thread[main,5,main]提交,时间:1691713108162
2,4,Thread[main,5,main]提交,时间:1691713108162
2,5,Thread[main,5,main]提交,时间:1691713108162
2,6,Thread[main,5,main]提交,时间:1691713108162
3,1,Thread[main,5,main]提交,时间:1691713108162
3,2,Thread[main,5,main]提交,时间:1691713108162
3,3,Thread[main,5,main]提交,时间:1691713108163
3,4,Thread[main,5,main]提交,时间:1691713108163
3,2,Thread[pool-1-thread-4,5,main]开始处理,时间:1691713108163
3,5,Thread[main,5,main]提交,时间:1691713108163
3,5,Thread[main,5,main]开始处理,时间:1691713108163
3,3,Thread[pool-1-thread-5,5,main]开始处理,时间:1691713108163
3,4,Thread[pool-1-thread-6,5,main]开始处理,时间:1691713108163
3,5,Thread[main,5,main]完成,时间:1691713110163
3,6,Thread[main,5,main]提交,时间:1691713110163
3,6,Thread[main,5,main]开始处理,时间:1691713110163
3,6,Thread[main,5,main]完成,时间:1691713112164
任务提交完成,时间:1691713112164
1,1,Thread[pool-1-thread-1,5,main]完成,时间:1691713113162
1,2,Thread[pool-1-thread-2,5,main]完成,时间:1691713113162
1,1,获取结果,时间:1691713113162
1,4,Thread[pool-1-thread-1,5,main]开始处理,时间:1691713113162
1,5,Thread[pool-1-thread-2,5,main]开始处理,时间:1691713113162
1,2,获取结果,时间:1691713113162
1,3,Thread[pool-1-thread-3,5,main]完成,时间:1691713113163
1,6,Thread[pool-1-thread-3,5,main]开始处理,时间:1691713113163
1,3,获取结果,时间:1691713113163
3,2,Thread[pool-1-thread-4,5,main]完成,时间:1691713113164
3,4,Thread[pool-1-thread-6,5,main]完成,时间:1691713113164
3,3,Thread[pool-1-thread-5,5,main]完成,时间:1691713113164
2,2,Thread[pool-1-thread-6,5,main]开始处理,时间:1691713113164
2,1,Thread[pool-1-thread-4,5,main]开始处理,时间:1691713113164
2,3,Thread[pool-1-thread-5,5,main]开始处理,时间:1691713113164
1,4,Thread[pool-1-thread-1,5,main]完成,时间:1691713118163
1,5,Thread[pool-1-thread-2,5,main]完成,时间:1691713118163
2,4,Thread[pool-1-thread-1,5,main]开始处理,时间:1691713118163
1,4,获取结果,时间:1691713118163
2,5,Thread[pool-1-thread-2,5,main]开始处理,时间:1691713118163
1,5,获取结果,时间:1691713118163
1,6,Thread[pool-1-thread-3,5,main]完成,时间:1691713118164
2,6,Thread[pool-1-thread-3,5,main]开始处理,时间:1691713118164
1,6,获取结果,时间:1691713118164
2,1,Thread[pool-1-thread-4,5,main]完成,时间:1691713118165
2,3,Thread[pool-1-thread-5,5,main]完成,时间:1691713118165
2,2,Thread[pool-1-thread-6,5,main]完成,时间:1691713118165
2,1,获取结果,时间:1691713118165
3,1,Thread[pool-1-thread-4,5,main]开始处理,时间:1691713118165
2,2,获取结果,时间:1691713118165
2,3,获取结果,时间:1691713118165
2,4,Thread[pool-1-thread-1,5,main]完成,时间:1691713123164
2,5,Thread[pool-1-thread-2,5,main]完成,时间:1691713123164
2,4,获取结果,时间:1691713123164
2,5,获取结果,时间:1691713123164
2,6,Thread[pool-1-thread-3,5,main]完成,时间:1691713123165
2,6,获取结果,时间:1691713123165
3,1,Thread[pool-1-thread-4,5,main]完成,时间:1691713123166
3,1,获取结果,时间:1691713123166
3,2,获取结果,时间:1691713123166
3,3,获取结果,时间:1691713123166
3,4,获取结果,时间:1691713123166
3,5,获取结果,时间:1691713123166
3,6,获取结果,时间:1691713123166

从这个结果我们可以看出我们把全部把任务提交后任务,接下来我们跟着结果来分析一下

从上面可以看出

核心线程如下

  • pool-1-thread-1
  • pool-1-thread-2
  • pool-1-thread-3

临时线程

  • pool-1-thread-4

  • pool-1-thread-5

  • pool-1-thread-6

    这里为了方便看结果,我简单处理了下文本

任务提交开始,时间:08082
1,1,从【主线程】提交,时间:08082
1,2,从【主线程】提交,时间:08161
1,3,从【主线程】提交,时间:08161
1,1,在 【核心线程1】(线程1)开始处理,时间:08161
1,2,在 【核心线程2】(线程2)开始处理,时间:08161
# 后面的10个进程进入阻塞队列
1,4,从【主线程】提交,时间:08161
1,5,从【主线程】提交,时间:08161
1,6,从【主线程】提交,时间:08162
1,3,在 【核心线程3】(线程3)开始处理,时间:08162
2,1,从【主线程】提交,时间:08162
2,2,从【主线程】提交,时间:08162
2,3,从【主线程】提交,时间:08162
2,4,从【主线程】提交,时间:08162
2,5,从【主线程】提交,时间:08162
2,6,从【主线程】提交,时间:08162
3,1,从【主线程】提交,时间:08162
# 阻塞队列满了
3,2,从【主线程】提交,时间:08162
3,3,从【主线程】提交,时间:08163
3,4,从【主线程】提交,时间:08163
3,2,在 【临时线程1】(线程4)开始处理,时间:08163
3,5,从【主线程】提交,时间:08163       # 核心线程、阻塞队列、临时线程都满了,执行拒绝策略
3,5,从【主线程】开始处理,时间:08163    # 在 主线程 处理
3,3,在 【临时线程2】(线程5)开始处理,时间:08163
3,4,在 【临时线程3】(线程6)开始处理,时间:08163
3,5,从【主线程】完成,时间:10163
3,6,从【主线程】提交,时间:10163
3,6,从【主线程】开始处理,时间:10163
3,6,从【主线程】完成,时间:12164       # 注意,这里开始主线程的任务完了
任务提交完成,时间:12164
1,1,在 【核心线程1】(线程1)完成,时间:13162
1,2,在 【核心线程2】(线程2)完成,时间:13162
1,1,获取结果,时间:13162
1,4,在 【核心线程1】(线程1)开始处理,时间:13162
1,5,在 【核心线程2】(线程2)开始处理,时间:13162
1,2,获取结果,时间:13162
1,3,在 【核心线程3】(线程3)完成,时间:13163
1,6,在 【核心线程3】(线程3)开始处理,时间:13163
1,3,获取结果,时间:13163
3,2,在 【临时线程1】(线程4)完成,时间:13164   # 临时线程没有销毁又进入临时线程了
3,4,在 【临时线程3】(线程6)完成,时间:13164
3,3,在 【临时线程2】(线程5)完成,时间:13164
2,2,在 【临时线程3】(线程6)开始处理,时间:13164
2,1,在 【临时线程1】(线程4)开始处理,时间:13164
2,3,在 【临时线程2】(线程5)开始处理,时间:13164
1,4,在 【核心线程1】(线程1)完成,时间:18163
1,5,在 【核心线程2】(线程2)完成,时间:18163
2,4,在 【核心线程1】(线程1)开始处理,时间:18163
1,4,获取结果,时间:18163
2,5,在 【核心线程2】(线程2)开始处理,时间:18163
1,5,获取结果,时间:18163
1,6,在 【核心线程3】(线程3)完成,时间:18164
2,6,在 【核心线程3】(线程3)开始处理,时间:18164
1,6,获取结果,时间:18164
2,1,在 【临时线程1】(线程4)完成,时间:18165
2,3,在 【临时线程2】(线程5)完成,时间:18165
2,2,在 【临时线程3】(线程6)完成,时间:18165
2,1,获取结果,时间:18165
3,1,在 【临时线程1】(线程4)开始处理,时间:18165
2,2,获取结果,时间:18165
2,3,获取结果,时间:18165
2,4,在 【核心线程1】(线程1)完成,时间:23164
2,5,在 【核心线程2】(线程2)完成,时间:23164
2,4,获取结果,时间:23164
2,5,获取结果,时间:23164
2,6,在 【核心线程3】(线程3)完成,时间:23165
2,6,获取结果,时间:23165
3,1,在 【临时线程1】(线程4)完成,时间:23166
3,1,获取结果,时间:23166
3,2,获取结果,时间:23166
3,3,获取结果,时间:23166
3,4,获取结果,时间:23166
3,5,获取结果,时间:23166
3,6,获取结果,时间:23166

从上面可以看出当核心线程和临时线程同时存在,如果这个时候开始消费阻塞队列里的任务是,临时线程可以和核心线程一起处理,神奇!

核心线程会被销毁吗?

那么我们再来想想,这里我们如果没有任务进入的话,那么核心线程会不会销毁?

试一试。

我们来写一个方法,来获取线程池里面的信息

    public static void printThreadPloolInfo(ThreadPoolExecutor threadPoolExecutor){
        System.out.println("当前线程池大小:"+threadPoolExecutor.getPoolSize()+
                " 核心线程数:"+threadPoolExecutor.getCorePoolSize()+
                " 活跃线程数:"+threadPoolExecutor.getActiveCount());
    }

同样,修改一下线程池创建的代码

 ThreadPoolExecutor executorService = new ThreadPoolExecutor(corePoolSize,
                maximumPoolSize,
                keepAliveTime,
                unit,
                workQueue,new ThreadPoolExecutor.CallerRunsPolicy());

最后的代码:

public class ThreadpoolApplication {
    public static void printThreadPloolInfo(ThreadPoolExecutor threadPoolExecutor){
        System.out.println("当前线程池大小:"+threadPoolExecutor.getPoolSize()+
                " 核心线程数:"+threadPoolExecutor.getCorePoolSize()+
                " 活跃线程数:"+threadPoolExecutor.getActiveCount());
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        int corePoolSize=3;
        int maximumPoolSize=6;
        long keepAliveTime=7000L;
        TimeUnit unit=TimeUnit.MILLISECONDS;
        BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue<>(10);
        ThreadPoolExecutor executorService = new ThreadPoolExecutor(corePoolSize,
                maximumPoolSize,
                keepAliveTime,
                unit,
                workQueue,new ThreadPoolExecutor.CallerRunsPolicy());
        int i=0;
        Thread local=Thread.currentThread();
        List<List<Future>> list=new ArrayList<>();
        list.add(new ArrayList<>());
        System.out.println("任务提交开始,时间:"+new Date().getTime());
        while (i++<3){
            list.add(new ArrayList<>());
            int j=0;
            while(j++<6){
                int finalJ = j;
                int finalI1 = i;
                System.out.println(finalI1 +","+finalJ+","+Thread.currentThread()+"提交,时间:" + new Date().getTime());
                Future<?> submit = executorService.submit(() -> {
                    Thread thread = Thread.currentThread();
                    try {
                        System.out.println(finalI1 +","+finalJ+","+thread +"开始处理,时间:" + new Date().getTime());
                        if (!thread.equals(local)) {
                            Thread.sleep(5000);
                        } else {
                            Thread.sleep(2000);
                        }
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    } finally {
                        System.out.println(finalI1 +","+finalJ+","+thread + "完成,时间:" + new Date().getTime());
                    }
                    return finalJ;
                });
                list.get(i).add(submit);
            }
            printThreadPloolInfo(executorService);
        }
        System.out.println("任务提交完成,时间:"+new Date().getTime());
        for (i=1;i<list.size();i++){
            int finalI = i;
            list.get(i).forEach(v->{
                try {
                    System.out.println(finalI+","+v.get()+",获取结果,时间:"+new Date().getTime());
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } catch (ExecutionException e) {
                    throw new RuntimeException(e);
                }
            });
        }
        long current = new Date().getTime();
        while(true){
            printThreadPloolInfo(executorService);
            if(new Date().getTime()-current>10*1000)break;
            Thread.sleep(500);
        }
        return;
    }
}

结果:

任务提交开始,时间:1691722972284
1,1,Thread[main,5,main]提交,时间:1691722972284
1,2,Thread[main,5,main]提交,时间:1691722972339
1,1,Thread[pool-1-thread-1,5,main]开始处理,时间:1691722972339
1,3,Thread[main,5,main]提交,时间:1691722972339
1,2,Thread[pool-1-thread-2,5,main]开始处理,时间:1691722972339
1,4,Thread[main,5,main]提交,时间:1691722972339
1,5,Thread[main,5,main]提交,时间:1691722972339
1,6,Thread[main,5,main]提交,时间:1691722972339
1,3,Thread[pool-1-thread-3,5,main]开始处理,时间:1691722972339
当前线程池大小:3 核心线程数:3 活跃线程数:3
2,1,Thread[main,5,main]提交,时间:1691722972340
2,2,Thread[main,5,main]提交,时间:1691722972340
2,3,Thread[main,5,main]提交,时间:1691722972340
2,4,Thread[main,5,main]提交,时间:1691722972340
2,5,Thread[main,5,main]提交,时间:1691722972340
2,6,Thread[main,5,main]提交,时间:1691722972340
当前线程池大小:3 核心线程数:3 活跃线程数:3
3,1,Thread[main,5,main]提交,时间:1691722972340
3,2,Thread[main,5,main]提交,时间:1691722972340
3,3,Thread[main,5,main]提交,时间:1691722972340
3,2,Thread[pool-1-thread-4,5,main]开始处理,时间:1691722972340
3,4,Thread[main,5,main]提交,时间:1691722972340
3,3,Thread[pool-1-thread-5,5,main]开始处理,时间:1691722972341
3,5,Thread[main,5,main]提交,时间:1691722972341
3,5,Thread[main,5,main]开始处理,时间:1691722972341
3,4,Thread[pool-1-thread-6,5,main]开始处理,时间:1691722972341
3,5,Thread[main,5,main]完成,时间:1691722974341
3,6,Thread[main,5,main]提交,时间:1691722974341
3,6,Thread[main,5,main]开始处理,时间:1691722974341
3,6,Thread[main,5,main]完成,时间:1691722976342
当前线程池大小:6 核心线程数:3 活跃线程数:6
任务提交完成,时间:1691722976342
1,2,Thread[pool-1-thread-2,5,main]完成,时间:1691722977340
1,3,Thread[pool-1-thread-3,5,main]完成,时间:1691722977340
1,1,Thread[pool-1-thread-1,5,main]完成,时间:1691722977340
1,4,Thread[pool-1-thread-3,5,main]开始处理,时间:1691722977340
1,5,Thread[pool-1-thread-2,5,main]开始处理,时间:1691722977340
1,1,获取结果,时间:1691722977340
1,6,Thread[pool-1-thread-1,5,main]开始处理,时间:1691722977340
1,2,获取结果,时间:1691722977340
1,3,获取结果,时间:1691722977340
3,4,Thread[pool-1-thread-6,5,main]完成,时间:1691722977342
3,2,Thread[pool-1-thread-4,5,main]完成,时间:1691722977342
2,2,Thread[pool-1-thread-4,5,main]开始处理,时间:1691722977342
3,3,Thread[pool-1-thread-5,5,main]完成,时间:1691722977342
2,1,Thread[pool-1-thread-6,5,main]开始处理,时间:1691722977342
2,3,Thread[pool-1-thread-5,5,main]开始处理,时间:1691722977342
1,5,Thread[pool-1-thread-2,5,main]完成,时间:1691722982340
1,6,Thread[pool-1-thread-1,5,main]完成,时间:1691722982340
1,4,Thread[pool-1-thread-3,5,main]完成,时间:1691722982340
2,5,Thread[pool-1-thread-1,5,main]开始处理,时间:1691722982340
2,4,Thread[pool-1-thread-2,5,main]开始处理,时间:1691722982340
1,4,获取结果,时间:1691722982340
2,6,Thread[pool-1-thread-3,5,main]开始处理,时间:1691722982340
1,5,获取结果,时间:1691722982340
1,6,获取结果,时间:1691722982340
2,2,Thread[pool-1-thread-4,5,main]完成,时间:1691722982342
2,1,Thread[pool-1-thread-6,5,main]完成,时间:1691722982342
3,1,Thread[pool-1-thread-4,5,main]开始处理,时间:1691722982342
2,1,获取结果,时间:1691722982342
2,3,Thread[pool-1-thread-5,5,main]完成,时间:1691722982342
2,2,获取结果,时间:1691722982342
2,3,获取结果,时间:1691722982342
2,6,Thread[pool-1-thread-3,5,main]完成,时间:1691722987341
2,4,Thread[pool-1-thread-2,5,main]完成,时间:1691722987341
2,4,获取结果,时间:1691722987341
2,5,Thread[pool-1-thread-1,5,main]完成,时间:1691722987341
2,5,获取结果,时间:1691722987341
2,6,获取结果,时间:1691722987341
3,1,Thread[pool-1-thread-4,5,main]完成,时间:1691722987343
3,1,获取结果,时间:1691722987343
3,2,获取结果,时间:1691722987343
3,3,获取结果,时间:1691722987343
3,4,获取结果,时间:1691722987343
3,5,获取结果,时间:1691722987343
3,6,获取结果,时间:1691722987343
当前线程池大小:6 核心线程数:3 活跃线程数:0
当前线程池大小:6 核心线程数:3 活跃线程数:0
当前线程池大小:6 核心线程数:3 活跃线程数:0
当前线程池大小:6 核心线程数:3 活跃线程数:0
当前线程池大小:4 核心线程数:3 活跃线程数:0
当前线程池大小:4 核心线程数:3 活跃线程数:0
当前线程池大小:4 核心线程数:3 活跃线程数:0
当前线程池大小:4 核心线程数:3 活跃线程数:0
当前线程池大小:3 核心线程数:3 活跃线程数:0
当前线程池大小:3 核心线程数:3 活跃线程数:0
当前线程池大小:3 核心线程数:3 活跃线程数:0

我们处理一下

当前线程池大小:3 核心线程数:3 活跃线程数:3
当前线程池大小:6 核心线程数:3 活跃线程数:6
当前线程池大小:6 核心线程数:3 活跃线程数:0
当前线程池大小:6 核心线程数:3 活跃线程数:0
当前线程池大小:6 核心线程数:3 活跃线程数:0
当前线程池大小:6 核心线程数:3 活跃线程数:0
当前线程池大小:4 核心线程数:3 活跃线程数:0
当前线程池大小:4 核心线程数:3 活跃线程数:0
当前线程池大小:4 核心线程数:3 活跃线程数:0
当前线程池大小:4 核心线程数:3 活跃线程数:0
当前线程池大小:3 核心线程数:3 活跃线程数:0
当前线程池大小:3 核心线程数:3 活跃线程数:0
当前线程池大小:3 核心线程数:3 活跃线程数:0

可以看到,核心线程并不会被销毁,所谓核心线程,只是保证了线程池的最小线程数而已。

那么核心线程能否被回收呢?

我们可以看到构造器中有一个方法

executorService.allowCoreThreadTimeOut(true);

那我们开启试一试

我们会看到最后又有新的东西出现

当前线程池大小:4 核心线程数:3 活跃线程数:0
当前线程池大小:4 核心线程数:3 活跃线程数:0
当前线程池大小:4 核心线程数:3 活跃线程数:0
当前线程池大小:0 核心线程数:3 活跃线程数:0
当前线程池大小:0 核心线程数:3 活跃线程数:0
当前线程池大小:0 核心线程数:3 活跃线程数:0
当前线程池大小:0 核心线程数:3 活跃线程数:0

这里也就是说corePool只是一个阙值,用户可以自定义是否销毁还是不销毁。

核心线程只是按照开发者的想法起的一个名称而已,和临时线程没有什么区别。

那么线程存放在哪里的呢?

线程的存放——深入剖析ThreadPoolExecutor源码

这个地方我们跟随源代码来看一看。

我们在ThreadPoolExecutor的源码里面发现了一个东西

    /**
     * Set containing all worker threads in pool. Accessed only when
     * holding mainLock.
     */
    private final HashSet<Worker> workers = new HashSet<Worker>();

看到没有,线程其实是存放在一个HashSet里面去的

我们来看看submit和execute

submit()和execute()

  protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }

public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask); // submit也会交给execute进行处理
        return ftask;
    }
class Integer{
    /**
     * The number of bits used to represent an {@code int} value in two's
     * complement binary form.
     *
     * @since 1.5
     */
    @Native public static final int SIZE = 32;
}

/**

主要的池控制状态ctl是一个原子整数,包含两个概念字段:

workerCount,表示有效线程数。
runState,表示运行状态,关闭状态等。

**/

// 运行状态存储在高位比特中
/***
RUNNING:运行中的状态,所有线程都可接受新任务。
SHUTDOWN:关闭状态,不再接受新任务,但会处理已排队的任务。
STOP:停止状态,不再接受新任务,不处理已排队的任务,且会中断正在执行的任务。
TIDYING:整理状态,所有任务已终止,线程池正在清理资源。
TERMINATED:终止状态,线程池已经终止,所有任务已完成。
***/
private static final int COUNT_BITS = Integer.SIZE - 3;

// 这个地方参考HashMap如何通过哈希寻找位置,COUNT_BITS是哈希掩码,https://www.wzl1.top/2023/07/21/996/
// 看到这里你以为是这样?放屁!还记得计算机网络如何通过网络掩码来计算网络号和主机号吗?这个就是相似的原理
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

private static int workerCountOf(int c)  { return c & CAPACITY; }

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {   // 当前任务数量小于核心线程数
            if (addWorker(command, true))   // 将任务加入到核心线程池里面
                return;
            c = ctl.get();           
            /**
                private static boolean isRunning(int c) {
                         return c < SHUTDOWN;
                }
            **/
            // 判断运行状态,并且加入阻塞队列
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false); // 那我不执行,没问题吧,具体的addworker代码看后文
        }
        else if (!addWorker(command, false))//阻塞队列满了,启动非核心
            reject(command);
    }

    private volatile RejectedExecutionHandler handler;

    final void reject(Runnable command) {
        handler.rejectedExecution(command, this);   // 拒绝策略
    }

    // 拒绝策略的实现就看上面了
    public interface RejectedExecutionHandler {
       void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
    }

我们再来看看addWork

addWork()

/*
runState提供了主要的生命周期控制,可以取以下值:

RUNNING:接受新任务并处理排队的任务。
SHUTDOWN:不接受新任务,但处理排队的任务。
STOP:不接受新任务,不处理排队的任务,并中断正在进行的任务。
TIDYING:所有任务已终止,workerCount为零,转换到TIDYING状态的线程将运行terminated()钩子方法。
TERMINATED:terminated()已完成。
这些值之间的数值顺序很重要,以允许有序比较。runState随时间单调递增,但不必达到每个状态。转换如下:

RUNNING -> SHUTDOWN:调用shutdown()时,可能隐式地在finalize()中调用。
(RUNNING或SHUTDOWN) -> STOP:调用shutdownNow()时。
SHUTDOWN -> TIDYING:队列和池都为空时。
STOP -> TIDYING:池为空时。
TIDYING -> TERMINATED:完成了terminated()钩子方法。
*/

private static final int RUNNING    = -1 << COUNT_BITS;       // 运行
private static final int SHUTDOWN   =  0 << COUNT_BITS;       // 关闭
private static final int STOP       =  1 << COUNT_BITS;       // 暂停
private static final int TIDYING    =  2 << COUNT_BITS;       // 整理
private static final int TERMINATED =  3 << COUNT_BITS;       // 终止

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    // Packing and unpacking ctl
    // CAPACITY = 00000000011111111111111111(前面自动补零,有30个左右的零,后面的1同理)
    private static int runStateOf(int c)     { return c & ~CAPACITY; }      // 取高位
    private static int workerCountOf(int c)  { return c & CAPACITY; }       // 取低位
    private static int ctlOf(int rs, int wc) { return rs | wc; }            // 合并

    private boolean compareAndIncrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect + 1);
    }

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);         // 获取运行状态

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))  
                // 如果不再接受任务的状态,并且满足下面条件之一直接return false
                // 1. 当前状态不是shutdown (shutdown都不是了,那么我也不能接受新的任务)
                // 2. firstTask不为空  (在这个条件满足之前,一定会满足为非运行态并且是shutdown状态,虽然你不会空,但是我也无法接受任务了啊)
                // 3. workQueue为空(好好好,shutdown状态,firstTask为空,这个时候没有workQueue了,那么我也不用处理了对不对)
                // rs != shutdown || firstTask != null || workQueue.isEmpty()
                // 唯一能够进行下去的就是, rs是shutdown的状态,fitstTask为空,并且有任务可以处理
                return false;

            for (;;) {
                int wc = workerCountOf(c);      // 获取任务数量
                if (wc >= CAPACITY ||            // OOM溢出,CAPACITY虽然是掩码,每一位为1,那么是不是可以看成任务数量的最大值
                    wc >= (core ? corePoolSize : maximumPoolSize))   // 加入核心线程还是临时线程
                    return false;
                if (compareAndIncrementWorkerCount(c))  // 如果这个时候c的值没有变化,那么自增(CAS乐观锁)
                    break retry;    // 语法糖,跳出retry,的所有循环,直接进入try那里,和goto类似,你在这里可以看作是对外层循环的控制
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)    // 运行状态改变,重试
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);      // 新建一个work
            /**
            这里是构造函数,内部使用的工厂模式来创建的线程
          Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

            **/
            final Thread t = w.thread;  // 获取线程
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get()); // 再次看运行状态

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);     // 放入work集合
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;    // 修改最大线程数
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();      // 执行线程
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

对于Worker,来说,有一个现成制造工厂,其实我们可以在线程池创建的时候去设定,这里我们看看默认工厂是如何实现的

DefaultThreadFactor

static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                      poolNumber.getAndIncrement() +
                     "-thread-";
    }

    public Thread newThread(Runnable r) {
        // 在这里,我们把runnable传进去的
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        if (t.isDaemon())
            t.setDaemon(false); // 默认模式不开启守护线程
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

而这里的r,我们从worker里面传入的是this

 Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

我这里直接把Worker这个类给放出来

Worker

private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{
    /**
     * This class will never be serialized, but we provide a
     * serialVersionUID to suppress a javac warning.
     */
    private static final long serialVersionUID = 6138294804551838833L;

    /** Thread this worker is running in.  Null if factory fails. */
    final Thread thread;
    /** Initial task to run.  Possibly null. */
    Runnable firstTask;
    /** Per-thread task counter */
    volatile long completedTasks;

    /**
     * Creates with given first task and thread from ThreadFactory.
     * @param firstTask the first task (null if none)
     */
    Worker(Runnable firstTask) {
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }

    /** Delegates main run loop to outer runWorker  */
    public void run() {
        runWorker(this);
    }

    // Lock methods
    //
    // The value 0 represents the unlocked state.
    // The value 1 represents the locked state.

    protected boolean isHeldExclusively() {
        return getState() != 0;
    }

    protected boolean tryAcquire(int unused) {
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }

    protected boolean tryRelease(int unused) {
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
    }

    public void lock()        { acquire(1); }
    public boolean tryLock()  { return tryAcquire(1); }
    public void unlock()      { release(1); }
    public boolean isLocked() { return isHeldExclusively(); }

    void interruptIfStarted() {
        Thread t;
        if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
            try {
                t.interrupt();
            } catch (SecurityException ignore) {
            }
        }
    }
}

既然是这样,那么t.start()一定会调用run()方法,我们再来看看runWoker(this)

runWokrer()

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread(); // 获取当前线程信息
    Runnable task = w.firstTask;        // 获取当前Worker任务
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        // 从当前的worker里面获取,或者从workQueue里面获取
        while (task != null || (task = getTask()) != null) {
            w.lock();
            // If pool is stopping, ensure thread is interrupted;
            // if not, ensure thread is not interrupted.  This
            // requires a recheck in second case to deal with
            // shutdownNow race while clearing interrupt
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    task.run();         // 执行这个任务
                } catch (RuntimeException x) {
                    thrown = x; throw x;
                } catch (Error x) {
                    thrown = x; throw x;
                } catch (Throwable x) {
                    thrown = x; throw new Error(x);
                } finally {
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

好了,现在我们知道大概的调用流程了

submit()->execute()->addWorker()->new Worker()->t=worker.thread=ThreadFactory.newThread(this)->t.start()执行worker.run()->runwark(this)->this.task.run()

总得来说就是把当前任务交给了worker来进行代理,那么阻塞队列的消费呢?上面的逻辑是在addWorker成功的情况下,如果失败了,就放在workQueue里面,那个offer()方法(祝大家拿到心仪的offer),然后我们在addWorker(null)。

那么我们找找workQueue.take()在哪里。

getTask()

private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?

    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }

        int wc = workerCountOf(c);  // 获取线程数

        // Are workers subject to culling?
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize; // 判断可用线程是否有时间限制

        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }

        try {
            /**
            public E poll(long timeout, TimeUnit unit) throws 
        参数:此方法采用两个强制性参数:
            timeout–等待的时间,以单位为单位。
            unit–超时参数的TimeUnit。
        返回值:此方法从此LinkedBlockingQueue的头部检索并删除元素,如果在元素可用之前经过了指定的等待时间,则为null。
        异常:如果在等待元素可用时方法被中断,则此方法将引发InterruptedException。
            **/
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :   //如果我们等待任务的时间都已经超过了线程存活时间,那么也没有必要                                                                          处理了,直接处理null就行
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

那么在那里又用到了getTask()呢?

哦,是runWorker(),也就是是说上面我们的流程又要变一下了。

submit()->execute()->addWorker()(如果添加失败的话放入队列,addWorker(null))->new Worker()->t=worker.thread=ThreadFactory.newThread(this)->t.start()执行worker.run()->runwark(this) (如果task是null的话从阻塞队列里面拿队首的来执行)->this.task.run()

那么问题又来了,我们是如何保证一定是被指定的线程执行的呢?

这就要从我们的线程是从哪里来的说起,我们创建线程的时候是在addWorker()方法,然后通过线程工厂,但是默认线程工厂的代码及其简单,给我感觉很强的应该是里面的ThreadGroup,我们看看什么时候用到了。

原来是构造函数

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), handler);
}

再来回顾下DefaultThreadFactor

static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                      poolNumber.getAndIncrement() +
                     "-thread-";
    }

    public Thread newThread(Runnable r) {
        // 在这里,我们把runnable传进去的
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        if (t.isDaemon())
            t.setDaemon(false); // 默认模式不开启守护线程
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

那么好吧,我们继续看看ThreadGroup

ThreadGroup

这一块就是Java SE的内容了,不做过多的阐述

public class ThreadGroup implements Thread.UncaughtExceptionHandler {
    private final ThreadGroup parent;
    String name;
    int maxPriority;
    boolean destroyed;
    boolean daemon;
    boolean vmAllowSuspension;

    int nUnstartedThreads = 0;
    int nthreads;
    Thread threads[];

    int ngroups;
    ThreadGroup groups[];

    ... // 忽略其他方法
}

原来这里秒你就有一个线程数组,那么ThreadGroup哪里有用?

Thread的一个构造方法

public Thread(ThreadGroup group, Runnable target, String name,
              long stackSize) {
    init(group, target, name, stackSize);
}

我们再来看看init

private void init(ThreadGroup g, Runnable target, String name,
                  long stackSize) {
    init(g, target, name, stackSize, null, true);
}

private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }

        this.name = name;

        Thread parent = currentThread();
        SecurityManager security = System.getSecurityManager();
        if (g == null) {
            /* Determine if it's an applet or not */

            /* If there is a security manager, ask the security manager
               what to do. */
            if (security != null) {
                g = security.getThreadGroup();
            }

            /* If the security doesn't have a strong opinion of the matter
               use the parent thread group. */
            if (g == null) {
                g = parent.getThreadGroup();
            }
        }

        /* checkAccess regardless of whether or not threadgroup is
           explicitly passed in. */
        g.checkAccess();

        /*
         * Do we have the required permissions?
         */
        if (security != null) {
            if (isCCLOverridden(getClass())) {
                security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
            }
        }

        g.addUnstarted();
        // 对新的这个线程初始化
        this.group = g;
        this.daemon = parent.isDaemon();
        this.priority = parent.getPriority();
        if (security == null || isCCLOverridden(parent.getClass()))
            this.contextClassLoader = parent.getContextClassLoader();
        else
            this.contextClassLoader = parent.contextClassLoader;
        this.inheritedAccessControlContext =
                acc != null ? acc : AccessController.getContext();
        this.target = target;
        setPriority(priority);
        if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            this.inheritableThreadLocals =
                ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
        /* Stash the specified stack size in case the VM cares */
        this.stackSize = stackSize;

        /* Set thread ID */
        tid = nextThreadID();
    }

但是,你这只是说明了线程组啊,线程数量是在哪里限制的呢?addWork()

那么如何将任务退出的呢?

我们碰一碰processWorkerExit()吧

processWorkerExit()

private void processWorkerExit(Worker w, boolean completedAbruptly) {
    if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
        decrementWorkerCount();

    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        completedTaskCount += w.completedTasks;
        workers.remove(w);
    } finally {
        mainLock.unlock();
    }

    tryTerminate();

    int c = ctl.get();
    if (runStateLessThan(c, STOP)) {
        if (!completedAbruptly) {
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            if (min == 0 && ! workQueue.isEmpty())
                min = 1;
            if (workerCountOf(c) >= min)
                return; // replacement not needed
        }
        addWorker(null, false);
    }
}

从上面可以看出,线程池的本质其实是一直控制new的线程的数量,只不过线程的ID、名称一直没有变过,所以是给人一种只是切换任务的错觉。

Executors

另外JUC为我们提供了一个构造器Executors,之里面有几种线程池的实现,底层还是靠的new ThreadPoolExecutor(),但是《阿里巴巴开发手册》里面不建议这样做,这里还是简单的介绍一下。

Executors类,提供了一系列工厂方法用于创建线程池,返回的线程池都实现了ExecutorService接口。

newFiexedThreadPool(int Threads)

创建固定数目线程的线程池。

  • newFixedThreadPool与cacheThreadPool差不多,也是能reuse就用,但不能随时建新的线程。

  • 其独特之处:任意时间点,最多只能有固定数目的活动线程存在,此时如果有新的线程要建立,只能放在另外的队列中等待,直到当前的线程中某个线程终止直接被移出池子

  • 和cacheThreadPool不同,FixedThreadPool没有IDLE机制(可能也有,但既然文档没提,肯定非常长,类似依赖上层的TCP或UDP IDLE机制之类的),所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程,多用于服务器

  • 从方法的源代码看,cache池和fixed 池调用的是同一个底层池,只不过参数不同:
    fixed池线程数固定,并且是0秒IDLE(无IDLE)

    cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力),60秒IDLE

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>(),
                                      threadFactory);
    }

newCachedThreadPool()

创建一个可缓存的线程池,调用execute 将重用以前构造的线程(如果线程可用)。如果没有可用的线程,则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。

  • 缓存型池子,先查看池中有没有以前建立的线程,如果有,就 reuse.如果没有,就建一个新的线程加入池中
  • 缓存型池子通常用于执行一些生存期很短的异步型任务
    因此在一些面向连接的daemon型SERVER中用得不多。但对于生存期短的异步任务,它是Executor的首选。
  • 能reuse的线程,必须是timeout IDLE内的池中线程,缺省 timeout是60s,超过这个IDLE时长,线程实例将被终止及移出池。
    注意,放入CachedThreadPool的线程不必担心其结束,超过TIMEOUT不活动,其会自动被终止。
    public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
    }

    public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>(),
                                      threadFactory);
    }

newSingleThreadExecutor()

创建一个单线程化的Executor。

单例线程,任意时间池中只能有一个线程
用的是和cache池和fixed池相同的底层池,但线程数目是1-1,0秒IDLE(无IDLE)

    public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
    }

    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>(),
                                    threadFactory));
    }

newScheduledThreadPool(int corePoolSize)

创建一个支持定时及周期性的任务执行的线程池,多数情况下可用来替代Timer类。

调度型线程池

这个池子里的线程可以按schedule依次delay执行,或周期执行

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

    public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }

总结

线程池,总算是搞懂了,所谓的核心线程数,只是一个定界指针,而线程存活时间也是靠按照时间来获取任务来实现的。

而任务的执行,并不是靠更换线程的仍无,仍然是靠new线程, 当执行完了以后进行processWorkerExit()进行释放

同时大家也可以看到,这里面的阻塞队列,有多种实现,具体的各种实现我们下期再谈。

参考文章:

  • 微信或QQ扫一扫

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注

目录