线程学习 （三） 线程池的使用

线程的各个状态图：

1.线程池（ThreadPoolExecutor）的实现：

1.1
通过继承 ThreadPoolExecutor 类 来实现

public class ThreadPoolExecutorTest extends ThreadPoolExecutor {

public ThreadPoolExecutorTest(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime, TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
    super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}

}

1.2通过实现 ExecutorService 接口

public class ThreadPoolExecutorTest implements ExecutorService {

@Override
public void shutdown() {

}

@Override
public List<Runnable> shutdownNow() {
    return null;
}

@Override
public boolean isShutdown() {
    return false;
}

@Override
public boolean isTerminated() {
    return false;
}

@Override
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
    return false;
}

@Override
public <T> Future<T> submit(Callable<T> task) {
    return null;
}

@Override
public <T> Future<T> submit(Runnable task, T result) {
    return null;
}

@Override
public Future<?> submit(Runnable task) {
    return null;
}

@Override
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
    return null;
}

@Override
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException {
    return null;
}

@Override
public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
    return null;
}

@Override
public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
    return null;
}

@Override
public void execute(Runnable command) {

}

}

2.线程池（ThreadPoolExecutor）的参数

ThreadPoolExecutorTest(int corePoolSize,
int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue workQueue)

2.1 corePoolSize 核心线程

线程池主要用于执行任务的是“核心线程”，“核心线程”的数量是你创建线程时所设置的corePoolSize参数决定的。如果不进行特别的设定，线程池中始终会保持corePoolSize数量的线程数（不包括创建阶段）

线程池在程序运行时会出现下面几种情况

2.1.1
当线程池中核心线程数量没有达到 corePoolSize 时，线程池都会生成一个新的线程来完成你当前的任务，不管当前线程池中是否有闲置线程

2.1.2
当线程池的线程数量达到 corePoolSize 时，当前任务会被加到一个等待队列中，等到核心线程中的线程空闲后进行执行

2.1.3 当线程池的线程数量达到 corePoolSize并且也不能加入等待队列中时，线程池会创建一个非核心线程执行任务

当线程池执行玩任务后，空闲的非核心线程就会被回收，知道线程池内线程数达到 corePoolSize，线程池线程数少于corePoolSize 不进行回收。

2.2 maximumPoolSize 线程总数/最大线程数

当前线程池允许创建的最大线程数量。那么如果设置的corePoolSize参数和设置的maximumPoolSize参数一致时，线程池在任何情况下都不会回收空闲线程。keepAliveTime和timeUnit也就失去了意义

2.3 keepAliveTime 等待存活时间 timeUnit 量化参数（time）

keepAliveTime参数和timeUnit参数也是配合使用的。keepAliveTime参数指明等待时间的量化值，timeUnit指明量化值单位。例如keepAliveTime=1，timeUnit为TimeUnit.MINUTES，代表空闲线程的回收阀值为1分钟。

2.4 BlockingQueue 可阻塞队列

实现简单的线程池：（没有等待序列状况下）

代码：

import java.util.concurrent.*;

public class ThreadPoolExecutorTest {

public static void main(String[] args) {

    ThreadPoolExecutor executor = new ThreadPoolExecutor(5,//核心线程数量
            10,//最大线程数量限制
            10,//空闲等待时间（非核心线程到达时间还处于空闲状态将被回收）
            TimeUnit.SECONDS,//keepAliveTime 量化单位
            new ArrayBlockingQueue<Runnable>(3));//等待线程队列


    for (int i = 0; i < executor.getMaximumPoolSize(); i++) {
        executor.execute(new Thread(new ThreadTest(i)));
        //核心线程数量
        System.out.println(executor.getCorePoolSize());
    }


}


static class ThreadTest implements Runnable {

    int index;

    public ThreadTest(int index) {
        this.index = index;
    }

    @Override
    public void run() {
        System.out.println("i'm Thread"+ index );
    }
}

}

结果：

需要等待序列时：

import java.util.concurrent.*;

public class ThreadPoolExecutorTest {

public static void main(String[] args) {

    ThreadPoolExecutor executor = new ThreadPoolExecutor(5,//核心线程数量
            10,//最大线程数量限制
            10,//空闲等待时间（非核心线程到达时间还处于空闲状态将被回收）
            TimeUnit.SECONDS,//keepAliveTime 量化单位
            new ArrayBlockingQueue<Runnable>(1));//等待线程队列

//超出线程池最大容量很多的情况下（超出很小的话线程池一般不会过载）
for (int i = 0; i < 100; i++) {
executor.execute(new Thread(new ThreadTest(i)));
System.out.println(executor.getQueue().size());
}

}


static class ThreadTest implements Runnable {

    int index;

    public ThreadTest(int index) {
        this.index = index;
    }

    @Override
    public void run() {
        System.out.println("i'm Thread"+ index );
    }
}

}

结果：

java.util.concurrent.RejectedExecutionException
等待序列已满 拒绝新插入的线程

代码：（不设置等待序列）

import java.util.concurrent.*;

public class ThreadPoolExecutorTest {

public static void main(String[] args) {

    ThreadPoolExecutor executor = new ThreadPoolExecutor(5,//核心线程数量
            10,//最大线程数量限制
            10,//空闲等待时间（非核心线程到达时间还处于空闲状态将被回收）
            TimeUnit.SECONDS,//keepAliveTime 量化单位
            new ArrayBlockingQueue<Runnable>(0));//等待线程队列

//这里设置线程数量比最大量多1
for (int i = 0; i < 11; i++) {
executor.execute(new Thread(new ThreadTest(i)));
System.out.println(executor.getQueue().size());
}

}


static class ThreadTest implements Runnable {

    int index;

    public ThreadTest(int index) {
        this.index = index;
    }

    @Override
    public void run() {
        System.out.println("i'm Thread"+ index );
    }
}

}

结果：

java.lang.IllegalArgumentException

不设置等待序列报的非法异常