必威-必威-欢迎您

必威,必威官网企业自成立以来,以策略先行,经营致胜,管理为本的商,业推广理念,一步一个脚印发展成为同类企业中经营范围最广,在行业内颇具影响力的企业。

Executor框架中还提供了四种线程池必威:,线程池

2019-09-19 00:20 来源:未知

然后是scheduleWithFixedDelay:

if (isShutdown() &&

publicstaticvoidmain(String[] args) { ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool;//延迟3秒执行,只执行一次((ScheduledExecutorService) scheduledThreadPool).schedule(newRunnable() { @Overridepublicvoidrun() { System.out.println("延迟========"); } },3,TimeUnit.SECONDS);//延迟1秒后每隔两秒执行一次((ScheduledExecutorService) scheduledThreadPool).scheduleAtFixedRate(newRunnable() { @Overridepublicvoidrun() { System.out.println("执行============"); } },1,2,TimeUnit.SECONDS);//单位是秒}

}

自JDK1.5开始,JDK提供了ScheduledThreadPoolExecutor类来支持周期性任务的调度。在这之前的实现需要依靠Timer和TimerTask或者其它第三方工具来完成。但Timer有不少的缺陷:

第四种线程池是ScheduledExecutorService,我平时没有用过,他的最大优点除了线程池的特性以外,可以实现循环或延迟任务。

// 1. 入参校验,包括空指针、数字范围

1、该线程池可以设置核心线程数量,最大线程数与newCachedThreadPool一样,都是Integer.MAX_VALUE。

newSingleThreadExecutor

DelayedWorkQueue

DelayedWorkQueue底层依赖DelayQueue,而DelayQueue底层又依赖PriorityQueue,所以DelayedWorkQueue是一个基于堆的数据结构。在执行定时任务的时候,每个任务的执行时间都不同,所以DelayedWorkQueue的工作就是按照执行时间的升序来排列,执行时间距离当前时间越近的任务在队列的前面,并且每次出队时能够保证取出的任务是当前队列中下次执行时间最小的任务。

由于DelayedWorkQueue底层完全依赖DelayQueue,所以可以参考上篇文章关于DelayQueue的分析。

  • 延迟时间 = 下一个任务的开始时间。

addWorker(null, true);

newCachedThreadPool:可缓存的线程池

for(int i = 1; i <= 10; i ++) {

通过如上的介绍,可以对比一下Timer和ScheduledThreadPoolExecutor:

必威 1这里写图片描述

}, 1000L, 1000L, TimeUnit.MILLISECONDS);

除此之外,我们也可以自定义ThreadFactory,并根据自己的需要来操作线程,下面是实例代码:

is cancelled: true

ScheduledThreadPoolExecutor继承ThreadPoolExecutor来重用线程池的功能,它的实现方式如下:

经过短暂的喜悦,我发现我的希望落空了,出现了两个问题:

*/

publicstaticvoidmain(String[] args) { ExecutorService service =newThreadPoolExecutor(5,5,0L, TimeUnit.MILLISECONDS,newSynchronousQueue(),newThreadFactory() { @OverridepublicThread newThread(Runnable r) { Thread t =newThread; System.out.println("我是线程"+ r);returnt; } } );//用lambda表达式编写方法体中的逻辑Runnablerun= () -> {try{ Thread.sleep; System.out.println(Thread.currentThread().getName() +"正在执行"); }catch(InterruptedException e) { e.printStackTrace(); } };for(inti =0; i <5; i++) { service.submit; }//这里一定要做关闭service.shutdown();}

newScheduledThreadPool方法:

源码深入分析

先看一下ScheduledThreadPoolExecutor类结构图:

必威 2image.png

ScheduledThreadPoolExecutor继承自ThreadPoolExecutor,实现了ScheduledExecutorService接口,该接口定义了schedule等任务调度的方法。

同时ScheduledThreadPoolExecutor有两个重要的内部类:DelayedWorkQueue和ScheduledFutureTask。DelayeddWorkQueue是一个阻塞队列,而ScheduledFutureTask继承自FutureTask,并且实现了Delayed接口。

ScheduledThreadPoolExecutor有4个构造方法:

public ScheduledThreadPoolExecutor(int corePoolSize) { super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS, new DelayedWorkQueue;}public ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory) { super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS, new DelayedWorkQueue(), threadFactory);}public ScheduledThreadPoolExecutor(int corePoolSize, RejectedExecutionHandler handler) { super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS, new DelayedWorkQueue(), handler);}public ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory, RejectedExecutionHandler handler) { super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS, new DelayedWorkQueue(), threadFactory, handler);}

因为ScheduledThreadPoolExecutor继承自ThreadPoolExecutor,所以这里都是调用的ThreadPoolExecutor类的构造方法。这里有三点需要注意:

  1. 使用DelayedWorkQueue作为阻塞队列,并没有像ThreadPoolExecutor类一样开放给用户进行自定义设置。该队列是ScheduledThreadPoolExecutor类的核心组件,后面详细介绍。
  2. 这里没有向用户开放maximumPoolSize的设置,原因是DelayedWorkQueue底层使用DelayedQueue,而DelayedQueue底层使用PriorityQueue,PriorityQueue最大大小为Integer.MAX_VALUE,也就是说队列不会装满,maximumPoolSize参数即使设置了也不会生效。
  3. worker线程没有回收时间,原因跟第2点一样,因为不会触发回收操作。所以这里的线程存活时间都设置为0。

当我们创建出一个调度线程池以后,就可以开始提交任务了。

首先是schedule方法,该方法是指任务在指定延迟时间到达后触发,只会执行一次。schedule方法的代码如下:

public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) { if (command == null || unit == null) throw new NullPointerException(); if (delay < 0) delay = 0; long triggerTime = now() + unit.toNanos; RunnableScheduledFuture<?> t = decorateTask(command, new ScheduledFutureTask<Boolean>(command, null, triggerTime)); delayedExecute; return t;}public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) { if (callable == null || unit == null) throw new NullPointerException(); if (delay < 0) delay = 0; long triggerTime = now() + unit.toNanos; RunnableScheduledFuture<V> t = decorateTask(callable, new ScheduledFutureTask<V>(callable, triggerTime)); delayedExecute; return t;}

两个重载的schedule方法只是传入的第一个参数不同,可以是Runnable对象或者Callable对象。会把传入的任务封装成一个RunnableScheduledFuture对象,其实也就是ScheduledFutureTask对象,decorateTask默认什么功能都没有做,子类可以重写该方法:

/** * 修改或替换用于执行 runnable 的任务。此方法可重写用于管理内部任务的具体类。默认实现只返回给定任务。 */protected <V> RunnableScheduledFuture<V> decorateTask( Runnable runnable, RunnableScheduledFuture<V> task) { return task;}/** * 修改或替换用于执行 callable 的任务。此方法可重写用于管理内部任务的具体类。默认实现只返回给定任务。 */protected <V> RunnableScheduledFuture<V> decorateTask( Callable<V> callable, RunnableScheduledFuture<V> task) { return task;}

然后,通过调用delayedExecute方法来延时执行任务。最后,返回一个ScheduledFuture对象。

该方法设置了执行周期,下一次执行时间相当于是上一次的执行时间加上period,它是采用固定的频率来执行任务:

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) { if (command == null || unit == null) throw new NullPointerException(); if (period <= 0) throw new IllegalArgumentException(); if (initialDelay < 0) initialDelay = 0; long triggerTime = now() + unit.toNanos(initialDelay); RunnableScheduledFuture<?> t = decorateTask(command, new ScheduledFutureTask<Object>(command, null, triggerTime, unit.toNanos; delayedExecute; return t;}

该方法设置了执行周期,与scheduleAtFixedRate方法不同的是,下一次执行时间是上一次任务执行完的系统时间加上period,因而具体执行时间不是固定的,但周期是固定的,是采用相对固定的延迟来执行任务:

public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) { if (command == null || unit == null) throw new NullPointerException(); if (delay <= 0) throw new IllegalArgumentException(); if (initialDelay < 0) initialDelay = 0; long triggerTime = now() + unit.toNanos(initialDelay); RunnableScheduledFuture<?> t = decorateTask(command, new ScheduledFutureTask<Boolean>(command, null, triggerTime, unit.toNanos; delayedExecute; return t;}

注意这里的unit.toNanos,这里把周期设置为负数来表示是相对固定的延迟来执行。

scheduleAtFixedRate把周期延迟时间传入ScheduledFutureTask中,而scheduleWithFixedDelay却设置成负数传入,区别在哪里呢?看一下ScheduledFutureTask中,运行周期任务的方法runPeriodic的源码:

private void runPeriodic() { boolean ok = ScheduledFutureTask.super.runAndReset(); boolean down = isShutdown(); // Reschedule if not cancelled and not shutdown or policy allows if (ok && (!down || (getContinueExistingPeriodicTasksAfterShutdownPolicy() && !isTerminating { long p = period; if  // 大于0是scheduleAtFixedRate方法,表示执行时间是根据初始化参数计算的 time += p; else // 小于0是scheduleWithFixedDelay方法,表示执行时间是根据当前时间重新计算的 time = now() - p; ScheduledThreadPoolExecutor.super.getQueue().add; } // This might have been the final executed delayed // task. Wake up threads to check. else if  interruptIdleWorkers();}

也就是说当使用scheduleAtFixedRate方法提交任务时,任务后续执行的延迟时间都已经确定好了,分别是initialDelay,initialDelay

  • period,initialDelay + 2 * period以此类推。

而调用scheduleWithFixedDelay方法提交任务时,第一次执行的延迟时间为initialDelay,后面的每次执行时间都是在前一次任务执行完成以后的时间点上面加上period延迟执行。

ScheduledExecutorService的用法主要有三个:

sft.outerTask = t;

必威 3

static class MyThread implements Runnable {

  1. Timer是单线程模式,如果在执行任务期间某个TimerTask耗时较久,那么就会影响其它任务的调度;
  2. Timer的任务调度是基于绝对时间的,对系统时间敏感;
  3. Timer不会捕获执行TimerTask时所抛出的异常,由于Timer是单线程,所以一旦出现异常,则线程就会终止,其他任务也得不到执行。
  • 延迟时间 = 下一次任务的开始时间。

null,

publicstaticExecutorServicenewCachedThreadPool(){returnnewThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,newSynchronousQueue;}

Executors类是Java提供的一个专门用于创建线程池的类。

Timer ScheduledThreadPoolExecutor
单线程 多线程
单个任务执行时间影响其他任务调度 多线程,不会影响
基于绝对时间 基于相对时间
一旦执行任务出现异常不会捕获,其他任务得不到执行 多线程,单个任务的执行不会影响其他线程

<h2>ScheduledExecutorService 和 Timer 的区别</h2>

}

publicstaticScheduledExecutorServicenewScheduledThreadPool(intcorePoolSize){returnnewScheduledThreadPoolExecutor(corePoolSize);}publicScheduledThreadPoolExecutor(intcorePoolSize){super(corePoolSize, Integer.MAX_VALUE,0, NANOSECONDS,newDelayedWorkQueue;}publicThreadPoolExecutor(intcorePoolSize,intmaximumPoolSize,longkeepAliveTime, TimeUnit unit, BlockingQueue workQueue){this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler); }

4.scheduleAtFixedRate方法,scheduleAtFixedRate方法跟scheduleWithFixedDelay类似。唯一的区别是scheduleWithFixedDelay是在线程全部执行完毕之后开始计算时间的,而scheduleAtFixedRate是在线程开始执行的时候计算时间的,所以scheduleAtFixedRate有时会产生不是定时执行的感觉。

所以,在JDK1.5之后,没什么理由继续使用Timer进行任务调度了。

private ScheduledExecutorService mScheduledExecutorService = Executors.newScheduledThreadPool(4, new ThreadFactory() { @Override public Thread newThread(@NonNull Runnable r) { return new Thread{ @Override public void run() { Log.e("lzp", "newThread"); super.run(); Log.e("lzp", "newThread over"); } }; } });

必威 4

1、该线程池的核心线程数量是0,线程的数量最高可以达到Integer 类型最大值;

4-thread-call-runner-0

ScheduledFutureTask

从上面几个调度方法的源码可以得知,任务都被封装成ScheduledFutureTask对象,下面看一下ScheduledFutureTask的源码。

ScheduledFutureTask继承自FutureTask并实现了RunnableScheduledFuture接口,构造方法如下:

/** * Creates a one-shot action with given nanoTime-based trigger time. */ScheduledFutureTask(Runnable r, V result, long ns) { super(r, result); this.time = ns; this.period = 0; this.sequenceNumber = sequencer.getAndIncrement();}/** * Creates a periodic action with given nano time and period. */ScheduledFutureTask(Runnable r, V result, long ns, long period) { super(r, result); this.time = ns; this.period = period; this.sequenceNumber = sequencer.getAndIncrement();}/** * Creates a one-shot action with given nanoTime-based trigger. */ScheduledFutureTask(Callable<V> callable, long ns) { super; this.time = ns; this.period = 0; this.sequenceNumber = sequencer.getAndIncrement();}

这里面有几个重要的属性,下面来解释一下:

  1. time:下次任务执行的时间;
  2. period:执行周期;
  3. sequenceNumber:保存任务被添加到ScheduledThreadPoolExecutor中的序号。

在schedule方法中,创建完ScheduledFutureTask对象之后,会执行delayedExecute方法来执行任务。

private void delayedExecute(Runnable command) { if (isShutdown { reject; return; } // Prestart a thread if necessary. We cannot prestart it // running the task because the task  shouldn't be // run yet, so thread will just idle until delay elapses. if (getPoolSize() < getCorePoolSize prestartCoreThread(); super.getQueue().add;}

这里的关键点其实就是super.getQueue().add行代码,该行代码把任务添加到DelayedWorkQueue延时队列中。

通过上面的逻辑,我们把提交的任务成功加入到了延迟队列中。回顾一下线程池的执行过程:当线程池中的工作线程启动时,不断地从阻塞队列中取出任务并执行,当然,取出的任务实现了Runnable接口,所以是通过调用任务的run方法来执行任务的。

这里的任务类型是ScheduledFutureTask,所以下面看一下ScheduledFutureTask的run方法:

public void run() { if (isPeriodic runPeriodic(); else ScheduledFutureTask.super.run();}private void runPeriodic() { boolean ok = ScheduledFutureTask.super.runAndReset(); boolean down = isShutdown(); // Reschedule if not cancelled and not shutdown or policy allows if (ok && (!down || (getContinueExistingPeriodicTasksAfterShutdownPolicy() && !isTerminating { long p = period; if  time += p; else time = now() - p; ScheduledThreadPoolExecutor.super.getQueue().add; } // This might have been the final executed delayed // task. Wake up threads to check. else if  interruptIdleWorkers();}

如果是周期性任务,调用FutureTask中的runAndReset方法执行任务,runAndReset方法不会设置执行结果,所以可以重复执行任务,任务执行完成后设置任务的下次执行时间,最后把该任务添加到延迟队列中;如果不是周期性任务,则直接调用FutureTask中的run方法执行。

至此,已经把任务从创建、提交、执行的流程说完了,下面看一下延迟队列DelayedWorkQueue。

最后带上源码链接,有问题或者建议可以留言。

long delay, TimeUnit unit);

用法:

}

  1. 将任务封装成ScheduledFutureTask对象,ScheduledFutureTask基于相对时间,不受系统时间的改变所影响;
  2. ScheduledFutureTask实现了java.lang.Comparable接口和java.util.concurrent.Delayed接口,所以有两个重要的方法:compareTo和getDelay。compareTo方法用于比较任务之间的优先级关系,如果距离下次执行的时间间隔较短,则优先级高;getDelay方法用于返回距离下次任务执行时间的时间间隔;
  3. ScheduledThreadPoolExecutor定义了一个DelayedWorkQueue,它是一个有序队列,会按照每个任务距离下次执行时间间隔的大小来排序;
  4. ScheduledFutureTask继承自FutureTask,可以通过返回Future对象来获取执行的结果。

Demo下载链接

  1. scheduleWithFixedDelay

用法:

下面就分析Executors的静态方法:

这里面我传入ThreadFactory加工过后的Runnable,我们推断,最后应该会打印两句:first task 和 嘿嘿嘿,运行一下看看是不是符合我们的期望:

System.out.println("task finish time: " + format(System.currentTimeMillis;

publicstaticvoidmain(String[] args){//定义ExecutorService实例ExecutorService cachedThreadPool = Executors.newCachedThreadPool();for(inti =0; i <10; i++) {finalintindex = i;try{ Thread.sleep(index *1000); }catch(InterruptedException e) { e.printStackTrace(); }//调用execute方法cachedThreadPool.execute(newRunnable() {@Overridepublicvoidrun(){ System.out.println(Thread.currentThread() +":"+ index); } }); }}

e.printStackTrace();

必威 5这里写图片描述

基本作用

运行代码后,控制行会输出五行 “我是线程java.util.concurrent.ThreadPoolExecutor。。。。。”的信息,也证明了我们自定义的ThreadFactory起到了作用。

ExecutorService es = Executors.newFixedThreadPool(2, new ThreadFactoryBuilder().setNameFormat("thread-call-runner-%d").build());

因为在线程池的构造方法中,有ThreadFactory参数,所以就来简单介绍一个ThreadFactory:

/**

publicstaticvoidmain(String[] args){ ExecutorService cachedThreadPool = Executors.newFixedThreadPool;for(inti =0; i <10; i++) {finalintindex = i;try{ Thread.sleep(index *1000); }catch(InterruptedException e) { e.printStackTrace(); } cachedThreadPool.execute(newRunnable() {@Overridepublicvoidrun(){ System.out.println(Thread.currentThread() +":"+ index); } }); }}

}

果然结果没有让我们失望。

* 带延迟时间的调度,循环执行,固定延迟

线程池特点:

2.cancel在schedule中的使用:

例如上面的代码,我在参数Runnable对象的run方法后,增加了一句log打印。

System.out.println("task finish time: " + format(System.currentTimeMillis;

newFixedThreadPool:定长线程池

final LinkedBlockingDeque deque = new LinkedBlockingDeque();

在代码中已经有注释说明这三个方法的用法,重点是scheduleAtFixedRate和scheduleWithFixedDelay的区别,下面看具体看一下Log信息:

throw new NullPointerException();

每天都在分享文章,也每天都有人想要我出来给大家分享下怎么去学习Java。大家都知道,我们是学Java全栈的,大家就肯定以为我有全套的Java系统教程。没错,我是有Java全套系统教程,进扣裙974所示,进群的时候记得表明自己想要学习什么,不要用小号,这样小编才好给你们发定向资源,今天小编就免费送!~

}

首先是scheduleAtFixedRate:

}

2、使用的列队是LinkedBlockingQueue,表示如果当前线程数小于核心线程数,那么即使有空闲线程也不会复用线程去执行任务,而是创建新的线程去执行任务。如果当前执行任务数量大于核心线程数,此时再提交任务就在队列中等待,直到有可用线程。

return new DelegatedScheduledExecutorService

带着疑问我开始查看源码,经过仔细的思考,找到了问题的原因,这里就简单解释一下:

ScheduledThreadPoolExecutor构造方法最终调用的是ThreadPoolExecutor构造方法

上面的代码因为每次循环都是隔一秒执行,这个时间足够之前的线程工作完毕,并在新循环中复用这个线程,程序的运行结果如下:

public String call() throws Exception {

newSingleThreadExecutor:单线程池,同时只有一个线程在跑。newCachedThreadPool() :回收型线程池,可以重复利用之前创建过的线程,运行线程最大数是Integer.MAX_VALUE。newFixedThreadPool() :固定大小的线程池,跟回收型线程池类似,只是可以限制同时运行的线程数量

Thread.sleep;

publicstaticExecutorServicenewFixedThreadPool(intnThreads){returnnewThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,newLinkedBlockingQueue;}

try {

Timer的内部只有一个线程,如果有多个任务的话就会顺序执行,这样我们的延迟时间和循环时间就会出现问题。

至此,除了DelayedWorkQueue延迟队列的源码还未分析,其他的我们都分析完了。

自定义ThreadFactory

}

从log上看,每一个任务的时间间隔是4秒,而不是我们设置的间隔1秒,任务要耗时3秒,两个时间相加正好是4秒,那么之前代码注释的解释就说的通了:以上一次任务的结束时间

long initialDelay,

四种线程池

}, 10, TimeUnit.SECONDS);

mScheduledExecutorService.schedule(threadFactory.newThread(new Runnable() { @Override public void run() { Log.e("lzp", "first task"); } }), 1, TimeUnit.SECONDS);

直白地讲,scheduleAtFixedRate()为固定频率,scheduleWithFixedDelay()为固定延迟。固定频率是相对于任务执行的开始时间,而固定延迟是相对于任务执行的结束时间,这就是他们最根本的区别!

源码:

ExecutorService的初始化可以使用Executors类的静态方法。

从log上看,我们的循环任务严格按照每一秒发起一次,sleep对于任务的开启是没有影响的,也就是以上一个任务的开始时间

既然这两个方法都是对任务循环执行,那么他们又有何区别呢?通过jdk文档我们找到了答案。

通过前面的文章,我们学习了Executor框架中的核心类ThreadPoolExecutor ,对于线程池的核心调度机制有了一定的了解,并且成功使用ThreadPoolExecutor 创建了线程池。

while (!deque.isEmpty()) {

必威 6这里写图片描述

if (delay <= 0)

而在Java中,除了ThreadPoolExecutor ,Executor框架中还提供了四种线程池,这四种线程池都是直接或间接配置ThreadPoolExecutor的参数实现的,对于ThreadPoolExecutor类不熟悉的读者可以参考Java并发编程:Java线程池核心ThreadPoolExecutor的使用和原理分析

} catch (TimeoutException e) {

线程工厂,可以对传入的Runnable进行加工操作,典型的工厂模式,需要实现newThread(@NonNull Runnable r) 方法返回加工后的线程。

// 4. 如果任务添加到队列之后,线程池状态是运行状态,需要提前启动线程

源码:

首先判断线程池的基本大小,如果基本大小还没满,那么直接创建新的线程执行任务,否则进行下一步

我在Runnable参数的run方法前后增加了打印,于是我迫不及待的运行了app:

System.out.println("task finish time: " + format(System.currentTimeMillis;

Thread[pool-1-thread-1,5,main]:0Thread[pool-1-thread-1,5,main]:1Thread[pool-1-thread-1,5,main]:2Thread[pool-1-thread-1,5,main]:3Thread[pool-1-thread-1,5,main]:4Thread[pool-1-thread-1,5,main]:5Thread[pool-1-thread-1,5,main]:6Thread[pool-1-thread-1,5,main]:7Thread[pool-1-thread-1,5,main]:8Thread[pool-1-thread-1,5,main]:9

Thread.sleep(3000l);

哎???第四个是什么来着,不知道你有没有想起来,反正我是没记住,结果面试的时候就栽了个跟头。

}

Thread newThread(Runnabler);

public void test05() throws Exception {

看一下具体的代码:

* Same as prestartCoreThread except arranges that at least one

3、线程处于闲置状态超过60s的话,就会被销毁。

}, 0, 5, TimeUnit.SECONDS);

必威 7这里写图片描述

必威 8

ThreadFactory是一个接口类,也就是我们经常说的线程工厂,只有一个方法,可以用于创建线程:

5

弄懂了内部的机制,刚才的问题就全都弄明白了,还发现android的设计者是不希望我们通过这种方法去影响Runnable的实现方法,但是可以去改变线程Thread对象的属性,例如优先级等等。

e.printStackTrace();

newSingleThreadExecutor:单线程线程池

!Thread.currentThread().isInterrupted()

public class MainActivity extends AppCompatActivity { // 通过静态方法创建ScheduledExecutorService的实例 private ScheduledExecutorService mScheduledExecutorService = Executors.newScheduledThreadPool; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // 延时任务 mScheduledExecutorService.schedule(threadFactory.newThread(new Runnable() { @Override public void run() { Log.e("lzp", "first task"); } }), 1, TimeUnit.SECONDS); // 循环任务,按照上一次任务的发起时间计算下一次任务的开始时间 mScheduledExecutorService.scheduleAtFixedRate(new Runnable() { @Override public void run() { Log.e("lzp", "first:" + System.currentTimeMillis; try { Thread.sleep; } catch (InterruptedException e) { e.printStackTrace(); } } }, 1, 1, TimeUnit.SECONDS); // 循环任务,以上一次任务的结束时间计算下一次任务的开始时间 mScheduledExecutorService.scheduleWithFixedDelay(new Runnable() { @Override public void run() { Log.e("lzp", "scheduleWithFixedDelay:" + System.currentTimeMillis; try { Thread.sleep; } catch (InterruptedException e) { e.printStackTrace(); } } }, 1, 1, TimeUnit.SECONDS); }}

入参校验,包括空指针、数字范围

必威 9

public void run() {

由于线程池的源码还是很多的,这里就不具体的解释了,想具体了解的朋友可以自己去查看源码或者网上查看资料。

*/

源码:

System.out.println(deque.poll() + "-" + Thread.currentThread().getName());

1、Log.e("lzp", "newThread over") 这一句为什么没有执行???2、为什么ThreadFactory.newThread() 只执行了四次。

然后,我们对其内部的实现原理和源代码做了初步的分析,知道了其和普通线程池是不同的地方在于:阻塞队列和创建线程的方式。

2、创建ThreadPoolExecutor实例时传过去的参数是一个SynchronousQueue实例,说明在创建任务时,若存在空闲线程就复用它,没有的话再新建线程。

public void test01() throws Exception {

ScheduledExecutorService是线程池,所以就不会出现这个情况,在对延迟任务和循环任务要求严格的时候,就需要考虑使用ScheduledExecutorService了。

// 3. 如果任务添加到队列之后,线程池状态变为非运行状态,

引言

return new FinalizableDelegatedExecutorService

1、线程池只会创建最大并发数(corePoolSize)的Worker对象。

2、Worker对象内部包含了Thread和Runnable信息。

3、添加任务时:如果Worker没有到最大值,就创建Worker(通过ThreadFactory的newThread新建了Thread,所以Thread的数量等于Worker数量);如果已经是最大,就把任务放到队列中。

3、任务执行中:如果Worker的Runnable不为空,执行Runnable,执行结束,Runnable设置为空;如果Worker的Runnable为空,从队列中取出任务执行。

4、Runnable运行结束,线程池内部直接退出了线程。

long delay,

源码:

如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!

然后我有了一个想法,我要给线程池所有的线程都加工一下:

}

newScheduledThreadPool的方法不是直接返回一个ThreadPoolExecutor实例,而是通过有定时功能的ThreadPoolExecutor,也就是ScheduledThreadPoolExecutor 来返回ThreadPoolExecutor实例,从源码中可以看出:

newFixedThreadPool方法:

android的线程池主要有四个:

try {

publicstaticExecutorServicenewSingleThreadExecutor(){returnnewFinalizableDelegatedExecutorService (newThreadPoolExecutor(1,1,0L, TimeUnit.MILLISECONDS,newLinkedBlockingQueue;}

public static ExecutorService newFixedThreadPool(int nThreads) {

private ThreadFactory threadFactory = new ThreadFactory() { @Override public Thread newThread(@NonNull final Runnable r) { return new Thread() { @Override public void run() { r.run(); Log.e("lzp", "嘿嘿嘿"); } }; } };

}

四种线程池分别是:newCachedThreadPool、newFixedThreadPool 、newScheduledThreadPool 和newSingleThreadExecutor ,下面对这几个线程池一一讲解。

判断线程池中的阻塞队列是是否已满,没满的话存到阻塞队列里等待执行,否则执行下一步(所以如果是个无界的阻塞队列,那么这一步永远都成立)

然后修改MainActivity的调用:

必威 10

1、线程池的最大线程数等于核心线程数,并且线程池的线程不会因为闲置超时被销毁。

}

这一篇我们先去弄懂了ScheduledExecutorService的特性和用法,然后了解了ThreadFactory的用法,最后两者结合使用,分析并解决可能出现的问题。

运行看到的结果和Runnable基本相同,唯一的区别在于future.get()能拿到Callable返回的真实结果。

和newFixedThreadPool类似,只是一直只有一个线程在工作,这里就不贴代码了。

public static ScheduledExecutorService newSingleThreadScheduledExecutor() {

TimeUnit unit) {

用法:

}

ensurePrestart();

2、该线程池采用的队列是DelayedWorkQueue,具有延迟和定时的作用。

System.out.println("cancel result: " + result.cancel(true));

}

publicstaticExecutorServicenewSingleThreadExecutor(ThreadFactory threadFactory){returnnewFinalizableDelegatedExecutorService (newThreadPoolExecutor(1,1,0L, TimeUnit.MILLISECONDS,newLinkedBlockingQueue(), threadFactory));}publicstaticExecutorServicenewCachedThreadPool(ThreadFactory threadFactory){returnnewThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,newSynchronousQueue(), threadFactory);}publicstaticScheduledExecutorServicenewScheduledThreadPool(intcorePoolSize, ThreadFactory threadFactory){returnnewScheduledThreadPoolExecutor(corePoolSize, threadFactory);}publicstaticExecutorServicenewFixedThreadPool(intnThreads, ThreadFactory threadFactory){returnnewThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,newLinkedBlockingQueue(), threadFactory);}

}

try {

用法:

System.out.println("exec");

else {

从源码就可以看出,该线程池基本就是只有一个线程数的newFixedThreadPool,它只有一个线程在工作,所有任务按照指定顺序执行。

@Override

while {

定义一个线程数为3的线程池,循环10次执行,可以发现运行的线程永远只有三个,结果如下:

@Override

接下来我们看看scheduleWithFixedDelay()方法,主要做了3件事情:

默认情况下,ThreadPoolExecutor构造器传入的ThreadFactory 参数是Executors类中的defaultThreadFactory(),相当于一个线程工厂,帮我们创建了线程池中所需的线程。

} catch (InterruptedException e) {

long delay, TimeUnit unit);

newCachedThreadPool的方法中是返回一个ThreadPoolExecutor实例,从源码中可以看出该线程池的特点:

new LinkedBlockingQueue());

}

四种线程池的使用就说到这里了,值得说明的是,除了上面的参数外,Executors类中还给这四种线程池提供了可传ThreadFactory的重载方法,以下是它们的源码:

线程池的使用

ScheduledFuture future = service.schedule -> {

newScheduledThreadPool:支持定时的定长线程池

4

将Runnable包装成RunnableScheduledFuture

后记:对于大部分转行的人来说,找机会把自己的基础知识补齐,边工作边补基础知识,真心很重要。“我们相信人人都可以成为一个程序员,现在开始,找个师兄,带你入门,学习的路上不再迷茫。这里是ja+va修真院,初学者转行到互联网行业的聚集地。

8

在schedule Runnable的基础上,我们将Runnable改为Callable来看一下。@Test public void test_schedule4Callable() throws Exception {

Thread[pool-1-thread-1,5,main]:0Thread[pool-1-thread-2,5,main]:1Thread[pool-1-thread-3,5,main]:2Thread[pool-1-thread-1,5,main]:3Thread[pool-1-thread-2,5,main]:4Thread[pool-1-thread-3,5,main]:5Thread[pool-1-thread-1,5,main]:6Thread[pool-1-thread-2,5,main]:7Thread[pool-1-thread-3,5,main]:8Thread[pool-1-thread-1,5,main]:9

ExecutorService es = Executors.newFixedThreadPool(2, new ThreadFactoryBuilder().setNameFormat("thread-call-runner-%d").build());

*/

而ExecutorService接口是Executor接口的子接口,用来管理线程的执行。

我们知道,Java的定时调度可以通过Timer&TimerTask来实现。由于其实现的方式为单线程,因此从JDK1.3发布之后就一直存在一些问题,大致如下:

Future result = ses.schedule(new Callable() {

多个任务的执行是串行的,性能较低

public MyThread(int index) {

如何使用

for(int i = 1; i <= 5000; i ++) {

* 调度之后可通过Future.get()阻塞直至任务执行完毕,并且可以获取执行结果

}

ScheduledExecutorService service = Executors.newScheduledThreadPool;

// catch TimeoutException的话线程里的代码还是会执行下去

remove

}

if (wc < corePoolSize)

11

上述代码达到的效果应该是这样的:延迟执行时间为1秒,任务执行3秒,任务只执行一次,同时通过Future.get()阻塞直至任务执行完毕。

} catch (Exception e) {

}

(new ScheduledThreadPoolExecutor(1));

TAG标签:
版权声明:本文由必威发布于必威-编程,转载请注明出处:Executor框架中还提供了四种线程池必威:,线程池