Executor框架简介

在Java 5之后，并发编程引入了一堆新的启动、调度和管理线程的API。Executor框架便是Java 5中引入的，其内部使用了线程池机制，它在java.util.concurrent 包下，通过该框架来控制线程的启动、执行和关闭，可以简化并发编程的操作。因此，在Java 5之后，通过Executor来启动线程比使用Thread的start方法更好，除了更易管理，效率更好（用线程池实现，节约开销）外，还有关键的一点：有助于避免this逃逸问题——如果我们在构造器中启动一个线程，因为另一个任务可能会在构造器结束之前开始执行，此时可能会访问到初始化了一半的对象用Executor在构造器中。

Executor框架包括

Executor框架包括以下关键组件：线程池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等。

Executor接口

Executor接口中定义了一个方法execute（Runnable command），该方法接收一个Runable实例，它用来执行一个任务，任务即一个实现了Runnable接口的类。

ExecutorService接口

ExecutorService接口继承自Executor接口，它提供了更丰富的实现多线程的方法，比如，ExecutorService提供了关闭自己的方法，以及可为跟踪一个或多个异步任务执行状况而生成 Future 的方法。可以调用ExecutorService的shutdown（）方法来平滑地关闭 ExecutorService，调用该方法后，将导致ExecutorService停止接受任何新的任务且等待已经提交的任务执行完成(已经提交的任务会分两类：一类是已经在执行的，另一类是还没有开始执行的)，当所有已经提交的任务执行完毕后将会关闭ExecutorService。

ExecutorService的生命周期

ExecutorService的生命周期包括三种状态：运行、关闭、终止。创建后便进入运行状态，当调用了shutdown（）方法时，便进入关闭状态，此时意味着ExecutorService不再接受新的任务，但它还在执行已经提交了的任务。当素有已经提交了的任务执行完后，便到达终止状态。如果不调用shutdown（）方法，ExecutorService会一直处在运行状态，不断接收新的任务，执行新的任务，服务器端一般不需要关闭它，保持一直运行即可。

Executors工厂方法

Executors提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。例如：

public static ExecutorService newFixedThreadPool(int nThreads)：创建固定数目线程的线程池。

public static ExecutorService newCachedThreadPool()：创建一个可缓存的线程池。

public static ExecutorService newSingleThreadExecutor()：创建一个单线程化的Executor。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)：创建一个支持定时及周期性的任务执行的线程池。

FixedThreadPool和CachedThreadPool的区别

newFixedThreadPool：线程池的线程数固定为指定值，不会自动回收线程。线程池中的线程空闲时也会保持在线等待任务。

newCachedThreadPool：线程池支持回收线程，当在线程空闲超过一段时间（默认60秒）时会自动回收。

newSingleThreadExecutor

SingleThreadExecutor创建的线程池只包含一个线程，该线程持续地执行任务，其他提交的任务都会放在队列中等待执行。单线程 executor在需要确保某个任务只能在特定的线程中执行时非常有用。

Executor执行Runnable任务

通过Executors的以上四个静态工厂方法获得 ExecutorService 实例，而后调用该实例的execute（Runnable command）方法即可。一旦Runnable任务传递到execute（）方法，该方法便会自动在一个线程上执行。例如：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestCachedThreadPool {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            executorService.execute(new TestRunnable());
            System.out.println("************* a" + i + " *************");
        }
        executorService.shutdown();
    }
}
class TestRunnable implements Runnable {
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程被调用了。");
    }
}

从结果可以看出，submit和execute会先在线程池中选择一个已有空闲线程来执行任务，如果线程池中没有空闲线程，它便会创建一个新的线程来执行任务。

Executor执行Callable任务

在Java 5之后，任务分两类：实现了Runnable接口的类和实现了Callable接口的类。两者都可以被ExecutorService执行，但Callable任务有返回值，并且通过submit(Callable task) 方法执行，并返回一个 Future。

Callable接口类似于Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的，但Callable有返回值，Runnable没有。以下是一个Executor执行Callable任务的示例：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
public class CallableDemo {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        List
   
    
     > resultList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Future
     
       future = executorService.submit(new TaskWithResult(i));
            resultList.add(future);
        }
        for (Future
      
        fs : resultList) {
            try {
                while (!fs.isDone()) {
                    System.out.println(fs.get());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            } finally {
                executorService.shutdown();
            }
        }
    }
}
class TaskWithResult implements Callable
       
         {
    private int id;
    public TaskWithResult(int id) {
        this.id = id;
    }
    public String call() throws Exception {
        System.out.println("call()方法被自动调用！！！" + Thread.currentThread().getName());
        return "call()方法被自动调用，任务返回的结果是：" + id + " " + Thread.currentThread().getName();
    }
}

自定义线程池

通过ThreadPoolExecutor类可以自定义线程池。例如：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolTest {
    public static void main(String[] args) {
        BlockingQueue
   
     bqueue = new ArrayBlockingQueue<>(20);
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 5, 50, TimeUnit.MILLISECONDS, bqueue);
        Runnable t1 = new MyThread();
        Runnable t2 = new MyThread();
        Runnable t3 = new MyThread();
        Runnable t4 = new MyThread();
        Runnable t5 = new MyThread();
        Runnable t6 = new MyThread();
        Runnable t7 = new MyThread();
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        pool.execute(t6);
        pool.execute(t7);
        pool.shutdown();
    }
}
class MyThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "正在执行。。。");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

ThreadPoolExecutor的构造方法

ThreadPoolExecutor的构造方法参数说明：

corePoolSize：线程池中保存的核心线程数，包括空闲线程。

maximumPoolSize：池中允许的最大线程数。

keepAliveTime：线程池中的空闲线程所能持续的最长时间。

unit：持续时间的单位。

workQueue：任务执行前保存任务的队列，只保存由execute方法提交的Runnable任务。

总结

通过以上内容可以看出，Executor框架通过提供一个统一的接口，参数化地管理线程池的配置。根据具体的任务需求，可以选择合适的executor类型，如FixedThreadPool、CachedThreadPool、ScheduledThreadPool以及自定义线程池。这些不同的选择基于任务的执行特点，如执行时间长度、线程数量限制、任务ellie的是否定期执行等。

转载地址：http://fhixz.baihongyu.com/

你可能感兴趣的文章