Runnable、Callable、Executor、ExecutorService、ScheduledExecutorService、Executors

最新推荐文章于 2024-08-21 16:47:09 发布
最新推荐文章于 2024-08-21 16:47:09 发布
阅读量1k 收藏
点赞数
分类专栏： java java.util.concurrent
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/undergrowth/article/details/44003877
版权

  

   本文是关于java.util.concurrent类库中任务、执行器(调度器/线程池)的相关测试用例，记录学习的脚步


使用pd画了个 主要的类图




主要测试类如下


RunnableTest.java

/**
 * 
 */
package com.undergrowth.util.concurrent;

import org.junit.Test;

/**
 * 测试Runnable 可执行的任务--> 本身并不执行，需外部调用执行
 * 
 * @author undergrowth
 * 
 */
public class RunnableTest {

	private Runnable runnable;
	private Thread thread;

	/**
	 * 使用匿名类的方式构建可执行的任务
	 */
	@Test
	public void testRun() {
		// 匿名类
		runnable = new Runnable() {

			public void run() {
				// TODO Auto-generated method stub
				System.out.println("内部线程名:" + Thread.currentThread().getName());
				System.out.println("内部线程输出:" + "发生什么");
			}
		};
		// 执行任务
		runnable.run();
		System.out.println("外部线程名:" + Thread.currentThread().getName());
	}

	/**
	 * 使用单独的线程构建可执行的任务 注意 start()与run()的区别
	 */
	@Test
	public void testThread() {
		// 构建另外线程执行
		thread = new Thread(new Runnable() {

			public void run() {
				// TODO Auto-generated method stub
				System.out.println("内部线程名:" + Thread.currentThread().getName());
				// System.out.println("内部线程输出:" + "发生什么");
			}
		}, "内部线程名称");
		// 使用start启动新线程 并发执行
		thread.start();
		System.out.println("外部线程名:" + Thread.currentThread().getName());
		// 使用run则 使用外部线程执行任务
		thread.run();
	}

}

/**
 * Runnable的实现类
 * @author undergrowth
 *
 */
class RunnableConcrete implements Runnable{

	public void run() {
		// TODO Auto-generated method stub
		System.out.println(Thread.currentThread().getName()+"\t"+RunnableConcrete.class.getSimpleName());
	}
	
}


结果

testRun()

内部线程名:main
内部线程输出:发生什么
外部线程名:main


testThread() 

外部线程名:main
内部线程名:内部线程名称
内部线程名:main



CallableTest.java

/**
 * 
 */
package com.undergrowth.util.concurrent;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;

import org.junit.Test;

/**
 * Callable-->返回结果并且可能抛出异常的任务
 * 
 * @author undergrowth
 * 
 */
public class CallableTest {

	private Callable<String> callable;

	/**
	 * 使用调用者调用任务,同步执行
	 */
	@Test
	public void synCallable() {
		callable = new CallableConcrete<String>();
		try {
			System.out.println(callable.call());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * 使用线程池进行任务调度
	 */
	@Test
	public void asynCallable(){
		callable = new CallableConcrete<String>();
		try {
			System.out.println(Executors.newCachedThreadPool().submit(callable).get());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		};
	}
}

/**
 * Callable的实现类
 * 
 * @author undergrowth
 * 
 */
class CallableConcrete<V> implements Callable<V> {

	@SuppressWarnings("unchecked")
	public V call() throws Exception {
		// TODO Auto-generated method stub
		return (V)(Thread.currentThread().getName()+"\t"+CallableConcrete.class.getSimpleName());
	}

}


结果

syncCallable()

main	CallableConcrete


asynCallable() 

pool-1-thread-1	CallableConcrete



可执行者

ExecutorTest.java

/**
 * 
 */
package com.undergrowth.util.concurrent;

import java.util.Queue;
import java.util.concurrent.Executor;

import org.junit.Test;

/**
 * Executor-->可执行者
 * @author undergrowth
 *
 */
public class ExecutorTest {

	private Executor executor;
	private Runnable runnable = new Runnable() {

		public void run() {
			// TODO Auto-generated method stub
			System.out.println(Thread.currentThread().getName());
		}
	};

	/**
	 * 测试异步执行
	 */
	@Test
	public void asynExecuteTest() {
		System.out.println(Thread.currentThread().getName());
		executor = new AsynExecute();
		executor.execute(runnable);
	}

	/**
	 * 测试同步执行
	 */
	@Test
	public void syncExecuteTest() {
		System.out.println(Thread.currentThread().getName());
		executor = new SyncExecute();
		executor.execute(runnable);
	}
}

/**
 * 构建单独线程执行
 * 异步执行的任务
 * @author undergrowth
 *
 */
class AsynExecute implements Executor {

	public void execute(Runnable command) {
		// TODO Auto-generated method stub
		new Thread(command, "单独的线程").start();
	}

}

/**
 * 使用调用线程线程执行任务
 * 同步执行的任务
 * @author undergrowth
 *
 */
class SyncExecute implements Executor {

	public void execute(Runnable command) {
		// TODO Auto-generated method stub
		command.run();
	}

}


结果

asynExecuteTest（）

main
单独的线程


syncExecuteTest（）

main
main




工厂类

ExecutorsTest.java

/**
 * 
 */
package com.undergrowth.util.concurrent;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;

import org.junit.Test;

/**
 * Executors类--> 提供实用方法-->
 * 工厂类作用-->Executor、ExecutorService、ScheduledExecutorService、ThreadFactory、Callable
 * 
 * @author undergrowth
 * 
 */
public class ExecutorsTest {

	// 可执行的任务 不可返回值
	private Runnable runnable = new RunnableConcrete();
	// 可执行的任务 可返回值
	private Callable<String> callable = new CallableConcrete<String>();
	// 线程工厂
	private ThreadFactory threadFactory;
	// 提供了执行任务、跟踪任务、关闭线程池的操作(线程池、调度器)
	private ExecutorService executorService;
	// 用于表示异步执行的结果
	private Future<String> future;
	// 可延迟或重复调用的线程池
	private ScheduledExecutorService scheduledExecutorService;
	// 一个延时、可接受计算结果
	private ScheduledFuture<String> scheduledFuture;

	/**
	 * 使用Runnable创建Callable
	 */
	@Test
	public void callableCreateTest() {
		// 使用Runnable、给定的返回值创建一个Callable
		callable = Executors.callable(runnable, ExecutorsTest.class
				.getSimpleName());
		try {
			// 显示返回值
			System.out.println(callable.call());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * 通过线程工厂创建线程
	 */
	@Test
	public void threadFactoryTest() {
		// 创建线程工厂
		threadFactory = Executors.defaultThreadFactory();
		// 创建一个Runnable
		runnable = new RunnableConcrete();
		// 创建线程
		threadFactory.newThread(runnable).start();
	}

	/**
	 * 产生根据需要而创建线程的线程池 当线程使用完后 可重复使用线程
	 */
	@Test
	public void executorServiceTest() {
		// 创建线程池
		executorService = Executors.newCachedThreadPool();
		// 在线程池中执行任务
		future = executorService.submit(runnable, "返回结果");
		System.out.println(future.isDone());
		// if(future.isDone())
		{
			try {
				// 获取任务的返回结果
				System.out.println(future.get());
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (ExecutionException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	/**
	 * 调用任务集合
	 */
	@Test
	public void executorServiceCollectionsTest() {
		/*
		 * CallableConcrete<String> callable=new CallableConcrete<String>();
		 * Collection<CallableConcrete<String>>
		 * tasks=createCallableTasks(20,callable);
		 */
		callable = new CallableConcrete<String>();
		// 构建集合任务
		Collection<Callable<String>> tasks = createCallableTasks(20, callable);
		// 创建线程池
		executorService = Executors.newCachedThreadPool();
		try {
			// 执行任务集合
			List<Future<String>> resuList = executorService.invokeAll(tasks);
			// 迭代任务集合
			iterator(resuList);
			// 关闭操作
			closeExecutorService(executorService);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	/**
	 * 关闭线程池操作
	 * 
	 * @param executorService2
	 */
	private void closeExecutorService(ExecutorService executorService2) {
		// TODO Auto-generated method stub
		if (!executorService2.isShutdown()) {
			executorService2.shutdown();
			try {
				if (!executorService2.awaitTermination(10, TimeUnit.SECONDS)) {
					System.out.println("线程池未关闭");
				} else {
					System.out.println("线程池已成功关闭");
				}
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	/**
	 * 迭代
	 * 
	 * @param <T>
	 * @param resuList
	 */
	@SuppressWarnings("unchecked")
	private <T> void iterator(Iterable<T> resuList) {
		// TODO Auto-generated method stub
		for (T t : resuList) {
			try {
				System.out.println(((Future<String>) t).get());
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (ExecutionException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	/**
	 * 创建可调度的任务
	 * 
	 * @return
	 */
	private <E> Collection<E> createCallableTasks(int length, E e) {
		// TODO Auto-generated method stub
		Collection<E> list = new ArrayList<E>();
		for (int i = 0; i < length; i++) {
			list.add(e);
		}
		return list;
	}

	/**
	 * 创建可延时的任务
	 */
	@Test
	public void scheduledExecutorServiceDelayTest() {
		// 获取可延时、重复调度的线程池
		scheduledExecutorService = Executors.newScheduledThreadPool(1);
		// 显示当前时间
		System.out.println(System.currentTimeMillis());
		// 延迟10s后 执行任务
		scheduledFuture = scheduledExecutorService.schedule(callable, 10,
				TimeUnit.SECONDS);
		try {
			// 获取线程池的执行任务的返回结果
			System.out.println(scheduledFuture.get() + "\t"
					+ System.currentTimeMillis());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	/**
	 * 创建重复调度的任务
	 */
	@Test
	public void scheduledExecutorServiceTest() {
		// 获取可延时、重复调度的线程池
		scheduledExecutorService = Executors.newScheduledThreadPool(2);
		// 显示当前时间
		System.out.println(System.currentTimeMillis());
		// 延迟10s后 重复执行任务 
		scheduledFuture = (ScheduledFuture<String>) scheduledExecutorService.scheduleAtFixedRate(runnable, 10, 10,TimeUnit.SECONDS);
		//运行1分钟后 终止重复执行的任务
		scheduledExecutorService.schedule(new Runnable(){

			public void run() {
				// TODO Auto-generated method stub
				//终止重复执行的任务
				scheduledFuture.cancel(true);
				System.out.println("终止重复执行的任务");
			}
			
		}, 1*60	, TimeUnit.SECONDS);
		// 获取线程池的执行任务的返回结果 因为任务被取消了 所以执行词句会报错
		try {
			System.out.println(scheduledFuture.get() + "\t"
					+ System.currentTimeMillis());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}catch(CancellationException e){
			e.printStackTrace();
		}
	}

}


结果

callableCreateTest()

main	RunnableConcrete
ExecutorsTest


threadFactoryTest()

pool-1-thread-1	RunnableConcrete


executorServiceTest()

false
pool-1-thread-1	RunnableConcrete
返回结果



executorServiceCollectionsTest()

pool-1-thread-1	CallableConcrete
pool-1-thread-2	CallableConcrete
pool-1-thread-3	CallableConcrete
pool-1-thread-2	CallableConcrete
pool-1-thread-3	CallableConcrete
pool-1-thread-1	CallableConcrete
pool-1-thread-4	CallableConcrete
pool-1-thread-1	CallableConcrete
pool-1-thread-2	CallableConcrete
pool-1-thread-3	CallableConcrete
pool-1-thread-5	CallableConcrete
pool-1-thread-2	CallableConcrete
pool-1-thread-3	CallableConcrete
pool-1-thread-4	CallableConcrete
pool-1-thread-1	CallableConcrete
pool-1-thread-6	CallableConcrete
pool-1-thread-4	CallableConcrete
pool-1-thread-5	CallableConcrete
pool-1-thread-3	CallableConcrete
pool-1-thread-2	CallableConcrete
线程池已成功关闭



scheduledExecutorServiceDelayTest()

1425202002086
pool-1-thread-1	CallableConcrete	1425202012086


scheduledExecutorServiceTest()

1425202037535
pool-1-thread-2	RunnableConcrete
pool-1-thread-2	RunnableConcrete
pool-1-thread-1	RunnableConcrete
pool-1-thread-2	RunnableConcrete
pool-1-thread-2	RunnableConcrete
pool-1-thread-2	RunnableConcrete
终止重复执行的任务
java.util.concurrent.CancellationException
	at java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.java:203)
	at java.util.concurrent.FutureTask.get(FutureTask.java:80)
	at com.undergrowth.util.concurrent.ExecutorsTest.scheduledExecutorServiceTest(ExecutorsTest.java:237)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
	at java.lang.reflect.Method.invoke(Method.java:585)
	at org.junit.internal.runners.TestMethodRunner.executeMethodBody(TestMethodRunner.java:99)
	at org.junit.internal.runners.TestMethodRunner.runUnprotected(TestMethodRunner.java:81)
	at org.junit.internal.runners.BeforeAndAfterRunner.runProtected(BeforeAndAfterRunner.java:34)
	at org.junit.internal.runners.TestMethodRunner.runMethod(TestMethodRunner.java:75)
	at org.junit.internal.runners.TestMethodRunner.run(TestMethodRunner.java:45)
	at org.junit.internal.runners.TestClassMethodsRunner.invokeTestMethod(TestClassMethodsRunner.java:66)
	at org.junit.internal.runners.TestClassMethodsRunner.run(TestClassMethodsRunner.java:35)
	at org.junit.internal.runners.TestClassRunner$1.runUnprotected(TestClassRunner.java:42)
	at org.junit.internal.runners.BeforeAndAfterRunner.runProtected(BeforeAndAfterRunner.java:34)
	at org.junit.internal.runners.TestClassRunner.run(TestClassRunner.java:52)
	at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:38)
	at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:460)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:673)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:386)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:196)



  记录学习的脚步


undergrowth
关注
专栏目录
Java中ExecutorService线程池的使用(Runnable和Callable多线程实现)
BADAO_LIUMANG_QIZHI的博客
08-09 7571
线程的创建和释放，需要占用不小的内存和资源。如果每次需要使用线程时，都new 一个Thread的话，难免会造成资源的浪费，而且可以无限制创建，之间相互竞争，会导致过多占用系统资源导致系统瘫痪。不利于扩展，比如如定时执行、定期执行、线程中断，所以很有必要了解下ExecutorService的使用。ExecutorService是Java提供的线程池，也就是说，每次我们需要使用线程的时候，可以通过ExecutorService获得线程。...
谈谈对 java线程池（Executors、ExecutorService、ScheduledExecutorService）和（Callable、Future、CyclicBarrier）的理解
eddyjoe的博客
03-11 855
线程池概念 线程池是实现多线程的一种用法，可以维护多个线程，优化创建和销毁线程的开销达到系统优化性能的目的。 线程池的优点 （1） 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗； （2） 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行； （3） 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进...
Executor ExecutorService Executors Runnable Callable Future FutureTask
fang_qiming的博客
02-27 307
Executor    执行接口  只有一个方法  void execute(Runnable command)  用来执行任务ExecutorService  是接口Executor的子类 同时提供对线程池的关闭,执行,等方法Executors 提供一些静态方法用于创建各种类型的线程池Runnable  是一个接口，使用很简单 1.实现该接口，重写run方法 2.创建线程 3.线程启动...
Runnable,Callable,ExecutorService,Future,FutureTask联系和区别
cg_Amaz1ng的博客
05-04 328
1、Runnable是线程Thread执行的对象,是线程执行的核心逻辑，核心方法run无法抛出异常，也没有返回值。 2、Callable不能作为Thread的构造函数参数，Callable只能被提交到线程池执行，核心方法call可以抛出异常，有返回值。 3、ExecutorService是线程池的通用接口，可以看成一个线程池。Runnable和Callable可以被提交到线程池来执行，通常是调...
java多线程：Thread、Runnable、Callable、ExecutorService
flyorfly的博客
04-09 257
Java多线程 1.基本概念：程序、进程、线程 2、线程的创建和使用 3、线程的声明周期 4、线程的同步 5、线程的通信 6、jdk 5.0 新增线程创建方式 程序、继承、线程 1、程序(program) :静态的代码 2、进程(process):运行起来的程序 3、线程(thread):进程可细化成线程：是程序内部的一条执行路径。 若一个程序并行执行多个线程，就支持多线程。 线程作为调度和执行的...
Java并发 三 ScheduledExecutorService
空
07-04 216
ScheduledExecutorService是与ExecutorService类似的接口，但它可以定期执行任务。 Executor和ExecutorService的方法是在现场安排的，不会引入任何人工延迟。零或任何负值表示需要立即执行请求。 我们可以使用Runnable和Callable接口来定义任务。 public void execute() { ScheduledExecutor...
多线程 Executor、ExecutorService、Executors三者的区别
kings_的博客
01-21 358
** Executor、ExecutorService、Executors三者的区别： ** UML简要类图关系 层次关系 public interface ExecutorService extends Executor {} public abstract class AbstractExecutorService implements ExecutorService {} public interface ScheduledExecutorService extends ExecutorServic
java中多线程执行器Executor之submit中Runnable任务和Callable任务的区别
sinat_29408999的博客
08-23 1029
线程执行器和不使用线程执行器的对比（优缺点） 1.线程执行器分离了任务的创建和执行，通过使用执行器，只需要实现Runnable接口的对象，然后把这些对象发送给执行器即可。 2.使用线程池来提高程序的性能。当发送一个任务给执行器时，执行器会尝试使用线程池中的线程来执行这个任务。避免了不断创建和销毁线程导致的性能开销。 3.执行器可以处理实现了Callable接口的任务。Callable接口类似于Runnable接口，却提供了两方面的增强： a.Callable主方法名称为call(),可以返回结果 b.当发送
【多线程】Executor 和 ExecutorService 使用小结
happydecai的博客
09-19 2105
我们之前创建一个线程的时候，就是直到new一个Thread创建一个线程，但是在jdk1.5之后，Java为我们提供了一个Java.util.concurrent包，这个包下有Executor接口，这就为我们提供了线程池的方法去开启多个线程，那么说到这里我们是不是会问：为什么要用Executor呢？或者new的方式有什么缺点呢？ 1）每次我们new Thread都会创建一个对象，不能被重用，而且对...
JAVA高级基础（71）---Executor执行Runnable任务
11onhook的博客
01-19 974
Executor框架：支持并发编程的线程池 Executors 1、ExecutorService    newFixedThreadPool(int initThread) 在线程池中，创建固定数目的线程。当执行任务的时候，如果线程池中由空闲线程，则直接使用该线程来执行任务，如果没有空闲线程，则任务处于阻塞状态，等待线程空闲。 2、ExecutorService    newCacheT...
ExecutorService的API
Howie_zhw的博客
06-24 764
实现Runnable的线程类不能够获取到线程的执行结果。 java.util.concurrent.ExecutorService的API Future submit(Callable task) 提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。這个可以通过Future.get()获取线程的返回结果。  Future submit(Runnable
ScheduledExecutorService使用
追寻心的步伐
04-24 945
ScheduledExecutorService是基于线程池的定时任务类，每个调度的任务都会分配到线程池中到一个线程去执行，即任务是并发执行的，互不影响，只有当调度任务来的时候，ScheduledExecutorService才会真正启动一个线程，其余时间ScheduledExecutorService都是处于轮询任务的状态。
Java ScheduledExecutorService示例
一名可爱的技术搬运工
05-30 646
在Java中，我们可以使用ScheduledExecutorService定期运行一个任务，也可以在TimeUnit预定义的延迟后一次运行一次。 1.一次运行任务 ScheduledExecutorService接受Runnable和Callable任务。 1.1运行Runnable 5秒初始延迟之后的任务。 ScheduledExecutorExample.java pac...
Java并发——ScheduledExecutorService
吴声子夜歌的博客
06-24 2814
ScheduledExecutorService 类 Scheduledexecutor Service的主要作用就是可以将定时任务与线程池功能结合使用。 ScheduledThreadPoolExecutor使用Callable延迟运行 public class MyCallableAA implements Callable<String> { @Override public String call() throws Exception { try {
java 线程池（Executors、ExecutorService、ScheduledExecutorService）和（Callable、Future、CyclicBarrier）实践篇
eddyjoe的博客
03-11 656
一、FixedThreadPool、CachedThreadPool、SingleThreadExecutor、ScheduledThreadPool 简单使用（不推荐） public void fixedThreadPool1(){ int size = 5; ExecutorService threadPool = Executors.newFixedThrea...
ExecutorService线程池使用、Future、Callable 接口
最新发布
m0_61160520的博客
08-21 953
Callable 本身并不能直接运行，它需要通过某种方式提交给执行器（如 ExecutorService）或包装成 FutureTask 然后在一个线程中执行。这是因为 Callable 接口本身只是一个定义了 call 方法的接口，它并不包含任何执行机制。
【线程池】 ScheduledExecutorService (1) 延迟 / 周期执行线程池
m0_45406092的博客
04-29 698
文章目录ScheduledExecutorService 简述对象创建方式schedule Runnableschedule CallablescheduleAtFixedRatescheduleWithFixedDelay ScheduledExecutorService 简述 1、public interface ScheduledExecutorService extends Execut...
java Timer和ScheduledExecutorService区别
lijianqingfeng的专栏
01-11 738
前面写了java Timer源码走读，算是搞懂了java中Timer的实现原理，之前对于定时任务，一直使用Timer，后来面试中被问到Timer和ScheduledExecutorService什么区别，一脸懵逼，之前都没想到这两个有什么关系。 一开始其实就只把ScheduledExecutorService当做是线程池，只是具备了调度定时任务的能力。但是从使用场景的角度来看，其实这两个确实很像，都是为了调度定时任务而产生的，只是使用的实现方法不一样。 ...
Java高并发编程中ScheduledExecutorService的使用及详细介绍-刘宇
热门推荐
刘宇的博客
08-19 1万+
作者：刘宇。一、什么是ScheduledExecutorService？二、ScheduledThreadPoolExecutor中的方法1、构造方法2、schedule方法3、scheduleAtFixedRate方法4、scheduleWithFixedDelay方法5、setContinueExistingPeriodicTasksAfterShutdownPolicy方法6、setExecuteExistingDelayedTasksAfterShutdownPolicy方法三、练习
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值