「java拒绝策略」java 策略

今天给各位分享java拒绝策略的知识，其中也会对java 策略进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、线程池 java中怎么设置拒绝策略
• 2、自定义线程池拒绝策略及有界无界队列
• 3、线程池的一些面试题
• 4、线程池的拒绝策略示例
• 5、SpringBoot @Scheduled多线程执行
• 6、线程池创建的7个参数

线程池 java中怎么设置拒绝策略

应该是没有这个功能的，因为线程池里面的线程实际上是复用的，即执行完一个Job以后会从Quenue（任务队列）里面取新的JOB。 

如果有这样的需求可以： 

1）控制JOB的执行时间不能太长，否则可能会造成阻塞； 

2）在JOB的实现(run方法）里面做相应的控制； 

3）如果JOB有长时间和短时间两种模式，可以考虑放在两个线程池中，避免长时间的任务阻塞短时间的任务； 

4）也可以控制等待队列的任务个数，但是Executors默认的Factory方法是没有这个参数的，需要直接new ThreadPoolExecutor

自定义线程池拒绝策略及有界无界队列

核心线程数：实际运行的线程数

最大线程数：最大可以创建的线程数

（1）ThreadPoolExecutor.AbortPolicy 丢弃任务，并抛出 RejectedExecutionException 异常。

（2）ThreadPoolExecutor.CallerRunsPolicy：该任务被线程池拒绝，由调用 execute方法的线程执行该任务。

（3）ThreadPoolExecutor.DiscardOldestPolicy ： 抛弃队列最前面的任务，然后重新尝试执行任务。

（4）ThreadPoolExecutor.DiscardPolicy，丢弃任务，不过也不抛出异常。

当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略。

一个任务通过 execute(Runnable) 方法被添加到线程池，任务就是一个 Runnable 类型的对象，任务的执行方法就是 Runnable 类型对象的 run() 方法。

当一个任务通过 execute(Runnable) 方法欲添加到线程池时，线程池采用的策略如下（即添加任务的策略）：

如果此时线程池中的数量小于 corePoolSize ，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。

如果此时线程池中的数量等于 corePoolSize ，但是缓冲队列 workQueue 未满，那么任务被放入缓冲队列。

如果此时线程池中的数量大于 corePoolSize ，缓冲队列 workQueue 满，并且线程池中的数量小于maximumPoolSize ，建新的线程来处理被添加的任务。

如果此时线程池中的数量大于 corePoolSize ，缓冲队列 workQueue 满，并且线程池中的数量等于maximumPoolSize ，那么通过 handler 所指定的策略来处理此任务。

任务处理的优先级（顺序）为：

核心线程 corePoolSize 、任务队列 workQueue 、最大线程 maximumPoolSize ，如果三者都满了，使用 handler处理被拒绝的任务。当线程池中的线程数量大于 corePoolSize 时，如果某线程空闲时间超过 keepAliveTime ，线程将被终止。这样，线程池可以动态的调整池中的线程数。

从有界无界上分

常见的有界队列为

ArrayBlockingQueue 基于数组实现的阻塞队列

LinkedBlockingQueue 其实也是有界队列，但是不设置大小时就是无界的。

ArrayBlockingQueue 与 LinkedBlockingQueue 对比一哈

ArrayBlockingQueue 实现简单，表现稳定，添加和删除使用同一个锁，通常性能不如后者

LinkedBlockingQueue 添加和删除两把锁是分开的，所以竞争会小一些

SynchronousQueue 比较奇葩，内部容量为零，适用于元素数量少的场景，尤其特别适合做交换数据用，内部使用 队列来实现公平性的调度，使用栈来实现非公平的调度，在Java6时替换了原来的锁逻辑，使用CAS代替了

上面三个队列他们也是存在共性的

put take 操作都是阻塞的

offer poll 操作不是阻塞的，offer 队列满了会返回false不会阻塞，poll 队列为空时会返回null不会阻塞

补充一点，并不是在所有场景下，非阻塞都是好的，阻塞代表着不占用CPU，在有些场景也是需要阻塞的，put take 存在必有其存在的必然性

常见的无界队列

ConcurrentLinkedQueue 无锁队列，底层使用CAS操作，通常具有较高吞吐量，但是具有读性能的不确定性，弱一致性——不存在如ArrayList等集合类的并发修改异常，通俗的说就是遍历时修改不会抛异常

PriorityBlockingQueue 具有优先级的阻塞队列

DelayedQueue 延时队列，使用场景

缓存：清掉缓存中超时的缓存数据

任务超时处理

补充：内部实现其实是采用带时间的优先队列，可重入锁，优化阻塞通知的线程元素leader

LinkedTransferQueue 简单的说也是进行线程间数据交换的利器，在SynchronousQueue 中就有所体现，并且并发大神 Doug Lea 对其进行了极致的优化，使用15个对象填充，加上本身4字节，总共64字节就可以避免缓存行中的伪共享问题，其实现细节较为复杂，可以说一下大致过程：

比如消费者线程从一个队列中取元素，发现队列为空，他就生成一个空元素放入队列 , 所谓空元素就是数据项字段为空。然后消费者线程在这个字段上旅转等待。这叫保留。直到一个生产者线程意欲向队例中放入一个元素，这里他发现最前面的元素的数据项字段为 NULL，他就直接把自已数据填充到这个元素中，即完成了元素的传送。大体是这个意思，这种方式优美了完成了线程之间的高效协作。参考自 

线程池的一些面试题

1,为什么要用线程池,优势

(1)降低资源消耗，通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

(2) 提高响应速度，当任务到达时，任务可以不需要的等到线程创建就能立即执行。

(3)  提高线程的可管理性，线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

1.1常用方式

那java中是怎样实现的线程池呢？是通过Executor框架实现的，该框架中用到了Executor，Executors，ExecutorService，ThreadPoolExecutor这几个接口或类，它们都是JUC包下的。 java.util.concurrent.Executors类是Executor的辅助类，类似于java中操作数组的辅助类java.util.Arrays，以及操作集合的java.util.Collections类

1.2:Executors类中的主要三个方法

线程安全的队列:staticQueue queue = new ConcurrentLinkedQueueString();

(1) 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中的等待，它创建的线程池corePoolSize和maximnumPoolSize是相等的，它使用的是LinkedBlockingQueue;

源码如下:

  public static ExecutorService newFixedThreadPool(int nThreads) {

        return new ThreadPoolExecutor(nThreads, nThreads,

                                      0L, TimeUnit.MILLISECONDS,

                                      new LinkedBlockingQueueRunnable());

    }

(2)Executors#newSingleThreadExecutor

    创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行，它将corePoolSize和maximnumPoolSize都设置为1，它也使用的是LinkedBlockingQueue;

源码:

public static ExecutorService newSingleThreadExecutor() {

        return new FinalizableDelegatedExecutorService

            (new ThreadPoolExecutor(1, 1,

                                    0L, TimeUnit.MILLISECONDS,

                                    new LinkedBlockingQueueRunnable()));

    }

(3)Executors#newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。，它将corePoolSize设置为0，将maximnumPoolSize设置为Integer.MAX_VALUE，它使用的是SynchronousQueue，也就是说来了任务就创建线程运行，当前线程空闲超过60秒，就销毁线程;

源码:

public static ExecutorService newCachedThreadPool() {

        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

                                      60L, TimeUnit.SECONDS,

                                      new SynchronousQueueRunnable());

    }

2,线程池的重要参数:

源码:

public ThreadPoolExecutor(int corePoolSize,

int maximumPoolSize,

long keepAliveTime,

TimeUnit unit,

BlockingQueue workQueue,

ThreadFactory threadFactory,

RejectedExecutionHandler handler)

参数:

corePoolSize

    线程池中的常驻核心线程数，在创建了线程池后，当有请求任务来之后，就会安排池中的线程去执行请求任务，近似理解为今日当值线程，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中。

maximumPoolSize

    线程池能够容纳同时执行的最大线程数，此值必须大于等于1。

keepAliveTime

    多余的空闲线程的存活时间，当前线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime值时，多余空闲线程会被销毁直到只剩下corePoolSize个线程为止。

unit

    keepAliveTime的单位。

workQueue

    任务队列，被提交但尚未被执行的任务。

threadFactory

    表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认的即可。

handler

    拒绝策略，表示当队列满了，再也塞不下新任务了，同时，工作线程大于等于线程池的最大线程数，无法继续为新任务服务，这时候我们就需要拒绝策略机制合理的处理这个问题，默认会抛异常， 那拒绝策略有哪些呢，我们继续往下看。

JDK内置的接口:RejectedExcutionHandle

AbortPolicy（默认）

    直接抛出java.util.concurrent.RejectedExecutionException异常阻止系统正常运行，这种方式显然是不友好的。

CallerRunsPolicy

    "调用者运行"一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。

DiscardOldestPolicy

    抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务。

DiscardPolicy

    直接丢弃任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种解决方案。

    具体选择哪一种的拒绝策略，也是看自己的系统需求了;

3,底层工作原理

(1).在创建了线程池后，等待提交过来的任务请求

 (2).当调用execute()方法添加一个请求任务时，线程池会做如下判断

            2.1 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务

            2.2 如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入队列

            2.3 如果这时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务

            2.4 如果队列满了且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行

    (3). 当一个线程完成任务时，它会从队列中取下一个任务来执行

    (4). 当一个线程无事可做超过一定的时间（keepAliveTime）时，线程池会判断

            4.1 如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉

            4.2 所以线程池的所有任务完成后它最终会收缩到corePoolSize的大小

创建线程池时，配置多少线程数是合理的:

(1)CPU密集型:CPU核数+1个线程的线程池(CPU密集任务只有在真正的多核CPU上才可能得到加速)

(2)IO密集型:O密集型时，大部分线程都阻塞，故需要多配置线程数，CPU核数/1-阻塞系数 阻塞系数在0.8至0.9之间。例如4核，取个乐观值0.9，可达到40个线程左右

------------------------------------------------------------------------

--------------------------------

阿里巴巴开发手册上:出自于生产时间来说:

1,线程资源必须通过线程池提供,不能够在应用中自行创建线程;

2,线程池不允许使用Executors去创建,而是使用ThreadPoolExecutor的方式,

这样可以明确线程池的规则,规避资源耗尽的风险;

---------------------------

SpringBoot 自定义线程池:

1,application.yml配置:

task:

pool:

corePoolSize:5#设置核心线程数

maxPoolSize:20#设置最大线程数

keepAliveSeconds:300#设置线程活跃时间（秒）

queueCapacity:50#设置队列容量

2,线程池配置属性类:

importorg.springframework.boot.context.properties.ConfigurationProperties;

/**

* 线程池配置属性类

*/

@ConfigurationProperties(prefix ="task.pool")

publicclassTaskThreadPoolConfig{

privateintcorePoolSize;

privateintmaxPoolSize;

privateintkeepAliveSeconds;

privateintqueueCapacity;

    ...getter and setter methods...

}

3,启动类上加上异步支持:

@EnableAsync

@EnableConfigurationProperties({TaskThreadPoolConfig.class} )// 开启配置属性支持

4,自定义线程池:

/**

* 创建线程池配置类

*/

@Configuration

public class TaskExecutePool {

    @Autowired

    private TaskThreadPoolConfig config;

    /**

    * 1.这种形式的线程池配置是需要在使用的方法上面@Async("taskExecutor"),

    * 2.如果在使用的方法上面不加该注解那么spring就会使用默认的线程池

    * 3.所以如果加@Async注解但是不指定使用的线程池，又想自己定义线程池那么就可以重写spring默认的线程池

    * 4.所以第二个方法就是重写默认线程池

    * 注意：完全可以把线程池的参数写到配置文件中

    */

    @Bean

    public Executor taskExecutor() {

        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

        //核心线程池大小

        executor.setCorePoolSize(config.getCorePoolSize());

        //最大线程数

        executor.setMaxPoolSize(config.getMaxPoolSize());

        //队列容量

        executor.setQueueCapacity(config.getQueueCapacity());

        //活跃时间

        executor.setKeepAliveSeconds(config.getKeepAliveSeconds());

        //线程名字前缀

        executor.setThreadNamePrefix("TaskExecutePool-");

        // setRejectedExecutionHandler：当pool已经达到max size的时候，如何处理新任务

        // CallerRunsPolicy：不在新线程中执行任务，而是由调用者所在的线程来执行

        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        // 等待所有任务结束后再关闭线程池

        executor.setWaitForTasksToCompleteOnShutdown(true);

        executor.initialize();

        return executor;

    }

}

测试:

import io.swagger.annotations.Api;

import io.swagger.annotations.ApiOperation;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.ResponseBody;

import org.springframework.web.bind.annotation.RestController;

/**

* @author qijx

*/

@Api(description = "测试控制类11111")

@RestController

@RequestMapping("/threadPoolController1")

public class ThreadPoolController1 {

        @Autowired

        private ThreadPoolService1 threadPoolService;

        @ApiOperation(value = "测试方法")

        @ResponseBody

        @RequestMapping(value = "/test",method = RequestMethod.GET)

        public String threadPoolTest() {

            threadPoolService.executeAsync();

            return "hello word!";

        }

}

第二种方法:重写springboot线程池:

**

* 原生(Spring)异步任务线程池装配类，实现AsyncConfigurer重写他的两个方法，这样在使用默认的

*  线程池的时候就会使用自己重写的

*/

@Slf4j

@Configuration

public class NativeAsyncTaskExecutePool implements AsyncConfigurer{

    //注入配置类

    @Autowired

    TaskThreadPoolConfig config;

    @Override

    public Executor getAsyncExecutor() {

        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

        //核心线程池大小

        executor.setCorePoolSize(config.getCorePoolSize());

        //最大线程数

        executor.setMaxPoolSize(config.getMaxPoolSize());

        //队列容量

        executor.setQueueCapacity(config.getQueueCapacity());

        //活跃时间

        executor.setKeepAliveSeconds(config.getKeepAliveSeconds());

        //线程名字前缀

        executor.setThreadNamePrefix("NativeAsyncTaskExecutePool-");

        // setRejectedExecutionHandler：当pool已经达到max size的时候，如何处理新任务

        // CallerRunsPolicy：不在新线程中执行任务，而是由调用者所在的线程来执行

        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        // 等待所有任务结束后再关闭线程池

        executor.setWaitForTasksToCompleteOnShutdown(true);

        executor.initialize();

        return executor;

    }

    /**

    *  异步任务中异常处理

    * @return

    */

    @Override

    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {

        return new AsyncUncaughtExceptionHandler() {

            @Override

            public void handleUncaughtException(Throwable arg0, Method arg1, Object... arg2) {

                log.error("=========================="+arg0.getMessage()+"=======================", arg0);

                log.error("exception method:"+arg1.getName());

            }

        };

    }

}

测试:

/**

* @author qijx

*/

@Service

public class ThreadPoolService2 {

    private static final Logger logger = LoggerFactory.getLogger(ThreadPoolService2.class);

    /**

    * @Async该注解不需要在指定任何bean

    */

    @Async

    public void executeAsync() {

        logger.info("start executeAsync");

        try {

            System.out.println("当前运行的线程名称：" + Thread.currentThread().getName());

            Thread.sleep(1000);

        } catch (Exception e) {

            e.printStackTrace();

        }

        logger.info("end executeAsync");

    }

}

------------------------------------

线程池的拒绝策略示例

Java的线程池中，如果不断往线程池提交任务，最终会发生什么？

如果work queue是一个有界队列，队列放满，线程数量达到maxsize，且没有空闲线程时，再往线程池提交任务会触发线程池的拒绝策略。

线程池有哪些拒绝策略呢？

一共提交8个任务，其中有一个默默被丢弃。

线程池1个核心线程，max线程数为2，work queue大小为5.

可以看到，提交8个任务后，第2个任务被丢弃了。因为第2个任务是oldest，第一个被放进queue的任务。

用这种拒绝策略时要注意，主线程既需要负责创建线程，又需要执行任务，会造成性能问题。

在输出中，能看出，主线程号为1，而提交的任务中，其中一个任务（最后一个被提交的任务）就是由主线程来执行的。

了解了前四种拒绝策略，发现：

abort，discard，discardOldest都会丢弃任务；

callerRun虽然执行了任务，但是会影响主线程性能。

若将work queue设置为无界队列，或者将maxsize设置为最大整数，都有可能造成out of memory。

那么可以通过自定义拒绝策略，让后进来的task阻塞住，有资源了再处理。这样可以让每一个任务都得到执行。

SpringBoot @Scheduled多线程执行

在用springboot框架做定时任务的时候，大部分情况都是直接通过 @Scheduled 注解来指定定时任务的。但是当你有多个定时任务时， @Scheduled 并不一定会按时执行。

因为使用 @Scheduled 的定时任务虽然是异步执行的，但是，默认不同的定时任务之间并不是并行的。

查看 org.springframework.scheduling.config.ScheduledTaskRegistrar 源码即可发现

当未手动指定 taskScheduler 时，会通过 Executors.newSingleThreadScheduledExecutor() 创建默认的单线程线程池，且该线程池的拒绝策略为 AbortPolicy ，这种策略在线程池无可用线程时丢弃任务，并抛出异常 RejectedExecutionException 。

添加配置类

接口 java.util.concurrent.RejectedExecutionHandler 提供了拒绝任务处理的自定义方法。在 java.util.concurrent.ThreadPoolExecutor 中已经包含四种拒绝策略。

线程池创建的7个参数

java多线程开发时，常常用到线程池技术，这篇文章是对创建java线程池时的七个参数的详细解释。从源码中可以看出，线程池的构造函数有7个参数，分别是corePoolSize、maximumPoolSize、keepAliveTime、unit、workQueue、threadFactory、handler。下面会对这7个参数一一解释。

线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会 被销毁，除非设置了allowCoreThreadTimeOut。这里的最小线程数量即是corePoolSize。

一个任务被提交到线程池后，首先会缓存到工作队列（后面会介绍）中，如果工作队列满了，则会创建一个新线程，然后从工作队列中的取出一个任务交由新线程来处理，而将刚提交的任务放入工作队列。线程池不会无限制的去创建新线程，它会有一个最大线程数量的限制，这个数量即由maximunPoolSize来指定。

一个线程如果处于空闲状态，并且当前的线程数量大于corePoolSize，那么在指定时间后，这个空闲线程会被销毁，这里的指定时间由keepAliveTime来设定。

keepAliveTime的计量单位

新任务被提交后，会先进入到此工作队列中，任务调度时再从队列中取出任务。jdk中提供了四种工作队列：

基于数组的有界阻塞队列，按FIFO排序。新任务进来后，会放到该队列的队尾，有界的数组可以防止资源耗尽问题。当线程池中线程数量达到corePoolSize后，再有新任务进来，则会将任务放入该队列的队尾，等待被调度。如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略。

基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。由于该队列的近似无界性，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列，而不会去创建新线程直到maxPoolSize，因此使用该工作队列时，参数maxPoolSize其实是不起作用的。

一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。

具有优先级的无界阻塞队列，优先级通过参数Comparator实现。

创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程等等

当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来，该如何处理呢。这里的拒绝策略，就是解决这个问题的，jdk中提供了4中拒绝策略：

该策略下，在 调用者线程 中直接执行该被拒绝任务的run方法，除非线程池已经shutdown，则直接抛弃任务。

该策略下，直接丢弃任务，并抛出RejectedExecutionException异常。

该策略下，直接丢弃任务，什么都不做。

该策略下，抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列

到此，构造线程池时的七个参数，就全部介绍完毕了。

java拒绝策略的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java 策略、java拒绝策略的信息别忘了在本站进行查找喔。