精华内容
下载资源
问答
  • 2019-09-18 14:25:12

    一,创建一个线程池

    其中:

    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor)

    饱和策略执行时的具体逻辑。

    protected void afterExecute(Runnable r, Throwable t)

    异常后的具体逻辑。

     

    package com.kintech.scanAF.common;
    
    import com.kintech.common.utils.log.LogerHelper;
    import java.util.concurrent.*;
    
    /**
     * @author Tyler
     * @date 2019/9/12
     */
    public class ThreadHelper {
        //初始化线程池
        private static final ExecutorService pool = new ThreadPoolExecutor(
                2, 
                5, 
                60,
                TimeUnit.SECONDS, 
                new ArrayBlockingQueue<Runnable>(10),
                Executors.defaultThreadFactory(), 
                new ThreadPoolExecutor.DiscardPolicy(){
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                LogerHelper.Write("--- "+this.getClass().getName()+"\r\n--- 队列已满,请稍后再来");
            }
        })
        {
            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                super.afterExecute(r, t);
                LogerHelper.Write(t.getMessage());
                System.out.println(t.getMessage());
            }
        };
    
        /**
         * 执行线程池方法(方法在RunnableFunc文件夹中)
         * @param run
         */
        public static void execute(Runnable run)
        {
            pool.execute(run);
        }
        /**
         * 执行线程池方法(方法在RunnableFunc文件夹中)
         * @param run
         */
        public static Future<?> submit(Runnable run)
        {
            Future<?> future = pool.submit(run);
            return future;
        }
    
    }
    

    线程池的参数介绍:

    public ThreadPoolExecutor(
      int corePoolSize, // 线程数量
      int maximumPoolSize, // 最大线程数量
      long keepAliveTime, // 线程存活时间
      TimeUnit unit, //时间单位
      BlockingQueue<Runnable> workQueue, // 任务队列
      ThreadFactory threadFactory, // 线程创建工厂,可以给线程起名字
      RejectedExecutionHandler handler) // 饱和策略

     

    二,创建任务

    package com.kintech.scanAF.common.RunnableFunc;
    
    
    /**
     * @author Tyler
     * @date 2019/9/12
     */
    public class Test implements Runnable {
        private String a;
        public Test(String a)
        {
            this.a=a;
        }
    
        @Override
        public void run() {
            try
            {
                throw new RuntimeException( "Service has error !");
            }
            catch (Exception e) {
                throw e;
            }
            finally
            {
                a=null;
            }
    
        }
    }
    

     

    三,调用并获取异常

    public void MainTest(String a) throws IOException {
            Future<?> future = ThreadHelper.submit(new Test(a));
            try {
                future.get();
            }
            catch (Exception ex)
            {
    //记录日志
                LogerHelper.Write(ex.getMessage());
    //swing弹窗
                JOptionPane.showMessageDialog(null, ex.getMessage(), "Message", JOptionPane.ERROR_MESSAGE);
            }
    
        }

     

    更多相关内容
  • 主要介绍了java ThreadPoolExecutor使用方法简单介绍的相关资料,需要的朋友可以参考下
  • 主要介绍了java ThreadPoolExecutor 并发调用实例详解的相关资料,需要的朋友可以参考下
  • 主要介绍了Java ThreadPoolExecutor的参数深入理解的相关资料,需要的朋友可以参考下
  • 提供工厂方法来创建不同类型的线程池,这篇文章主要介绍了Java ThreadPoolExecutor 线程池的使用介绍,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来...
  • 主要介绍了Java线程池ThreadPoolExecutor原理及使用实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • ThreadPoolExecutorJava语言对于线程池的实现。池化技术是一种复用资源,减少开销的技术。线程是操作系统的资源,线程的创建与调度由操作系统负责,线程的创建与调度都要耗费大量的资源,其中线程创建需要占用一定...

    ThreadPoolExecutor是Java语言对于线程池的实现。池化技术是一种复用资源,减少开销的技术。线程是操作系统的资源,线程的创建与调度由操作系统负责,线程的创建与调度都要耗费大量的资源,其中线程创建需要占用一定的内存,而线程的调度需要不断的切换线程上下文造成一定的开销。同时线程执行完毕之后就会被操作系统回收,这样在高并发情况下就会造成系统频繁创建线程。

    为此线程池技术为了解决上述问题,使线程在使用完毕后不回收而是重复利用。如果线程能够复用,那么我们就可以使用固定数量的线程来解决并发问题,这样一来不仅节约了系统资源,而且也会减少线程上下文切换的开销。

    参数

    ThreadPoolExecutor的构造函数有7个,它们分别是:

    corePoolSize(int):线程池的核心线程数量

    maximumPoolSize(int):线程池最大线程数量

    keepAliveTime(long):保持线程存活的时间

    unit(TimeUnit):线程存活时间单位//加入Java开发交流君样:756584822一起吹水聊天

    workQueue(BlockingQueue):工作队列,用于临时存放提交的任务

    threadFactory(ThreadFactory):线程工厂,用于创建线程

    handler(RejectedExecutionHandler):任务拒绝处理器,当线程池无法再接受新的任务时,会交给它处理

    一般情况下,我们只使用前五个参数,剩余两个我们使用默认参数即可。

    任务提交逻辑

    其实,线程池创建参数都与线程池的任务提交逻辑密切相关。根据源码描述可以得知:当提交一个新任务时(执行线程池的execute方法)会经过三个步骤的处理。

    当任务数量小于corePoolSize时,线程池会创建一个新的线程(创建新线程由传入参数threadFactory完成)来处理任务,哪怕线程池中有空闲线程,依然会选择创建新线程来处理。

    当任务数量大于corePoolSize时,线程池会将新任务压入工作队列(参数中传递的workQueue)等待调度。

    当新提交的任务无法压入工作队列时,会检查当前任务数量是否大于maximumPoolSize。如果小于maximunPoolSize则会新建线程来处理任务(这时我们的keepAliveTime参数就起作用了,它主要作用于这种情况下创建的线程,如果任务数量减小,这些线程闲置了,那么在超过keepAliveTime时间后就会被回收)。如果大于了maximumPoolSize就会交由任务拒绝处理器handler处理。

    60132ee3674c7ca22c30eaca00572a71.png

    线程池状态

    正如线程有不同的状态一样,线程池也拥有不同的运行状态。源码中提出,线程池有五种状态,分别为:

    RUNNING:运行状态,不断接收任务并处理它们。

    SHUTDOWN:关闭状态,不接收新任务,但是会处理工作队列中排队的任务。

    STOP:停止状态,不接收新任务,清空工作队列且不会处理工作队列的任务。

    TIDYING:待终止状态,此状态下,任务队列和线程池都为空。

    TERMINATED:终止状态,线程池关闭。

    6e4e75b8fdfe03140daf930d935ffebe.png

    如何让线程不被销毁

    文章开头说到,线程在执行完毕之后会被操作系统回收销毁,那么线程池时如何保障线程不被销毁?首先看一个测试用例:

    public static void testThreadState()

    {

    Thread thread = new Thread(() -> System.out.println("Hello world")); // 创建一个线程

    System.out.println(thread.getState()); // 此时线程的状态为NEW

    thread.start(); // 启动线程,状态为RUNNING

    System.out.println(thread.getState());

    try

    {

    thread.join();

    System.out.println(thread.getState()); // 线程运行结束,状态为TERMINATED

    thread.start(); // 此时再启动线程会发生什么呢?

    } catch (InterruptedException e)

    {

    e.printStackTrace();

    }

    }//加入Java开发交流君样:756584822一起吹水聊天

    结果输出:

    NEW

    RUNNABLE

    Hello world

    TERMINATED

    Exception in thread "main" java.lang.IllegalThreadStateException

    at java.base/java.lang.Thread.start(Thread.java:794)

    at misc.ThreadPoolExecutorTest.testThreadState(ThreadPoolExecutorTest.java:90)

    at misc.ThreadPoolExecutorTest.main(ThreadPoolExecutorTest.java:114)

    可以看出,当一个线程运行结束之后,我们是不可能让线程起死回生重新启动的。既然如此ThreadPoolExecutor如何保障线程执行完一个任务不被销毁而继续执行下一个任务呢?

    其实这里就要讲到我们最开始传入的参数workQueue,它的接口类型为BlockingQueue,直译过来就是阻塞队列。这中队列有个特点,就是当队列为空而尝试出队操作时会阻塞。

    基于阻塞队列的如上特点,ThreadPoolExecutor采用不断循环+阻塞队列的方式来实现线程不被销毁。

    final void runWorker(Worker w) {

    Thread wt = Thread.currentThread();

    Runnable task = w.firstTask;

    w.firstTask = null;

    w.unlock(); // allow interrupts

    boolean completedAbruptly = true;

    try {

    // 从工作队列中不断取任务。如果工作队列为空,那么程序会阻塞在这里

    while (task != null || (task = getTask()) != null) {

    w.lock();

    // 检查线程池状态

    if ((runStateAtLeast(ctl.get(), STOP) ||

    (Thread.interrupted() &&

    runStateAtLeast(ctl.get(), STOP))) &&

    !wt.isInterrupted())

    wt.interrupt();

    try {

    beforeExecute(wt, task);

    try {//加入Java开发交流君样:756584822一起吹水聊天

    执行任务

    task.run();

    afterExecute(task, null);

    } catch (Throwable ex) {

    afterExecute(task, ex);

    throw ex;

    }

    } finally {

    task = null;

    w.completedTasks++;

    w.unlock();

    }

    }

    completedAbruptly = false;

    } finally {

    processWorkerExit(w, completedAbruptly);

    }

    }

    关闭线程池

    想要关闭线程池可以通过调用shutdown()和shutdownNow()方法实现。两种方法有所不同,其中调用shutdown()方法会停止接收新的任务,处理工作队列中的任务,调用这个方法之后线程池会进入SHUTDOWN状态,此方法无返回值并且不抛出异常。

    而shutdownNow()方法会停止接收新的任务,而且会返回未完成的任务集合,同时这个方法也会抛出异常。

    如何创建一个适应业务背景的线程池

    线程池创建有七个参数,这几个参数的相互作用可以创建出适应特定业务场景的线程池。其中最为重要的有三个参数分别为:corePoolSize,maximumPoolSize,workQueue。其中前两个参数已经在上文中作了详细介绍,而workQueue参数在线程池创建中也极为重要。workQueue主要有三种:

    //加入Java开发交流君样:756584822一起吹水聊天

    SynchronousQueue:这个队列只能容纳一个元素,而且只有当队列为空时可以入队。

    ArrayBlockingQueue:这是一个固定容量大小的队列。

    LinkedBlockingQueue:链式阻塞队列,容量无限。

    通过上述三种队列的特性我们可以得知,

    当使用SynchronousQueue的时候,总是倾向于新建线程处理请求,如果线程池大小参数设置的很大,那么线程数量倾向于无限增长。这样的线程池能够高效处理突发增长的请求,而且处理效率很高,但是开销很大。//加入Java开发交流君样:756584822一起吹水聊天

    当使用ArrayBlockingQueue的时候,线程池所能处理的瞬时最大任务量为队列大小 + 线程池最大数量,这样的线程池中规中矩,使用的业务场景很多,具体还需结合业务场景来调配三个参数的大小。例如I/O密集型的场景,多数的线程处于阻塞状态,为了提高系统吞吐量,我们希望能够有多数线程来处理IO。这样的话我们偏向于将corePoolSize设置的大一点。而且阻塞队列大小不要设置很大,同时maximumPoolSize也设置的大一点。

    当使用LinkedBlockingQueue时,线程池的maximumPoolSize参数会失效,因为按照任务提交流程来看,LinkedBlockingQueue可以无限制地容纳任务,自然不会出现队列无法工作,新建线程处理的情况。使用LinkedBlockingQueue可以平稳地处理一些请求激增的情况,但是处理效率不会提高,仅仅能够起到一定的缓冲作用。

    bf9f9af691d10a2901feb2081de77247.png

    bf9f9af691d10a2901feb2081de77247.png

    标签:Java,队列,创建,处理,任务,详解,线程,参数,ThreadPoolExecutor

    来源: https://blog.csdn.net/wj1314250/article/details/113924970

    展开全文
  • JAVA ThreadPoolExecutor线程池参数设置技巧 之前发了一篇文章还是在学校的时候,很久没有回到慕课学习了。 加入公司,成为一名程序员已经过了大半年,接手了大大小小的项目不少,忙碌中有很多磨砺和收获,但也变...

    JAVA ThreadPoolExecutor线程池参数设置技巧

     

    之前发了一篇文章还是在学校的时候,很久没有回到慕课学习了。
    加入公司,成为一名程序员已经过了大半年,接手了大大小小的项目不少,忙碌中有很多磨砺和收获,但也变得有些浮躁,怀念在学校里能投入的埋头学习时光。
    感觉是时候重新静下心来重拾学习之路,探究一些较深入的问题。

    今天带来些干货,关于java线程池的参数设置。线程池是java多线程里开发里的重要内容,使用难度不大,但如何用好就要明白参数的含义和如何去设置。干货里的内容大多是参考别人的,加入了一些知识点的扩充和看法。希望能对多线程开发学习的童鞋有些启发和帮助。

    一、ThreadPoolExecutor的重要参数

        1、corePoolSize:核心线程数
            * 核心线程会一直存活,及时没有任务需要执行
            * 当线程数小于核心线程数时,即使有线程空闲,线程池也会优先创建新线程处理
            * 设置allowCoreThreadTimeout=true(默认false)时,核心线程会超时关闭
    
        2、queueCapacity:任务队列容量(阻塞队列)
            * 当核心线程数达到最大时,新任务会放在队列中排队等待执行
    
        3、maxPoolSize:最大线程数
            * 当线程数>=corePoolSize,且任务队列已满时。线程池会创建新线程来处理任务
            * 当线程数=maxPoolSize,且任务队列已满时,线程池会拒绝处理任务而抛出异常
    
        4、 keepAliveTime:线程空闲时间
            * 当线程空闲时间达到keepAliveTime时,线程会退出,直到线程数量=corePoolSize
            * 如果allowCoreThreadTimeout=true,则会直到线程数量=0
    
        5、allowCoreThreadTimeout:允许核心线程超时
        6、rejectedExecutionHandler:任务拒绝处理器
            * 两种情况会拒绝处理任务:
                - 当线程数已经达到maxPoolSize,切队列已满,会拒绝新任务
                - 当线程池被调用shutdown()后,会等待线程池里的任务执行完毕,再shutdown。如果在调用shutdown()和线程池真正shutdown之间提交任务,会拒绝新任务
            * 线程池会调用rejectedExecutionHandler来处理这个任务。如果没有设置默认是AbortPolicy,会抛出异常
            * ThreadPoolExecutor类有几个内部实现类来处理这类情况:
                - AbortPolicy 丢弃任务,抛运行时异常
                - CallerRunsPolicy 执行任务
                - DiscardPolicy 忽视,什么都不会发生
                - DiscardOldestPolicy 从队列中踢出最先进入队列(最后一个执行)的任务
            * 实现RejectedExecutionHandler接口,可自定义处理器

    二、ThreadPoolExecutor执行顺序

            线程池按以下行为执行任务
        1. 当线程数小于核心线程数时,创建线程。
        2. 当线程数大于等于核心线程数,且任务队列未满时,将任务放入任务队列。
        3. 当线程数大于等于核心线程数,且任务队列已满
            - 若线程数小于最大线程数,创建线程
            - 若线程数等于最大线程数,抛出异常,拒绝任务

    三、如何设置参数

        1、默认值
            * corePoolSize=1
            * queueCapacity=Integer.MAX_VALUE
            * maxPoolSize=Integer.MAX_VALUE
            * keepAliveTime=60s
            * allowCoreThreadTimeout=false
            * rejectedExecutionHandler=AbortPolicy()
    
        2、如何来设置
            * 需要根据几个值来决定
                - tasks :每秒的任务数,假设为500~1000
                - taskcost:每个任务花费时间,假设为0.1s
                - responsetime:系统允许容忍的最大响应时间,假设为1s
            * 做几个计算
                - corePoolSize = 每秒需要多少个线程处理? 
                    * threadcount = tasks/(1/taskcost) =tasks*taskcout =  (500~1000)*0.1 = 50~100 个线程。corePoolSize设置应该大于50
                    * 根据8020原则,如果80%的每秒任务数小于800,那么corePoolSize设置为80即可
                - queueCapacity = (coreSizePool/taskcost)*responsetime
                    * 计算可得 queueCapacity = 80/0.1*1 = 80。意思是队列里的线程可以等待1s,超过了的需要新开线程来执行
                    * 切记不能设置为Integer.MAX_VALUE,这样队列会很大,线程数只会保持在corePoolSize大小,当任务陡增时,不能新开线程来执行,响应时间会随之陡增。
                - maxPoolSize = (max(tasks)- queueCapacity)/(1/taskcost)
                    * 计算可得 maxPoolSize = (1000-80)/10 = 92
                    * (最大任务数-队列容量)/每个线程每秒处理能力 = 最大线程数
                - rejectedExecutionHandler:根据具体情况来决定,任务不重要可丢弃,任务重要则要利用一些缓冲机制来处理
                - keepAliveTime和allowCoreThreadTimeout采用默认通常能满足
    
        3、 以上都是理想值,实际情况下要根据机器性能来决定。如果在未达到最大线程数的情况机器cpu load已经满了,则需要通过升级硬件(呵呵)和优化代码,降低taskcost来处理。

    JAVA

    展开全文
  • 本文整理匯總了Javajava.util.concurrent.ThreadPoolExecutor.AbortPolicy方法的典型用法代碼示例。如果您正苦於以下問題:Java ThreadPoolExecutor.AbortPolicy方法的具體用法?Java ThreadPoolExecutor....

    本文整理匯總了Java中java.util.concurrent.ThreadPoolExecutor.AbortPolicy方法的典型用法代碼示例。如果您正苦於以下問題:Java ThreadPoolExecutor.AbortPolicy方法的具體用法?Java ThreadPoolExecutor.AbortPolicy怎麽用?Java ThreadPoolExecutor.AbortPolicy使用的例子?那麽恭喜您, 這裏精選的方法代碼示例或許可以為您提供幫助。您也可以進一步了解該方法所在類java.util.concurrent.ThreadPoolExecutor的用法示例。

    在下文中一共展示了ThreadPoolExecutor.AbortPolicy方法的11個代碼示例,這些例子默認根據受歡迎程度排序。您可以為喜歡或者感覺有用的代碼點讚,您的評價將有助於我們的係統推薦出更棒的Java代碼示例。

    示例1: getExecutor

    ​點讚 3

    import java.util.concurrent.ThreadPoolExecutor; //導入方法依賴的package包/類

    public XExecutor getExecutor() {

    if (executor == null) {

    synchronized (DownloadThreadPool.class) {

    if (executor == null) {

    executor = new XExecutor(corePoolSize,

    MAX_POOL_SIZE,

    KEEP_ALIVE_TIME,

    UNIT,

    new PriorityBlockingQueue()/*無限容量的緩衝隊列*/,

    Executors.defaultThreadFactory()/*線程創建工廠*/,

    new ThreadPoolExecutor.AbortPolicy()/*繼續超出上限的策略,阻止*/);

    }

    }

    }

    return executor;

    }

    開發者ID:wzx54321,項目名稱:XinFramework,代碼行數:18,

    示例2: CountDownLatchHelper

    ​點讚 2

    import java.util.concurrent.ThreadPoolExecutor; //導入方法依賴的package包/類

    public CountDownLatchHelper() {

    executes = Lists.newCopyOnWriteArrayList();

    data = Lists.newCopyOnWriteArrayList();

    threadPool= new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(), Runtime.getRuntime().availableProcessors(),

    0L, TimeUnit.MILLISECONDS,

    new LinkedBlockingQueue<>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

    }

    開發者ID:yu199195,項目名稱:happylifeplat-transaction,代碼行數:9,

    示例3: getExecutorService

    ​點讚 2

    import java.util.concurrent.ThreadPoolExecutor; //導入方法依賴的package包/類

    public ExecutorService getExecutorService() {

    final ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("search-thread-%d")

    .setDaemon(true).build();

    return new ThreadPoolExecutor(DEFAULT_THREAD_MAX, DEFAULT_THREAD_MAX,

    0L, TimeUnit.MILLISECONDS,

    new LinkedBlockingQueue<>(1024), threadFactory, new ThreadPoolExecutor.AbortPolicy());

    }

    開發者ID:yu199195,項目名稱:happylifeplat-transaction,代碼行數:9,

    示例4: getExecutor

    ​點讚 2

    import java.util.concurrent.ThreadPoolExecutor; //導入方法依賴的package包/類

    public XExecutor getExecutor() {

    if (executor == null) {

    synchronized (UploadThreadPool.class) {

    if (executor == null) {

    executor = new XExecutor(corePoolSize, MAX_IMUM_POOL_SIZE, KEEP_ALIVE_TIME, UNIT, //

    new PriorityBlockingQueue(), //無限容量的緩衝隊列

    Executors.defaultThreadFactory(), //線程創建工廠

    new ThreadPoolExecutor.AbortPolicy()); //繼續超出上限的策略,阻止

    }

    }

    }

    return executor;

    }

    開發者ID:weiwenqiang,項目名稱:GitHub,代碼行數:14,

    示例5: getExecutor

    ​點讚 2

    import java.util.concurrent.ThreadPoolExecutor; //導入方法依賴的package包/類

    public XExecutor getExecutor() {

    if (executor == null) {

    synchronized (DownloadThreadPool.class) {

    if (executor == null) {

    executor = new XExecutor(corePoolSize, MAX_POOL_SIZE, KEEP_ALIVE_TIME, UNIT, //

    new PriorityBlockingQueue(), //無限容量的緩衝隊列

    Executors.defaultThreadFactory(), //線程創建工廠

    new ThreadPoolExecutor.AbortPolicy()); //繼續超出上限的策略,阻止

    }

    }

    }

    return executor;

    }

    開發者ID:weiwenqiang,項目名稱:GitHub,代碼行數:14,

    示例6: createPool

    ​點讚 2

    import java.util.concurrent.ThreadPoolExecutor; //導入方法依賴的package包/類

    protected synchronized static void createPool() {

    BlockingQueue workers = new LinkedBlockingQueue<>();

    RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();

    mDownloadPool = new DownloadPool(

    corePoolSize,

    maxPoolSize,

    keepAliveTime,

    TimeUnit.MILLISECONDS,

    workers,

    Executors.defaultThreadFactory(),

    handler);

    }

    開發者ID:Dpuntu,項目名稱:android-downloader,代碼行數:13,

    示例7: TreadPool

    ​點讚 2

    import java.util.concurrent.ThreadPoolExecutor; //導入方法依賴的package包/類

    private TreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime) {

    exec = new ThreadPoolExecutor(

    corePoolSize,// 核心線程數

    maximumPoolSize,// 最大線程數

    keepAliveTime,//閑置線程存活時間

    TimeUnit.SECONDS, // 時間單位

    new LinkedBlockingDeque(), // 線程隊列

    Executors.defaultThreadFactory(), // 線程工廠

    new ThreadPoolExecutor.AbortPolicy() // 隊列已滿,而且當前線程數已經超過最大線程數時的異常處理策略

    );

    scheduleExec = Executors.newScheduledThreadPool(corePoolSize);

    }

    開發者ID:penghongru,項目名稱:Coder,代碼行數:13,

    示例8: initial

    ​點讚 2

    import java.util.concurrent.ThreadPoolExecutor; //導入方法依賴的package包/類

    public void initial() {

    RejectedExecutionHandler handler = null;

    if (discard) {

    handler = new ThreadPoolExecutor.DiscardPolicy();

    } else {

    handler = new ThreadPoolExecutor.AbortPolicy();

    }

    executor = new ThreadPoolExecutor(poolSize, poolSize, 60 * 1000L, TimeUnit.MILLISECONDS,

    new LinkedBlockingQueue(10 * 1000),

    new NamedThreadFactory("communication-async"), handler);

    }

    開發者ID:luoyaogui,項目名稱:otter-G,代碼行數:13,

    示例9: init

    ​點讚 2

    import java.util.concurrent.ThreadPoolExecutor; //導入方法依賴的package包/類

    @PostConstruct

    public void init() {

    ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()

    .setNameFormat("demo-pool-%d").build();

    //通用線程池

    executorService = new ThreadPoolExecutor(corePoolSize, maximumPoolSize,

    0L, TimeUnit.MILLISECONDS,

    new LinkedBlockingQueue(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

    }

    開發者ID:alibaba,項目名稱:bulbasaur,代碼行數:11,

    示例10: buildSimpleExecutorService

    ​點讚 2

    import java.util.concurrent.ThreadPoolExecutor; //導入方法依賴的package包/類

    public static ExecutorService buildSimpleExecutorService() {

    ThreadFactory namedThreadFactory = Executors.defaultThreadFactory();

    return new ThreadPoolExecutor(1, 1,

    0L, TimeUnit.MILLISECONDS,

    new LinkedBlockingQueue(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

    }

    開發者ID:shenhuanet,項目名稱:ZhidaoDaily-android,代碼行數:7,

    示例11: setRejectedExecutionHandler

    ​點讚 1

    import java.util.concurrent.ThreadPoolExecutor; //導入方法依賴的package包/類

    /**

    * Set the RejectedExecutionHandler to use for the ExecutorService.

    * Default is the ExecutorService's default abort policy.

    * @see java.util.concurrent.ThreadPoolExecutor.AbortPolicy

    */

    public void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler) {

    this.rejectedExecutionHandler =

    (rejectedExecutionHandler != null ? rejectedExecutionHandler : new ThreadPoolExecutor.AbortPolicy());

    }

    開發者ID:lamsfoundation,項目名稱:lams,代碼行數:10,

    注:本文中的java.util.concurrent.ThreadPoolExecutor.AbortPolicy方法示例整理自Github/MSDocs等源碼及文檔管理平台,相關代碼片段篩選自各路編程大神貢獻的開源項目,源碼版權歸原作者所有,傳播和使用請參考對應項目的License;未經允許,請勿轉載。

    展开全文
  • corePoolSize:核心池的大小,这个参数跟后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后,默认情况下,线程池中并没有任何线程,而是等待有任务到来才创建线程去执行任务,除非调用了...
  • Java 线程池 ThreadPoolExecutor

    千次阅读 2021-06-07 21:32:55
    Java 线程池 ThreadPoolExecutor
  • 一、背景 前面一篇文章转载了ThreadPoolExecutor的几种拒绝策略:https://blog.csdn.net/w605283073/article/details/89930154,讲得很不错。...ThreadPoolExecutor的拒绝策略常用的是DiscardPolicy...
  • Java ThreadPoolExecutor的拒绝策略

    千次阅读 多人点赞 2019-05-07 21:52:52
    在分析ThreadPoolExecutor的构造参数时,有一个RejectedExecutionHandler参数。 RejectedExecutionHandler是一个接口: public interface RejectedExecutionHandler { void rejectedExecution(Runnable r, ...
  • 本文整理匯總了Javajava.util.concurrent.ThreadPoolExecutor.getCompletedTaskCount方法的典型用法代碼示例。如果您正苦於以下問題:Java ThreadPoolExecutor.getCompletedTaskCount方法的具體用法?Java ...
  • 本文整理匯總了Javajava.util.concurrent.ThreadPoolExecutor.getQueue方法的典型用法代碼示例。如果您正苦於以下問題:Java ThreadPoolExecutor.getQueue方法的具體用法?Java ThreadPoolExecutor.getQueue怎麽用...
  • Java线程池ThreadPoolExecutor

    千次阅读 2022-04-01 15:33:12
    线程池ThreadPoolExecutor 1、类关系 Executor 是一个接口, 它是 Executor 框架的基础, 它将任务的提交与任务的执行分离开来。 ExecutorService 接口继承了 Executor【原来接口是可以继承接口的】, 在其上做了...
  • java使用ThreadPoolExecutor的方式创建简单的线程池使用ThreadPoolExecutor的方式创建参数介绍代码示例 使用ThreadPoolExecutor的方式创建 new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, ...
  • java 线程池的使用 ThreadPoolExecutor所需maven包构建线程池具体代码使用 废话不爱说,直接上代码,懂的都懂 所需maven包 <dependency> <groupId>com.google.guava</groupId> <...
  • 不过在阿里java开发规范文档中说明,尽量不要用该类创建线程池。 1.2 ThreadPoolExecutor类讲解 1.2.1 线程池状态: 五种状态: 线程池的状态 说明 RUNNING 允许提交并处理任务 SHUTDOWN 不允许提交新的任务,但是会...
  • JAVA ThreadPoolExecutor

    千次阅读 2010-06-22 20:03:00
    JAVA ThreadPoolExecutor
  • JAVA线程池ThreadPoolExecutor详解

    千次阅读 2021-08-15 16:58:21
    构造函数 ThreadPoolExecutor的构造函数共有四个,但最终调用的都是同一个: public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ...
  • Java线程池01之ThreadPoolExecutor 1. 类继承关系 ExecutorExecutorServiceAbstractExecutorServiceScheduledExecutorServiceThreadPoolExecutorForkJoinPoolScheduledThreadPoolExecutor 2. java代码 2.1 基本使用 ...
  • Java ThreadPoolExecutor线程池的使用

    千次阅读 2019-12-19 08:39:21
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor ( 4 , 20 , 20 , TimeUnit . MILLISECONDS , ( BlockingQueue ) new LinkedBlockingQueue < > ( ) ) ; public static ...
  • Java】 之 ThreadPoolExecutor 使用案例

    千次阅读 2019-09-14 14:56:43
    ThreadPoolExecutor threadPoolExecutor ) { System . out . println ( "task rejected. " + threadPoolExecutor . toString ( ) ) ; } } // UserThreadPool.java public class ...
  • Java多线程 ThreadPoolExecutor自定义线程池
  • java Thread线程池ThreadPoolExecutor使用详解 作者:Matrix海子 出处:https://www.cnblogs.com/dolphin0520/p/3932921.html 该篇文章是我受益颇多,转载出来分享 一.Java中的ThreadPoolExecutorjava.uitl....
  • JAVA线程池提交方式 execute和 submit 两种提交执行的方式,那他们有什么区别? execute里面中的参数 是一个必须实现 Runnable 接口的实现类。从源码中我们就可以看出: public void execute(Runnable command) { ...
  • Java ThreadPoolExecutor线程池概述

    千次阅读 2018-06-13 17:07:47
    前言 在互联网的开发场景下,很多业务...java.util.concurrent包中提供了ThreadPoolExecutor类来管理线程,本文将介绍一下ThreadPoolExecutor类的使用。 为什么要使用线程池? 在执行一个异步任务或并发任...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 115,155
精华内容 46,062
关键字:

java threadpoolexecutor

java 订阅