java线程池详解

最新推荐文章于 2024-10-08 15:07:49 发布

weixin_33881753

最新推荐文章于 2024-10-08 15:07:49 发布

阅读量65

点赞数

文章标签： java python 数据库

原文链接：https://my.oschina.net/suzheworld/blog/3004515

版权

2019独角兽企业重金招聘Python工程师标准>>>

ThreadPoolExecutor执行execute方法分下面4种情况。
1）如果当前运行的线程少于corePoolSize，则创建新线程来执行任务。

2）如果运行的线程等于或多于corePoolSize，则将任务加入BlockingQueue。

3）如果无法将任务加入BlockingQueue（队列已满），则创建新的线程来处理任务

4）如果创建新线程将使当前运行的线程超出maximumPoolSize，任务将被拒绝，并调用RejectedExecutionHandler.rejectedExecution()方法。

线程池的创建,首先看一下线程池的api

corePoolSize（线程池的基本大小）：当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建。如果调用了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有基本线程。

keepAliveTime（线程活动保持时间）：线程池的工作线程空闲后，保持存活的时间。所以，如果任务很多，并且每个任务执行的时间比较短，可以调大时间，提高线程的利用率。

TimeUnit（线程活动保持时间的单位）

maximumPoolSize（线程池最大数量）：线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。值得注意的是，如果使用了无界的任务队列这个参数就没什么效果。

workQueue（任务队列）：用于保存等待执行的任务的阻塞队列。可以选择以下几种队列。
ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按FIFO（先进先出）原则对元素进行排序。
LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。
SynchronousQueue：必须等队列中的添加元素被消费后才能继续添加新的元素。静态工厂方法Executors.newCachedThreadPool使用了这个队列。
PriorityBlockingQueue：一个具有优先级的无限阻塞队列。

RejectedExecutionHandler（饱和策略）：当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。Java线程池框架提供了以下4种策略。
AbortPolicy：直接抛出异常。
CallerRunsPolicy：只用调用者所在线程来运行任务。
DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
DiscardPolicy：不处理，丢弃掉。
当然，也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化存储不能处理的任务。

下面的程序，演示了线程的使用。首先创建一个线程池，并先向线程池提交了6个任务，1s后再次向线程池提交任务，线程池已饱和，拒绝了该次提交。

基于该拒绝机制，线程池可以实现限流，在高并发场景下，保护我们的mysql数据库资源。

   @Test
    public void test() throws Exception {
        //定义一个线程池 核心线程数为3，最大线程数为3，队列3 也就是说如果 有超过6个以上的任务就会拒绝
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 3,
                60, TimeUnit.SECONDS,
                new LinkedBlockingDeque<Runnable>(3), new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {

                throw new RejectedExecutionException(r.toString());
            }
        });
        for (int i = 0;i < 6;i++){
            threadPoolExecutor.execute(()->{
                try {
                    System.out.println(Thread.currentThread() + "正在运行");
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        Thread.sleep(1000);
        System.out.println("添加一个线程");
        threadPoolExecutor.execute(()->{
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.in.read();
    }

运行

线程池实现资源隔离，超时补偿。下面看一个简单的隔离，超时的例子。

   @Test
    public void test2() throws Exception {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3, 3,
                60, TimeUnit.SECONDS,
                new LinkedBlockingDeque<Runnable>(3), new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {

                throw new RejectedExecutionException(r.toString());
            }
        });

        Future<String> future = threadPoolExecutor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                //将资源隔离，比如从redis里获取数据
                Thread.sleep(3000);
                return "hello";
            }
        });
        try {
            //如果超过2秒还没有返回 做超时处理
            String result = future.get(2000, TimeUnit.MILLISECONDS);
            System.out.println(result);
        }catch (TimeoutException e){
            System.out.println("超时，做降级");
            future.cancel(true);
        }


    }

市面上的框架Hystrix就采用了线程池的方式实现了资源隔离、限流、降级，并成为了springcloud微服务架构体系的一个组件。

转载于:https://my.oschina.net/suzheworld/blog/3004515