1,ScheduledExecutorServic介绍
ScheduledExecutorService是ExecutorService的子接口,具备了延迟运行或定期执行任务的能力,
2,常用获取方式如下
- static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
创建一个可重用固定线程数的线程池且允许延迟运行或定期执行任务; - static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)
创建一个可重用固定线程数的线程池且线程池中的所有线程都使用ThreadFactory来创建,且允许延迟运行或定期执行任务; - static ScheduledExecutorService newSingleThreadScheduledExecutor()
创建一个单线程执行程序,它允许在给定延迟后运行命令或者定期地执行。 - static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory)
创建一个单线程执行程序,它可安排在给定延迟后运行命令或者定期地执行。
3,常用方法如下
- ScheduledFuture schedule(Callable callable, long delay, TimeUnit unit)
延迟时间单位是unit,数量是delay的时间后执行callable。 - ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
延迟时间单位是unit,数量是delay的时间后执行command。 - ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
延迟时间单位是unit,数量是initialDelay的时间后,每间隔period时间重复执行一次command。 - ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
创建并执行一个在给定初始延迟后首次启用的定期操作,随后,在每一次执行终止和下一次执行开始之间都存在给定的延迟。
4,延迟执行
4.1,newScheduledThreadPool(int corePoolSize)
延迟执行
package com.study.javaThreadPool.demo02_scheduledExecutorServic;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
@Slf4j
public class Demo01_NewScheduledThreadPool_Int {
public static void main(String[] args) {
//1,获取一个延迟执行线程池任务的对象
ScheduledExecutorService es = Executors.newScheduledThreadPool(3);
//创建多个任务对象,提交任务,每个任务延迟5秒执行
es.schedule(new MyRunnable1(1),5, TimeUnit.SECONDS);
log.info("ScheduledExecutorService执行结束");
es.shutdown();
}
}
@Slf4j
class MyRunnable1 implements Runnable{
private int id;
public MyRunnable1(int id) {
this.id = id;
}
@Override
public void run() {
//获取线程的名称
String name = Thread.currentThread().getName();
log.info(name +"执行了任务,编号为:"+id);
}
}
4.2,newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)
参与线程的创建
package com.study.javaThreadPool.demo02_scheduledExecutorServic;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
@Slf4j
public class Demo02_NewScheduledThreadPool_Int_ThreadFactory {
public static void main(String[] args) {
//1,获取一个延迟执行线程池任务的对象
ScheduledExecutorService es = Executors.newScheduledThreadPool(3, new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
return new Thread(r,"线程名称111");
}
});
//创建多个任务对象,提交任务,每个任务延迟5秒执行
es.schedule(new MyRunnable1(1),5, TimeUnit.SECONDS);
log.info("ScheduledExecutorService执行结束");
es.shutdown();
}
}
@Slf4j
class MyRunnable2 implements Runnable{
private int id;
public MyRunnable2(int id) {
this.id = id;
}
@Override
public void run() {
//获取线程的名称
String name = Thread.currentThread().getName();
log.info(name +"执行了任务,编号为:"+id);
}
}
4.3,newSingleThreadScheduledExecutor()
只创建一个线程
package com.study.javaThreadPool.demo02_scheduledExecutorServic;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
@Slf4j
public class Demo03_NewSingleThreadScheduledExecutor {
public static void main(String[] args) {
//1,获取一个延迟执行线程池任务的对象
ScheduledExecutorService es = Executors.newSingleThreadScheduledExecutor();
//创建多个任务对象,提交任务,每个任务延迟5秒执行
es.schedule(new MyRunnable1(1),5, TimeUnit.SECONDS);
log.info("ScheduledExecutorService执行结束");
es.shutdown();
}
}
@Slf4j
class MyRunnable3 implements Runnable{
private int id;
public MyRunnable3(int id) {
this.id = id;
}
@Override
public void run() {
//获取线程的名称
String name = Thread.currentThread().getName();
log.info(name +"执行了任务,编号为:"+id);
}
}
4.4,newSingleThreadScheduledExecutor(ThreadFactory threadFactory)
package com.study.javaThreadPool.demo02_scheduledExecutorServic;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
@Slf4j
public class Demo04_NewSingleThreadScheduledExecutor_ThreadFactory {
public static void main(String[] args) {
//1,获取一个延迟执行线程池任务的对象
ScheduledExecutorService es = Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
return new Thread(r,"线程名称222");
}
});
//创建多个任务对象,提交任务,每个任务延迟5秒执行
es.schedule(new MyRunnable1(1),5, TimeUnit.SECONDS);
log.info("ScheduledExecutorService执行结束");
es.shutdown();
}
}
@Slf4j
class MyRunnable4 implements Runnable{
private int id;
public MyRunnable4(int id) {
this.id = id;
}
@Override
public void run() {
//获取线程的名称
String name = Thread.currentThread().getName();
log.info(name +"执行了任务,编号为:"+id);
}
}
5,重复执行
5.1 scheduleAtFixedRate
scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
延迟时间单位是unit,数量是initialDelay的时间后,每间隔period时间重复执行一次command。
package com.study.javaThreadPool.demo02_scheduledExecutorServic;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
@Slf4j
public class Demo05_ScheduleAtFixedRate {
public static void main(String[] args) {
//1,获取一个延迟执行线程池任务的对象
ScheduledExecutorService es = Executors.newScheduledThreadPool(1);
//创建多个任务对象,提交任务,每个任务延迟5秒执行
MyRunnable5 runnble = new MyRunnable5(1);
/**
* 参数数目
* 1:运行任务
* 2:初始等待时间
* 3:间隔时间
* 4:时间单位
*
* 运行1秒后每个5秒重复执行
*/
es.scheduleAtFixedRate(runnble,1,5, TimeUnit.SECONDS);
log.info("ScheduledExecutorService执行结束");
}
}
@Slf4j
class MyRunnable5 implements Runnable{
private int id;
public MyRunnable5(int id) {
this.id = id;
}
@Override
public void run() {
//获取线程的名称
String name = Thread.currentThread().getName();
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info(name +"执行了任务,编号为:"+id);
}
}
5.2 scheduleWithFixedDelay
scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
创建并执行一个在给定初始延迟后首次启用的定期操作,随后,在每一次执行终止和下一次执行开始之间都存在给定的延迟。
package com.study.javaThreadPool.demo02_scheduledExecutorServic;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
@Slf4j
public class Demo06_ScheduleWithFixedDelay {
public static void main(String[] args) {
//1,获取一个延迟执行线程池任务的对象
ScheduledExecutorService es = Executors.newScheduledThreadPool(1);
//创建多个任务对象,提交任务,每个任务延迟5秒执行
MyRunnable6 runnble = new MyRunnable6(1);
/**
* 参数数目
* 1:运行任务
* 2:初始等待时间
* 3:间隔时间
* 4:时间单位
*
* 运行1秒后每个5秒重复执行
*/
es.scheduleWithFixedDelay(runnble,1,5, TimeUnit.SECONDS);
log.info("ScheduledExecutorService执行结束");
}
}
@Slf4j
class MyRunnable6 implements Runnable{
private int id;
public MyRunnable6(int id) {
this.id = id;
}
@Override
public void run() {
//获取线程的名称
String name = Thread.currentThread().getName();
log.info(name +"执行了任务,编号为:"+id);
}
}