Executor
/*
* Executor是一个接口，需要使用它的实现类ThreadPoolExecutor，这里用Executors.newSingleThreadExecutor()返回一个单线程池
* execute()方法传入的是一个Runnable对象
* */
public class ExecutorsJava {
public static void main(String[] args) {
Executor e = Executors.newSingleThreadExecutor();
e.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
while(true) {
System.out.println("线程1正在执行");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
});
}
}
ExecutorService
ExecutorService相比Executor多了实现执行Callable多线程的方法，以及提供了具有返回值的执行方法
public class ExecutorServiceJava {
public static void main(String[] args) throws InterruptedException, ExecutionException {
// ExecutorService是接口，需要使用实现类ThreadPoolExecutor对象
ExecutorService es = Executors.newCachedThreadPool();
CallableTest ct = new CallableTest();
//把Callable多线程传入线程池中，并得到包装返回值信息的Future
Future<String> f = es.submit(ct);
System.out.println("从future中获取信息：" + f.get());
}
}
class CallableTest implements Callable<String>{
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return Thread.currentThread().getName() + "---线程正在执行---";
}
}
也可以传入Runnable对象并设置执行完成返回值
public class ExecutorServiceJava {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService es = Executors.newCachedThreadPool();
RunnableTest rt = new RunnableTest();
//把Runnable对象传入，并设置返回值
Future<String> f = es.submit(rt, "执行完成");
System.out.println("从future中获取信息：" + f.get());
}
}
//------------------------------------------------------------------------------------------
class RunnableTest implements Runnable{
private static int i = 5;
@Override
public void run() {
// TODO Auto-generated method stub
b:
while(true) {
if(i > 0) {
System.out.println(Thread.currentThread().getName() + "---Runnable线程正在执行---");
i--;
}else {
break b;
}
}
}
}
执行线程集合
public class ExecutorServiceJava {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService es = Executors.newCachedThreadPool();
//储存返回结果对象
List<Future<String>> lf = new ArrayList<>();
CallableTest ct1 = new CallableTest();
CallableTest ct2 = new CallableTest();
CallableTest ct3 = new CallableTest();
CallableTest ct4 = new CallableTest();
//把要执行的线程存入集合中
Collection<CallableTest> collection = new HashSet<>();
collection.add(ct1);
collection.add(ct2);
collection.add(ct3);
collection.add(ct4);
//执行多线程
lf = es.invokeAll(collection);
//迭代并得到结果
for(Future<String> f : lf) {
System.out.println(f.get());
}
}
}
class CallableTest implements Callable<String>{
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return Thread.currentThread().getName() + "---Callable线程正在执行---";
}
}
invokeAny()方法与invokeAll()区别在于invokeAny()随便执行一个有返回值就退出，也就是只会执行一个线程
String lf2 = es.invokeAny(collection);
System.out.println( "随便执行一个" + lf2);
ThreadPoolExecutor实现了ExecutorService和Executor接口的
ScheduledThreadPoolExecutor
schedule(Callable<V> callable, long delay, TimeUnit unit) 创建并执行在给定延迟后启用的 ScheduledFuture。
schedule(Runnable command, long delay, TimeUnit unit) 创建并执行在给定延迟后启用的一次性操作。
scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) 创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。
ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) 创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。
这四个方法实现定时操作
FutureTask
FutureTask类实现了RunnableFuture接口，RunnableFuture接口实现了Runnable、Future。也就是FutureTask可以当做一个线程使用，同时也可以作为线程的返回结果。
FutureTask提供了两个构造器
public FutureTask(Callable<V> callable) {}
public FutureTask(Runnable runnable, V result) {}
程序示例：
/*
* 执行结果：
* 子线程在进行计算
* 主线程开始执行
* 4950
* 主线程执行完成
* 执行顺序：
* 子线程
* 主线程
* 主线程获取子线程结果
* 主线程执行完成
* */
public class FutureTaskJava {
public static void main(String[] args) throws InterruptedException {
//新建异步任务
CallableFutureTask cj = new CallableFutureTask();
FutureTask<Integer> ft = new FutureTask<>(cj);
//创建线程池
ExecutorService es = Executors.newCachedThreadPool();
//异步任务完成
es.submit(ft);
es.shutdown();
Thread.sleep(1000);
System.out.println("主线程开始执行");
try {
System.out.println(ft.get());
} catch (ExecutionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("主线程执行完成");
}
}
class CallableFutureTask implements Callable<Integer>{
@Override
public Integer call() throws Exception {
System.out.println("子线程在进行计算");
Thread.sleep(3000);
Integer sum = 0;
for(int i=0;i<100;i++)
sum += i;
return sum;
}
}
Future模式的核心在于：去除了主函数的等待时间，并使得原本需要等待的时间段可以用于处理其他业务逻辑
FutureTask在高并发环境下确保任务只执行一次
Timer和TimerTask
public class TimerJava {
public static void main(String[] args) {
// TODO Auto-generated method stub
Timer t = new Timer();
t.schedule(new TimerTask() {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("TimerTask正在执行--");
}
//1000毫秒以后执行，每1000毫秒执行一次
}, 1000, 1000);
}
}
