【JAVA核心知识】14：JAVA线程池常用方法

最新推荐文章于 2024-04-04 21:49:01 发布

yue_hu

最新推荐文章于 2024-04-04 21:49:01 发布

阅读量697

点赞数 2

分类专栏： JAVA核心知识 JAVA 文章标签：多线程并发编程 thread java 面试

本文链接：https://blog.csdn.net/yue_hu/article/details/116295451

版权

JAVA 同时被 2 个专栏收录

85 篇文章 2 订阅

订阅专栏

JAVA核心知识

64 篇文章 4 订阅

订阅专栏

JAVA线程池常用方法

1 常用方法
- 1.1 基本线程池
- 1.2 定时线程池
2 代码示例
- 2.1 基本线程池
- 2.2定时线程池

上一篇【JAVA核心知识】13：一文看懂JAVA线程池，轻松应对面试中对线程池进行了剖析，了解线程池的核心参数与实现可以更清楚的了解每个方法所代表的意义。

1 常用方法

1.1 基本线程池

prestartCoreThread()：初始化一个核心线程；每次都是初始化一个，始化到最大核心线程数时就不再初始化新的了
getPoolSize()：获得当前线程量（包含核心线程和临时线程）
getCorePoolSize()：获得当前核心线程量
prestartAllCoreThreads()：初始化所有的核心线程
setMaximumPoolSize(int)：设置最大线程数
execute(Runnable)：提交一个任务
remove(Runnable)：移除一个待执行的任务
submit(Callable<T>)：提交一个带返回的任务
getActiveCount()：获取线程池中活动线程数量
getLargestPoolSize()：获取线程池中曾有过的最大线程量
getTaskCount()：包括正在执行的在内预计要执行的任务量，因为任务和线程的状态可能在计算过程中动态变化，返回的值只是一个近似值
getCompletedTaskCount()：线程池已完成任务量
allowsCoreThreadTimeOut()：返回超时空闲销毁时间是否针对核心线程(默认为false,即核心线程会一直保持)
allowCoreThreadTimeOut(boolean)：设置为true时不仅临时线程空闲时间超过keepAliveTime会被销毁，核心线程也会超时空闲销毁
purge()：将队列中已经取消的fature移除(fature可以取消Callable任务的执行)。这个方法不影响任何功能，只是相当于一个提前的垃圾处理操作(不调用这个方法线程池也会自动处理),这个方法可能因为其它线程影响导致失败
shutdown()：进入shutDown状态，不再接收新的任务
shutdownNow()：立即关闭线程池，中断当前线程被清空缓存队列
isTerminating()：是否处于Terminating状态。SHUTDOWN,STOP,TIDYING三种状态都返回true
isTerminated()：是否处于TERMINATED 状态
isShutdown()：注意不要被方法的名称所迷惑，并不是只有处于SHUTDOWN状态才返回TRUE，只要不是RUNNING状态都返回true
awaitTermination(long, TimeUnit)：awaitTermination方法只是一个监听方法，他不参与具体的线程池运行。他只是在调用这个方法之后等待指定时间，然后返回线程池是否已经关闭。true:已经关闭。 false:未关闭
invokeAll(Collection<? extends Callable<T>> ):把线程投入线程池并返回Future集合。Future结果集合的顺序和callList的顺序是一样的

1.2 定时线程池

因为定时线程池继承自基本线程池，且其底层任务执行通过基本线程池实现，因此具有基本线程池拥有的方法，除此之外，还拥有独属于定时线程池的方法：

scheduleAtFixedRate(Runnable,long,long,TimeUnit)：周期性的执行Runable(延迟时间以上一个任务开始时间开始计算eg：一个线程执行1s,周期为2s，那么它会在0,2,4,6…执行一个线程执行4s,周期为2s，那么它会在0,4,8,12…执行)
scheduleWithFixedDelay(Runnable,long,long,TimeUnit)：周期性的执行Runable(延迟时间以上一个任务结束时间开始算。eg：一个线程执行1s,周期为2s,那么它会在0,3,6,9…执行)
schedule(Runnable,long,TimeUnit)：// 延迟指定时间执行Runable
schedule(Callable<V>,long,TimeUnit)：延迟指定时间执行Callable并返回ScheduleFuture
setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean)：线程池关闭之后定时任务是否继续执行,包括scheduleAtFixedRate和scheduleWithFixedDelay。如果有周期任务线程池关闭之后会保持最大线程数(如果关闭时线程还未到达最大线程数依然会建立新线程)(默认false(true:继续，false:放弃))
setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean)：线程池关闭之后是否继续执行delay任务,如果只有延迟任务线程池关闭之后且这个延时任务执行后会销毁所有线程(默认true(true:继续，false:放弃))
setRemoveOnCancelPolicy(boolean)：设置是否在任务被取消之后立刻从队列中移出

2 代码示例

2.1 基本线程池

public class ThreadPoolExecutorTest {

    public static void main(String[] args) {

        /**
         * 构造方法
         */
        // 所有构造入参都可通过get方法获得，除阻塞队列外的其它几个可以通过set方法重置

        // 1参表示日常保持的线程数，
        // 2 表示任务来时间可以开启的最大线程数,值得注意的是临时线程的创建时间。不是核心线程都处于运行状态来新任务时创建，而是核心线程都被占用，且队列被占满，此时来新任务才会创建临时线程
        // 3.4参表示一个非核心线程空闲多久之后会被销毁
        // 5参：用来放等待任务的阻塞队列(BlockingQueue)
        //
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 6, 100, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>());
        // threadPool.prestartCoreThread(); // 初始化一个核心线程；
        // System.out.println(threadPool.getPoolSize()); // 1
        // threadPool.prestartCoreThread(); // 初始化一个核心线程；每次都是初始化一个
        // System.out.println(threadPool.getPoolSize()); // 2
        // threadPool.prestartCoreThread(); // 初始化一个核心线程；初始化到最大核心线程数时就不再初始化新的了
        // System.out.println(threadPool.getPoolSize()); // 2
        // System.out.println(threadPool.getCorePoolSize()); // 2
        // threadPool.prestartAllCoreThreads(); // 初始化所有核心线程
        // System.out.println(threadPool.getCorePoolSize()); // 2
        threadPool.setMaximumPoolSize(10); // 设置最大线程数
        // 构造方法2 6参为线程创建工厂 默认为Executors.defaultThreadFactory()
        ThreadPoolExecutor threadPool2 = new ThreadPoolExecutor(3, 5, 100, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(), Executors.defaultThreadFactory());
        // 构造方法3 6参为拒绝策略，有4种, 一般是定长队列，当运行线程数达到最大线程数且线程缓存队列已满，此时依然有线程抛入线程池。就会执行拒绝策略.默认拒绝策略为AbortPolicy
        // ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 拒绝执行异常，这里抛弃的是这个要加入线程池的任务
        // ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。这里抛弃的是这个要加入线程池的任务
        // ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）(注意：这里抛弃的不是这个要加入线程池的任务，而是线程池等待队列的首位，也就是线程池下一个要执行的任务。这里的实现是直接用e.getQueue().poll(),然后调用e.execute(r),r是要加入线程池的任务)
        // ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务
        ThreadPoolExecutor threadPool3 = new ThreadPoolExecutor(2, 5, 100, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(), new ThreadPoolExecutor.AbortPolicy());
        // 构造方法4 其它构造其实都通过调用此构造实现
        ThreadPoolExecutor threadPool4 = new ThreadPoolExecutor(2, 5, 100, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        ThreadPoolExecutor threadPool5 = new ThreadPoolExecutor(2, 5, 100, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(4)); // 这里设置成5不会拒绝执行抛出RejectedExecutionException
        // 原因是总共10线程，前两个占据核心线程，再来5个进入缓存队列，剩下3个则会创建临时线程来执行任务，因此不会溢出
        /**
         * 线程提交
         */
        for (int i = 0; i < 10; i++) {
            final int j = i;
            Runnable r = new Runnable() {

                @Override
                public void run() {
                    System.out.println(j + "开始运行...");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(j + "运行结束...");
                }
            };
            threadPool.execute(r); // ThreadPoolExecutor的线程是一个个建立的，在线程池里面的线程数尚未到达最大线程数时间新任务到了会优先创建新的线程来执行而不是使用空闲线程执行
        }

        Callable<String> call = new Callable<String>() {

            @Override
            public String call() throws Exception {
                System.out.println("Callable");
                Thread.sleep(1000);
                System.out.println("Callable Sleep End");
                return "This is Callable";
            }
        };
        // Future<String> f = threadPool.submit(call);// 可以提交Callable获得执行结果，这里就体现出submit和excute的区别了，submit可以获得返回
        // try {
        // Thread.sleep(500);
        // } catch (InterruptedException e) {
        // e.printStackTrace();
        // }
        // f.cancel(true); //
        // 取消Callable任务的执行，参数为true时如果任务已经在执行则会尝试中断这个任务，参数为false时如果任务已经在执行了则会允许它执行结束。取消之后再调用get方法会抛java.util.concurrent.CancellationException异常。
        // // 值得注意的是,即使参数设为false,且取消指令在Callable执行过程中调用。那么任务是会执行完,但是即使这样，调用get方法依然会抛出异常.
        // // 如这个地方，在Callable执行时取消，设为true时不会打印Callable Sleep End，false时会打印。但是之后的get方法都会报异常。
        // try {
        // System.out.println("the return of callable:" + f.get()); // 这里调用get会使主线程停止。future的主线程停止是在get这里而不是submit那里
        // } catch (InterruptedException e) {
        // e.printStackTrace();
        // } catch (ExecutionException e) {
        // e.printStackTrace();
        // }

        Runnable rno = new Runnable() {

            @Override
            public void run() {
                System.out.println("not need");
            }
        };
        threadPool.execute(rno); // 添加一个无需执行的任务
        threadPool.remove(rno); // 从等待队列中移除任务

        System.out.println("getPoolSize -- :" + threadPool.getPoolSize()); // 当前线程池中有多少线程
        System.out.println("getActiveCount -- :" + threadPool.getActiveCount()); // 线程池中活动线程数量
        System.out.println("getLargestPoolSize -- :" + threadPool.getLargestPoolSize()); // 线程池中曾有过的最大线程量
        System.out.println("getTaskCount -- :" + threadPool.getTaskCount()); // 包括正在执行的在内预计要执行的任务量，因为任务和线程的状态可能在计算过程中动态变化，返回的值只是一个近似值。
        System.out.println("getCompletedTaskCount -- :" + threadPool.getCompletedTaskCount()); // 线程池已完成多少任务
        System.out.println("allowCoreThreadTimeOut -- :" + threadPool.allowsCoreThreadTimeOut()); // 超时空闲销毁时间是否针对核心线程(默认为false,即核心线程会一直保持)
        threadPool.allowCoreThreadTimeOut(true);// 设置为true时不仅临时线程空闲时间超过keepAliveTime会被销毁，核心线程也会超时空闲销毁
        threadPool.purge(); // 将队列中已经取消的fature移除(fature可以取消Callable任务的执行)。这个方法不影响任何功能，只是相当于一个提前的垃圾处理操作(不调用这个方法线程池也会自动处理),这个方法可能因为其它线程影响导致失败。

        // threadPool.shutdown(); // 进入shutDown状态，不再接收新的任务
        // System.out.println("isTerminating()--:" + threadPool.isTerminating()); //
        // SHUTDOWN,STOP,TIDYING三种状态都返回true，这里会返回true。
        // try {
        // System.out.println("awaitTermination" + threadPool.awaitTermination(1, TimeUnit.SECONDS)); //
        // awaitTermination方法只是一个监听方法，他不参与具体的线程池运行。他只是在调用这个方法之后等待指定时间
        // //然后返回线程池是否已经关闭。true:已经关闭。 false:未关闭
        // } catch (InterruptedException e1) {
        // System.out.println("awaitTermination err");
        // e1.printStackTrace();
        // }

        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        threadPool.shutdown(); // 进入shutDown状态，不再接收新的任务。他会等待线程池中所有的任务都执行完毕
        // threadPool.shutdownNow(); // 立即关闭线程池，中断当前线程被清空缓存队列。
        Runnable rn = new Runnable() {

            @Override
            public void run() {
                System.out.println("new runnable");
            }
        };
        // threadPool.execute(rn); // 线程池已得到关闭指令，继续添加则根据拒绝策略执行响应操作

        System.out.println("isTerminating()--:" + threadPool.isTerminating()); // SHUTDOWN,STOP,TIDYING三种状态都返回true
        System.out.println("isTerminated()--:" + threadPool.isTerminated()); // TERMINATED 状态
        System.out.println("isShutdown()--:" + threadPool.isShutdown()); // 注意不要被方法的名称所迷惑，并不是只有处于SHUTDOWN状态才返回TRUE，只要不是RUNNING状态都返回true
        /*
         * ThreadPoolExecutor共有5种状态： RUNNING：接收新任务并处理队列中的任务 SHUTDOWN:不接受新任务，但是处理队列任务 STOP:不接受新任务，也不处理队列任务，并中断正在处理的任务。
         * TIDYING：清理状态。所有的任务已经结束，当前工作线程为0.此时会调用terminated()，terminated()状态执行期间 TERMINATED：terminated()方法执行完毕 状态转换条件：
         * RUNNING -> SHUTDOWN：调用shutDown()方法之后。或者是隐式的调用了protect级别的finalize()方法 (RUNNING or SHUTDOWN) ->
         * STOP：调用shutdownNow()方法之后 SHUTDOWN -> TIDYING：当队列线程池都为空 STOP -> TIDYING：线程池为空 TIDYING ->
         * TERMINATED：terminated()方法执行执行完毕
         */

        /** AbstractExecutorService方法 */
        System.out.println("start test AbstractExecutorService");
        List<Callable<String>> callList = new ArrayList<>();
        final AtomicInteger ai = new AtomicInteger();
        for (int i = 0; i < 10; i++) {
            final int j = i;
            Callable<String> callTemp = new Callable<String>() {
                @Override
                public String call() throws Exception {
                    System.out.println("Callable" + j);
                    Thread.sleep(1000);
                    System.out.println("Callable Sleep End" + j);
                    return "This is Callable" + j;
                }
            };
            callList.add(callTemp);
        }
        try {
            // for (int i = 0; i < 11; i++) {
            // System.out.println(threadPool2.invokeAny(callList)); //
            // 执行集合中的任意一条。一旦有一个任务执行完毕就会返回结果并取消其它线程。(个人认为这是一件很危险的事情：如果有A,B两个线程在这个集合，空闲线程大于2导致A,B共同执行，那么如果A执行完毕返回，B执行一半，那么B被取消，但是取消之后B前半部分造成的影响是无法回滚的！！！这需要注意)
            // Thread.sleep(1000);
            // }
            List<Future<String>> result = threadPool2.invokeAll(callList);// 把线程投入线程池并返回Future集合。List结果的顺序和callList的顺序是一样的
            for (Future<String> future : result) {
                System.out.println(future.get());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

2.2定时线程池

public class ScheduledThreadPoolExecutorDemo {

    public static void main(String[] args) {
        
        /**
         * public class ScheduledThreadPoolExecutor
         *   extends ThreadPoolExecutor
         *   implements ScheduledExecutorService
         */
        ScheduledThreadPoolExecutor ScheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);
        /**public ScheduledThreadPoolExecutor(int corePoolSize) {
            super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
                  new DelayedWorkQueue());
            }*/
        ScheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1, Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        /**public ScheduledThreadPoolExecutor(int corePoolSize,
                                       ThreadFactory threadFactory,
                                       RejectedExecutionHandler handler) {
            super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
                  new DelayedWorkQueue(), threadFactory, handler);*/
        ScheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1, Executors.defaultThreadFactory());
        /**public ScheduledThreadPoolExecutor(int corePoolSize,
                                       ThreadFactory threadFactory) {
            super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
                  new DelayedWorkQueue(), threadFactory);
            }*/
        ScheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(5, new ThreadPoolExecutor.CallerRunsPolicy());
        /**public ScheduledThreadPoolExecutor(int corePoolSize,
                                       RejectedExecutionHandler handler) {
            super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
                  new DelayedWorkQueue(), handler);
            }*/
        
        /**
        // 定义自己的拒绝策略
        new RejectedExecutionHandler() {
            
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                
            }
        };*/
        final AtomicInteger i = new AtomicInteger();
        Runnable run1 = new Runnable() {
            
            @Override
            public void run() {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("A第" + i.incrementAndGet() + "次执行!!!");
            }
        };

        final AtomicInteger i2 = new AtomicInteger();
        Runnable run2 = new Runnable() {
            
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("B第" + i2.incrementAndGet() + "次执行");
            }
        };
        
        final AtomicInteger i3 = new AtomicInteger();
        Runnable run3 = new Runnable() {
            
            @Override
            public void run() {
                System.out.println("C第" + i3.incrementAndGet() + "次执行");
            }
        };
        
        Callable<String> call1 = new Callable<String>() {
            
            @Override
            public String call() throws Exception {
                return "当前B: " + i2.get();
            }
        };
        
        
        // 线程池在没有到达最大线程数量时会优先创建新的线程来执行而不是使用空闲线程(eg：如果只有一个定时任务。一个线程执行1s,周期为2s,那么会在0,2,4...分别创建一个新线程，即使之前的线程有空闲的)
        // ps:这个是我根据现象做的猜测-定时任务的条件达成(本次队列执行开始或者本次队列执行完毕)之后并不是寻求新线程去进行运行,而是将其加入其维护的自身内部类(队列DelayedWorkQueue)里面。然后线程会从这个队列里面取出过期元素执行。
        //                    不过并不是和DelayQueue的阻塞取出方法一样如果第一个不过期会阻塞后面的过期的。他用peek取出元素并判断是否过期，直到找到第一个过期元素，实现了非阻塞且先进先过期元素先出的情况。
//        ScheduledThreadPoolExecutor.scheduleAtFixedRate(run1, 0, 1, TimeUnit.SECONDS);  // 周期性的执行Runable(延迟时间以上一个任务开始时间开始计算eg：一个线程执行1s,周期为2s，那么它会在0,2,4,6...执行  一个线程执行4s,周期为2s，那么它会在0,4,8,12...执行)
        ScheduledThreadPoolExecutor.scheduleAtFixedRate(run2, 0, 1, TimeUnit.SECONDS);
//        ScheduledThreadPoolExecutor.scheduleWithFixedDelay(run2, 0, 5, TimeUnit.SECONDS);   // 周期性的执行Runable(延迟时间以上一个任务结束时间开始算。eg：一个线程执行1s,周期为2s,那么它会在0,3,6,9...执行)
        ScheduledThreadPoolExecutor.schedule(run3, 20, TimeUnit.SECONDS);    // 延迟指定时间执行Runable
        ScheduledFuture f = ScheduledThreadPoolExecutor.schedule(call1, 1, TimeUnit.SECONDS);   // 延迟指定时间执行Callable并返回ScheduleFuture
        ScheduledThreadPoolExecutor.getContinueExistingPeriodicTasksAfterShutdownPolicy(); // 默认false(true:继续，false:放弃)
        ScheduledThreadPoolExecutor.setContinueExistingPeriodicTasksAfterShutdownPolicy(true);  // 线程池关闭之后定时任务是否继续执行,包括scheduleAtFixedRate和scheduleWithFixedDelay。如果有周期任务线程池关闭之后会保持最大线程数(如果关闭时线程还未到达最大线程数依然会建立新线程)。
        ScheduledThreadPoolExecutor.getExecuteExistingDelayedTasksAfterShutdownPolicy();    // 默认true(true:继续，false:放弃)
        ScheduledThreadPoolExecutor.setExecuteExistingDelayedTasksAfterShutdownPolicy(true);    // 线程池关闭之后是否继续执行delay任务,如果只有延迟任务线程池关闭之后且这个延时任务执行后会销毁所有线程
        ScheduledThreadPoolExecutor.getRemoveOnCancelPolicy(); // 默认为false
        ScheduledThreadPoolExecutor.setRemoveOnCancelPolicy(true);  // 设置是否在任务被取消之后立刻从队列中移出
        try {
            System.out.println(f.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        try {
            Thread.sleep(10000);
            ScheduledThreadPoolExecutor.shutdown();
            System.out.println("shutdown end");
            Thread.sleep(20000);
            ScheduledThreadPoolExecutor.execute(run3);// shutdown之后再提交任务就会被拒绝(执行定义的拒绝策略)(也就是说setContinueExistingPeriodicTasksAfterShutdownPolicy和setExecuteExistingDelayedTasksAfterShutdownPolicy只负责线程关闭之前的任务)
        } catch (InterruptedException e) {
            System.out.println(1);
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } 
        
        System.out.println("isShutdown:" + ScheduledThreadPoolExecutor.isShutdown());
    }
}

PS：
【JAVA核心知识】系列导航 [持续更新中…]
上篇导航：13：一文看懂JAVA线程池，轻松应对面试
下篇导航：15.1：线程控制器CountDownLatch
欢迎关注…

yue_hu

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
4
评论
【JAVA核心知识】14：JAVA线程池常用方法

JAVA线程池常用方法1 常用方法1.1 基本线程池1.2 定时线程池2 代码示例2.1 基本线程池2.2定时线程池上一篇【JAVA核心知识】13：JAVA线程池解析中对线程池进行了剖析，了解线程池的核心参数与实现可以更清楚的了解每个方法所代表的意义。1 常用方法1.1 基本线程池prestartCoreThread()：初始化一个核心线程；每次都是初始化一个，始化到最大核心线程数时就不再初始化新的了getPoolSize()：获得当前线程量（包含核心线程和临时线程）getCorePoolS
复制链接

扫一扫