一、队列

1.队列

队列是先进先出的数据结构(FIFO)，在队尾插入，在对头取出。

2.阻塞队列

当队列满时，继续插入数据的线程将被阻塞；
当队列为空，继续获取数据的线程将被阻塞；
上述这种情况的处理方式除了一直阻塞也有其他方式：
1.抛出异常；
2.返回特殊值；
3.一直阻塞；
4.超时退出；

3.常见阻塞队列

ArrayBlockingQueue：用数组结构实现，需要指定大小，也就是有界。插入和取出用的是同一把锁，默认锁为非公平，可以指定为公平锁。公平锁即先入队的元素可以保证先获取锁。

    public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }

LinkedBlockingQueue：用链表结构实现，有界。默认为Integer.MAX_VALUE。插入和取出用的是不同的锁，这样保证了效率。非公平锁，无法指定为公平锁，这也是为了效率考虑。

PriorityBlockingQueue：支持优先级的阻塞队列。默认自然升序排序，也可通过实现Comparator的compareTo()指定排序规则。

DelayQueue：支持延期，支持优先级的阻塞队列。

SynchronousQueue：只能存储一个元素的队列，插入一个必须取出之后才能再次插入，这也就意味着需要消费者及时消费。

ArrayBlockingQueue与LinkedBlockingQueue的区别：
1.ArrayBlockingQueue插入和取出用的同一把锁，有失效率；LinkedBlockingQueue插入和取出用不同的锁；
2.ArrayBlockingQueue可以指定公平锁，LinkedBlockingQueue不能指定公平锁；
3.ArrayBlockingQueue因为是数组实现，必须指定大小；LinkedBlockingQueue不需要指定大小；
4.ArrayBlockingQueue直接将对象插入；LinkedBlockingQueue需要将对象装换为Node之后才能插入，有失效率。

二、线程池

1.线程池的作用

1.减少资源消耗，进程内同一时间能创建的线程是有限的，线程需要占用资源，减少线程就是减少资源消耗；
2.提高响应速度，节省线程创建所需要的时间。
3.统一线程的管理和调度，合理分配资源。

2.线程池相关类

Executor：接口，定义执行任务的方法void execute(Runnable command);

ExecutorService:接口，继承Executor，定义一些线程池接口，如：

void shutdown();
List<Runnable> shutdownNow();
boolean isTerminated();

AbstractExecutorService：抽象类，实现ExecutorService中的大部分方法。
ThreadPoolExecutor：线程池核心类，通过不同的参数，构建不同的线程池。

3.线程池的参数

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
  ...
}

corePoolSize：核心线程数，最开始创建的线程就是核心线程，直到核心线程数满了，则将任务放入队列。
maximumPoolSize：最大线程数，当队列满了，则会创建核心线程数执行任务。
keepAliveTime：存活时间value值，存活时间是指超过核心线程数的空闲线程能存活的时间。
unit：存活时间单位。
workQueue：阻塞队列，核心线程数满了，则将任务放入队列。
threadFactory:线程工厂，可以定义线程的名称；
handler：拒绝策略，当队列满了，最大线程也满了，没有空闲线程，则调用拒绝策略的rejectedExecution()

四种拒绝策略：
        （1）AbortPolicy：直接抛出异常，默认策略；

        （2）CallerRunsPolicy：用调用者所在的线程来执行任务；

        （3）DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；

        （4）DiscardPolicy：直接丢弃任务；

4.线程池工作机制

1.创建核心线程执行任务；
2.核心线程满了，没有空闲的核心线程，则将任务加入阻塞队列；
3.队列满了，线程数没超过最大线程数，继续创建线程执行任务；
4.队列满了，线程数达到最大线程数，没有空闲线程，交给拒绝策略；

5.线程池用法

1.俩种提交方式

execute：直接提交没有返回值；
submit：返回future对象，通过future.get()获得返回值，get()会阻塞直到有结果，也可以指定等待时长get(long,TimeUnit )

2.线程池的关闭

shutdown():遍历工作线程，调用interrupt(),如果不响应中断，则线程不会停止；将线程池设置为SHUTDOWN状态。无返回值。shutdown()中断的是不在执行任务的线程；一般情况下用这个方法
shutdownNow()：遍历工作线程，调用interrupt(),如果不响应中断，则线程不会停止；将线程池设置为STOP状态。返回等待执行任务的列表。shutdownNow()中断所有线程。如果不管线程是否执行任务都要中断，则用这个方法。

3.线程池的配置

IO密集：IO线程池，因为不用一直占用CPU，可以分配多一点线程，一般配置2N+1；
CPU密集：需要经常使用CPU，一般分配N+1；
CPU核数：Runtime.getRuntime().availableProcessors()

6.常见线程池

Executors类中提供了各种线程池的创建方法，常见的有以下四种。

1.FixedThreadPool

核心线程数等于最大线程数，采用LinkedBlockingQueue，无界。

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

2.CachedThreadPool

没有核心线程，不限制最大线程数，也就是为Integer.MAX_VALUE，采用SynchronousQueue队列，也是不缓存任务，只交接任务，接受一个执行一个。
CachedThreadPool适用于有大量需要立即执行的耗时少的任务的情况

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

3.SingleThreadPool

核心线程和最大线程都是1.采用LinkedBlockingQueue无界队列。

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

4.ScheduledThreadPool

周期性任务线程池。采用DelayedWorkQueue队列，一个按超时时间升序排序的队列。

    public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }


    public ScheduledThreadPoolExecutor(int corePoolSize,
                                       ThreadFactory threadFactory) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue(), threadFactory);
    }