一、队列
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);
}
