多线程进阶002 之 Executor框架

Executor接口

public interface Executor {
    void execute(Runnable command);
}

基于Executor的web服务器

使用Executor来构建web服务器,这里的Executor最多只能容纳100个线程

public class TaskExecutionWebServer {
    private static final int NTHREADS = 100;
    private static final Executor exec = Executors.newFixedThreadPool(NTHREADS);
    public static void main(String []args) throws IOException{
        @SuppressWarnings("resource")
        ServerSocket socket = new ServerSocket(80);
        while(true){
            final Socket connection = socket.accept();
            Runnable task = new Runnable(){
                @Override
                public synchronized void run() {
                    handleResponse(connection,handleRequest(connection));
                }
            };
            exec.execute(task);
        }
    }
}

自定义Executor

1.为每个请求启动一个新线程

import java.util.concurrent.Executor;
public class ThreadPerTaskExecutor implements Executor{
    @Override
    public void execute(Runnable command) {
        new Thread(command).start();
    }
}

2.串行执行任务

import java.util.concurrent.Executor;
public class WithinThreadExecutor implements Executor{
    @Override
    public void execute(Runnable command) {
        command.run();
    }
}

Executor将任务的提交与执行解耦出来

new Thread(task).start();
//当你希望获得一种更灵活的执行策略时,请考虑使用Executor代替Thread
exec.execute(task);

执行策略中定义了任务执行的”What,Where,When,How,Witch”
Where: 在什么线程中执行task
When: 按照什么顺序,什么时间执行task
How: 有多少个任务能够并发
What: 任务执行前后,有做哪些动作
Witch: 系统负载过多,需要拒绝哪一个任务

线程池

字面意思是指: 管理一组同构工作线程的资源池.
通过重用现有的线程,而不是创建线程,可以在处理多个请求是分摊在线程创建和销毁过程中产生的巨大开销.
使用Executors的静态工厂方法来创建线程,直到达到线程池的最大数量.

newFixedThreadPool  固定长度的线程池,每当提交一个任务是就创建一个线程,知道达到线程池的最大数量,这时线程池的规模将不再变化(如果某个线程由于发生了未预期的Exception而结束,那么线程池会补充一个新的线程)

newCachedThreadPool 创建一个可缓存的线程池,如果线程池的当前规模超过了处理需求时,那么将回收空闲的线程,而当需求增加时,则可以添加新的线程,线程池的规模不存在任何限制.

newSingleThreadExecutor 一个单线程的Executor,如果这个线程异常结束,会创建另一个线程来代替.

newScheduledThreadPool  创建了一个固定长度的线程池,而且以延迟或定时的方式来执行任务.

Executor 的生命周期

Executor是没有生命周期的
但是它有一个子接口,ExecutorService有生命周期

package java.util.concurrent;
import java.util.List;
import java.util.Collection;

public interface ExecutorService extends Executor {
    void shutdown();
    List<Runnable> shutdownNow();   
    boolean isTerminated(); 
    boolean awaitTermination(long timeout, TimeUnit unit)throws InterruptedException;
    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    Future<?> submit(Runnable task);
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)throws InterruptedException;
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)
        throws InterruptedException;
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)throws InterruptedException, ExecutionException;  
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

ExecutorService 有三种状态: 运行,关闭,终止.