文档章节

Java多线程之Executor框架<Callable、Future、Executor和ExecutorService>

青衣霓裳
 青衣霓裳
发布于 07/19 09:53
字数 2511
阅读 1543
收藏 40

引言

Executor框架是指JDK 1.5中引入的一系列并发库中与Executor相关的功能类,包括Executor、Executors、ExecutorService、Future、Callable等。

一、为什么要引入Executor框架?

1、如果使用new Thread(...).start()的方法处理多线程,有如下缺点:

① 开销大。对于JVM来说,每次新建线程和销毁线程都会有很大的开销。

② 线程缺乏管理。没有一个池来限制线程的数量,如果并发量很高,会创建很多线程,而且线程之间可能会有相互竞争,这将会过多占用系统资源,增加系统资源的消耗量。而且线程数量超过系统负荷,容易导致系统不稳定。

2、使用线程池的方法,有如下优点:

① 线程复用。通过复用创建了的线程,减少了线程的创建、消亡的开销。

② 有效控制并发线程数。

③ 提供了更简单灵活的线程管理。可以提供定时执行、单线程、可变线程数等多种使用功能。

二、Executor框架的UML图

三、下面开始分析一下Executor框架中几个比较重要的接口和类。

1、Callable

Callable位于java.util.concurrent包下,它是一个接口,只声明了一个call()方法。

Callable接口类似于Runnable,两者都是为了可能在线程中执行的类而设计的。和Runnable接口中的run()方法类似,Callable 提供的call()方法作为线程的执行体。但是call()比run()方法更强大,体现在

① call方法有返回值。

② call方法可以声明抛出异常。

2、Future

Future 接口位于java.util.concurrent包下,是Java 1.5中引入的接口。

Future主要用来对具体的Runnable或Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get()方法获取执行结果,get()方法会阻塞知道任务返回结果。

当你提交一个Callable对象给线程池时,将得到一个Future对象,并且它和你传入的Callable示例有相同泛型。

Future 接口中的5个方法:

public interface Future<V> {
    //用来取消任务
    //参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务。
    boolean cancel(boolean mayInterruptIfRunning);
    //表示任务是否被取消成功
    boolean isCancelled();
    //表示任务是否已经完成
    boolean isDone();
    //用来获取执行结果,这个方法会产生阻塞,会一直等到任务执行完毕才返回;
    V get()
    //用来获取执行结果,如果在指定时间内,还没获取到结果,会抛出TimeoutException异常。
    V get(long timeout, TimeUnit unit)
}

Future提供了三种功能:

① 判断任务是否完成

② 能够中断任务

③ 能够获取任务执行结果

3、Executor

Executor是一个接口,它将任务的提交与任务的执行分离开来,定义了一个接收Runnable对象的方法executor。Executor是Executor框架中最基础的一个接口,类似于集合中的Collection接口。

4、ExecutorService

ExecutorService继承了Executor,是一个比Executor使用更广泛的子类接口。定义了终止任务、提交任务、跟踪任务返回结果等方法。

一个ExecutorService是可以关闭的,关闭之后它将不能再接收任何任务,对于不在使用的ExecutorService,应该将其关闭以释放资源。

ExecutorService方法介绍:

package java.util.concurrent;

import java.util.List;
import java.util.Collection;

public interface ExecutorService extends Executor {

    /**
     * 平滑地关闭线程池,已经提交到线程池中的任务会继续执行完。
     */
    void shutdown();

    /**
     * 立即关闭线程池,返回还没有开始执行的任务列表。
     * 会尝试中断正在执行的任务(每个线程调用 interruput方法),但这个行为不一定会成功。
     */
    List<Runnable> shutdownNow();

    /**
     * 判断线程池是否已经关闭
     */
    boolean isShutdown();

    /**
     * 判断线程池的任务是否已经执行完毕。
     * 注意此方法调用之前需要先调用shutdown()方法或者shutdownNow()方法,否则总是会返回false
     */
    boolean isTerminated();

    /**
     * 判断线程池的任务是否都执行完。
     * 如果没有任务没有执行完毕则阻塞,直至任务完成或者达到了指定的timeout时间就会返回
     */
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * 提交带有一个返回值的任务到线程池中去执行(回调),返回的 Future 表示任务的待定结果。
     * 当任务成功完成后,通过 Future 实例的 get() 方法可以获取该任务的结果。
     * Future 的 get() 方法是会阻塞的。
     */
    <T> Future<T> submit(Callable<T> task);

    /**
     *提交一个Runnable的任务,当任务完成后,可以通过Future.get()获取的是提交时传递的参数T result
     * 
     */
    <T> Future<T> submit(Runnable task, T result);

    /**
     * 提交一个Runnable的人无语,它的Future.get()得不到任何内容,它返回值总是Null。
     * 为什么有这个方法?为什么不直接设计成void submit(Runnable task)这种方式?
     * 这是因为Future除了get这种获取任务信息外,还可以控制任务,
     具体体现在 Future的这个方法上:boolean cancel(boolean mayInterruptIfRunning)
     这个方法能够去取消提交的Rannable任务。
     */
    Future<?> submit(Runnable task);

    /**
     * 执行一组给定的Callable任务,返回对应的Future列表。列表中每一个Future都将持有该任务的结果和状态。
     * 当所有任务执行完毕后,方法返回,此时并且每一个Future的isDone()方法都是true。
     * 完成的任务可能是正常结束,也可以是异常结束
     * 如果当任务执行过程中,tasks集合被修改了,那么方法的返回结果将是不确定的,
       即不能确定执行的是修改前的任务,还是修改后的任务
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    /**
     * 执行一组给定的Callable任务,返回对应的Future列表。列表中每一个Future都将持有该任务的结果和状态。
     * 当所有任务执行完毕后或者超时后,方法将返回,此时并且每一个Future的isDone()方法都是true。
     * 一旦方法返回,未执行完成的任务被取消,而完成的任务可能正常结束或者异常结束, 
     * 完成的任务可以是正常结束,也可以是异常结束
     * 如果当任务执行过程中,tasks集合被修改了,那么方法的返回结果将是不确定的
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * 执行一组给定的Callable任务,当成功执行完(没抛异常)一个任务后此方法便返回,返回的是该任务的结果
     * 一旦此正常返回或者异常结束,未执行的任务都会被取消。 
     * 如果当任务执行过程中,tasks集合被修改了,那么方法的返回结果将是不确定的
     */
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

    /**
     * 执行一组给定的Callable任务,当在timeout(超时)之前成功执行完(没抛异常)一个任务后此方法便返回,返回的是该任务的结果
     * 一旦此正常返回或者异常结束,未执行的任务都会被取消。 
     * 如果当任务执行过程中,tasks集合被修改了,那么方法的返回结果将是不确定的
     */
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

shutdown() 和 shutdownNow() 是用来关闭连接池的两个方法,而且这两个方法都是在当前线程立即返回,不会阻塞至线程池中的方法执行结束。调用这两个方法之后,连接池将不能再接受任务。

下面给写几个示例来加深ExecutorService的方法的理解。
先写两个任务类:ShortTask和LongTask,这两个类都继承了Runnable接口,ShortTask的run()方法执行很快,LongTask的run()方法执行时间为10s。

public class LongTask implements Runnable {
    @Override
    public void run() {
        try {
            TimeUnit.SECONDS.sleep(10L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("complete a long task");
    }

}
public class ShortTask implements Runnable {
    @Override
    public void run() {
        System.out.println("complete a short task...");
    }
    
}

测试shutdown()方法

package OSChina.Client;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.*;

public class Client10 {
    public static void main(String[] args) {
        ExecutorService threadpool = Executors.newFixedThreadPool(4);
        threadpool.submit(new ShortTask());
        threadpool.submit(new ShortTask());
        threadpool.submit(new LongTask());
        threadpool.submit(new ShortTask());
        threadpool.shutdown();
        boolean isShutdown = threadpool.isShutdown();
        System.out.println("线程池是否已经关闭:" + isShutdown);
        final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        try {
            while (!threadpool.awaitTermination(1L, TimeUnit.SECONDS)){
                System.out.println("线程池中还有任务在执行,当前时间:" + sdf.format(new Date()));
            }
            System.out.println("线程池中已经没有在执行的任务,线程池已完全关闭!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试shutdownNow()方法

package OSChina.Client;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Client11 {
    public static void main(String[] args) {
        ExecutorService threadpool = Executors.newFixedThreadPool(3);
        //将5个任务提交到有3个线程的线程池
        threadpool.submit(new LongTask());
        threadpool.submit(new LongTask());
        threadpool.submit(new LongTask());
        threadpool.submit(new LongTask());
        threadpool.submit(new LongTask());
        try {
            TimeUnit.SECONDS.sleep(1L);
            //关闭线程池
            List<Runnable> waiteRunnables = threadpool.shutdownNow();
            System.out.println("还没有执行的任务数:" + waiteRunnables.size());

            boolean isShutdown = threadpool.isShutdown();
            System.out.println("线程池是否已经关闭:" + isShutdown);

            final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
            while (!threadpool.awaitTermination(1L, TimeUnit.SECONDS)) {
                System.out.println("线程池中还有任务在执行,当前时间:" + sdf.format(new Date()));
            }

            System.out.println("线程池中已经没有在执行的任务,线程池已完全关闭!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

当调用shutdownNow()后,三个执行的任务都被interrupt了。而且awaitTermination(1L, TimeUnit.SECONDS)返回的都是true。

测试submit(Callable<T> task)方法

package OSChina.Client;

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

public class CallableTask implements Callable{
    @Override
    public Object call() throws Exception {
        TimeUnit.SECONDS.sleep(5L);
        return "success";
    }
}
package OSChina.Client;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Client12 {
    public static void main(String[] args) {
        ExecutorService threadpool = null;
        threadpool = Executors.newFixedThreadPool(3);
        final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        System.out.println("提交一个callable任务到线程池,现在时间是:" + sdf.format(new Date()));
        Future<String> future = threadpool.submit(new CallableTask());
        try {
            System.out.println("获取callable任务的结果:" + future.get() + ",现在时间是:" + sdf.format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            if(threadpool!=null){
                threadpool.shutdown();
            }
        }
    }
}

 

素小暖讲Java@目录

© 著作权归作者所有

青衣霓裳
粉丝 69
博文 67
码字总数 151035
作品 0
大连
私信 提问
java Future 接口介绍

在Java中,如果需要设定代码执行的最长时间,即超时,可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分,在java.util.concurrent包中。Future接口...

程序袁_绪龙
2014/11/25
229
0
《Java多线程的控制》

多线程,是很多编程人员再熟悉不过的了。 在稍老一些的Java版本中,具体是在Java 5.0以前,启动一个任务是通过调用Thread类的start()方法来实现的,任务的提交和执行时同时进行的,如果想对任...

迷途d书童
2012/03/26
159
0
Java使用Executor执行Callable任务时的几种方法

多线程在需要返回值时,我们知道需要用到Callable和Future。Callable的cell方法可以返回一个值并且可抛出异常,是对Runnable的很好的补充;Future表示了一个任务的周期,它提供了判断任务状态...

东都大狼狗
2018/09/09
24
0
Java Executor 框架

Executor框架是指java5中引入的一系列并发库中与executor相关的功能类,包括Executor、Executors、ExecutorService、CompletionService、Future、Callable等。(图片引用自http://www.javacl...

leesama
2014/12/01
280
0
Java多线程学习(八)线程池与Executor 框架

Java面试通关手册(Java学习指南,欢迎Star,会一直完善下去,欢迎建议和指导):https://github.com/Snailclimb/JavaGuide 历史优质文章推荐: Java并发编程指南专栏 分布式系统的经典基础理...

snailclimb
2018/05/31
0
0

没有更多内容

加载失败,请刷新页面

加载更多

spring cloud

一、从面试题入手 1.1、什么事微服务 1.2、微服务之间如何独立通讯的 1.3、springCloud和Dubbo有哪些区别 1.通信机制:DUbbo基于RPC远程过程调用;微服务cloud基于http restFUL API 1.4、spr...

榴莲黑芝麻糊
48分钟前
2
0
Executor线程池原理与源码解读

线程池为线程生命周期的开销和资源不足问题提供了解决方 案。通过对多个任务重用线程,线程创建的开销被分摊到了多个任务上。 线程实现方式 Thread、Runnable、Callable //实现Runnable接口的...

小强的进阶之路
昨天
6
0
maven 环境隔离

解决问题 即 在 resource 文件夹下面 ,新增对应的资源配置文件夹,对应 开发,测试,生产的不同的配置内容 <resources> <resource> <directory>src/main/resources.${deplo......

之渊
昨天
8
0
详解箭头函数和普通函数的区别以及箭头函数的注意事项、不适用场景

箭头函数是ES6的API,相信很多人都知道,因为其语法上相对于普通函数更简洁,深受大家的喜爱。就是这种我们日常开发中一直在使用的API,大部分同学却对它的了解程度还是不够深... 普通函数和...

OBKoro1
昨天
7
0
轻量级 HTTP(s) 代理 TinyProxy

CentOS 下安装 TinyProxy yum install -y tinyproxy 启动、停止、重启 # 启动service tinyproxy start# 停止service tinyproxy stop# 重启service tinyproxy restart 相关配置 默认...

Anoyi
昨天
2
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部