线程：
线程是CUP调度资源的最小单位，线程模型分为KLT模型和ULT模型，JVM使用的是KLT模型，java线程与OS线程保持着1：1的映射关系，也就是说一个java线程在操作系统中有一个对应的线程；
线程的6中生命状态：
NEW：新建，还没有调用start()方法；
RUNNABLE：运行
BLOCKED：阻塞
WAITING：等待
TIMED_WAITING：超时等待
TERMINATED：终结
协程：
协程（纤程，用户级线程），目的是为了最求最大力度的发挥硬件的性能和提升软件的速度；协程的基本原理是：挂起当前的任务，并且保存栈信息，去执行另一个任务；等完成或到达某个条件时，再还原原来的栈信息并继续执行，整个过程不需要上下文的切换；java原生不支持协程，如果需要使用，需要引入jar包：quasar。
线程池：
是线程的缓存，线程是是一种珍贵的资源，如果进行频繁的创建于销毁，会消耗大量的CUP资源和内存资源，对程序性能造成很大的影响，为了避免这一问题，java提供了线程池对线程进行统一的分配、调优和监控；
什么时候使用线程池：
单个任务执行时间比较短；
需要处理的任务量很大；
线程池的好处：
重用存在的线程，减少线程的创建和销毁的系统资源开销，提高性能；
提高性能；任务到达时不需要等待线程的创建就能执行；
提高线程的可管理性；提供了统一的分配、调优和监控；
任务的创建有两个接口：
Runnable没有返回结果的；Callable具有返回结果的；
Excutor框架：
ThreadPoolExcutor实现了最基础的Excutor接口，其定义了最基础的执行任务的方法execute(Runnable command)；
ThreadPoolExcutor类中的重要属性
//这个值记录了线程池的状态（runState）和有效线程的数量（workCount）,高3位保存runState、低29位保存workCount；
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
//等于29
private static final int COUNT_BITS = Integer.SIZE - 3;
//2的29次方减1；最大的有效线程数量
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
//线程池的状态
//高3位为111
private static final int RUNNING = -1 << COUNT_BITS;
//高3位为000
private static final int SHUTDOWN = 0 << COUNT_BITS;
//高3位001
private static final int STOP = 1 << COUNT_BITS;
//高3位010
private static final int TIDYING = 2 << COUNT_BITS;
//高3位010
private static final int TERMINATED = 3 << COUNT_BITS;
线程池状态：
1、RUNNING：表示线程池处于运行状态，能接受新添加的任务且能够对已添加的任务进行处理。线程池的初始化状态就是RUNNING状态，也就是一创建就是这个状态；
2、SHUTDOWN：不接受新任务，但可以处理已添加的任务；调用shutdown()方法；
3、STOP：不接受新任务，不处理已添加的任务，并且会中断正在执行任务的线程；调用shutdownNow()方法；
4、TIDYING：所有任务已经终止，且任务数量为0时，线程池会进入TIDYING状态，会执行钩子函数terminated()，此方法为空方法；当处于SHUTDOWN状态时，队列中的任务已经被执行完，且没有正在执行的任务了，状态会从SHUTDOWN状态变为TIDYING状态；当处于STOP状态时，没有正在执行的任务时，则从STOP状态变为TIDYING状态；
5、TERMINATED：线程池彻底终止；处于TIDYING状态，执行完terminated()函数之后，从TIDYING状态变为TERMINATED状态；
线程池的具体实现：
ThreadPoolExecutor 默认线程池
ScheduledThreadPoolExecutor 定时线程池；
线程池的参数：
线程池中构造函数有多个，但是最终都会调到下面的一个构造函数：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
看一下每个参数的含义：
corePoolSize：核心线程数，当提交一个任务时，线程池会新创建一个线程来执行该任务，直到当前线程数等于corePoolSize；如果当前线程数等于corePoolSize，继续提交的任务会被保存到阻塞队列中，等待被执行；如果线程池执行了prestartAllCoreThreads()方法，则会提前创建核心线程；
maxinumPoolSize：线程池支持的最大线程数；当前线程数已经大于等于corePoolSize,且阻塞队列已满，则继续提交任务时会创建新的线程来执行任务，但是总线程数要小于等于maxinumPoolSize；
keepAliveTime：非核心现场所允许的空闲时间；非核心外的线程如果获取不到任务执行，空闲时间超过keepAliveTime,就会被销毁；
unit：keepAliveTime单位；
workQueue：阻塞队列，用来保存来不及执行的任务；当总线程数大于等于
corePoolSize，且有新的任务被提交时，就会放到这个队列中；
threadFactory：创建线程的工厂；默认使用Executors.defaultThreadFactory()来创建线程，创建的线程具有相同的NORM_PRIORITY优先级并且是非守护线程，同时设置了线程名称；
handler：线程池的拒绝策略；但阻塞队列已满，并且线程数已达到maxinumPoolSize，再向线程池提交任务就会执行拒绝策略；
线程池提供了4种拒绝策略：（都是ThreadPoolExecutor的内部类）
AbortPolicy：直接抛出异常，默认策略；
CallerRunsPolicy：用调用这个线程池的线程来执行该任务；
DiscardOldestPolicy：丢弃阻塞队列中最前的任务，并且执行当前任务（把当前任务加在队列的最后面）；
DiscardPolicy：直接丢弃任务；
如果上面线程池提供的4种拒绝策略不满足业务，则可以自定义拒绝策略，比如持久化不能处理的任务，我们可以实现RejectedExecutionHandler接口；
线程池的监控方法：
public long getTaskCount()：获取线程池中已执行和未执行的任务总和；
public long getCompletedTaskCount() ：获取已完成的任务数；
public int getPoolSize() ：获取当前线程数量；
public int getActiveCount() ：获取线程中正在执行任务的线程；
线程池的执行流程：
1、提交任务，如果线程数小于corePoolSize,则新建一个线程执行当前提交的任务，这些线程称为核心线程；
2、当线程数量等于corePoolSize，提交任务，就会把提交的任务放到阻塞队列中；
3、当提交新任务时，此时队列已满，则会新创建线程来执行这个任务；但是线程池总线程数量不能大于maxinumPoolSize；
4、当线程总数大于corePoolSize且线程空闲时间大于设置的空闲时间时，则该空闲线程就会被销毁，当线程池总线程数等于corePoolSize时，就不会再销毁线程；
5、当线程总数已达到maxinumPoolSize，且队列已满，再提交任务时，就会执行拒绝策略；
ThreadPoolExecutor源码分析：
execute(Runnable command)方法：向线程池提交任务的方法；
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* Proceed in 3 steps:
*
* 1. If fewer than corePoolSize threads are running, try to
* start a new thread with the given command as its first
* task. The call to addWorker atomically checks runState and
* workerCount, and so prevents false alarms that would add
* threads when it shouldn't, by returning false.
*
* 2. If a task can be successfully queued, then we still need
* to double-check whether we should have added a thread
* (because existing ones died since last checking) or that
* the pool shut down since entry into this method. So we
* recheck state and if necessary roll back the enqueuing if
* stopped, or start a new thread if there are none.
*
* 3. If we cannot queue task, then we try to add a new
* thread. If it fails, we know we are shut down or saturated
* and so reject the task.
*/
//获取ctl的值，上面已经介绍过，此值的高三位记录线程池的状态，后三位记录线程个数
int c = ctl.get();
//当工作线程个数小于corePoolSize时，会创建一个线程，并执行当前的任务，这个线程会封装成一个Worker对象（线程池内部类）的一个属性
if (workerCountOf(c) < corePoolSize) {
//创建新线程来执行任务，第二个参数ture代表，比较当前工作线程是否大于等于corePoolSize,如果判断为真，则返回false，会执行下面的逻辑；
如果第二个参数为false，则代表线程总数和maxinumPoolSize做比较，下面创建非核心线程就是传的是false;
if (addWorker(command, true))
return;
c = ctl.get();
}
//到达这一步说明总线程数大于等于corePoolSize;
//如果当前线程池是RUNNING状态，则把任务添加到阻塞队列中；
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
//再次检查线程池的状态，因为中途状态可能发生改变；如果不是RUNNING状态，则移除添加到队列的任务，并且执行拒绝策略；
if (! isRunning(recheck) && remove(command))
reject(command);
//如果线程数为0，则进行添加线程，因为如果执行public void allowCoreThreadTimeOut(boolean value)设置allowCoreThreadTimeOut属性等于ture，则所有线程都就空闲超时时间；
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//到达这里说明，队列已满，则创建非核心线程来执行提交的任务；如果线程池状态不是RUNNING状态或者已达到maxinumPoolSize，则不会执行任务，并且会进入判断里执行拒绝策略；
else if (!addWorker(command, false))
reject(command);
}
这个方法里展示了线程池的主要要逻辑，先判断当前线程总数是否小于corePoolSize，如果是小于核心线程数，则创建线程执行当前任务；
当总线程数大于corePoolSize，，把任务提交到阻塞队列中；
如果提交失败，则继续创建非核心线程执行当前任务，如果当前总线程数大于等于maxinumPoolSize,则会执行拒绝策略；
再看一下private boolean addWorker(Runnable firstTask, boolean core)方法：
private boolean addWorker(Runnable firstTask, boolean core) {
//这是一个循环跳出标识，名字自定义，是为了解决多循环嵌套在最里面循环执行break时跳出所有循环；
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
//先做判断：这个含义就是如果线程池状态大于SHUTDOWN则直接进行返回，不创建线程并且丢弃当前任务；如果等于SHUTDOWN并且（阻塞队列为空或提交任务不为null），则不创建线程直接返回；
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
//通过自旋和CAS来修改总线程数；如果修改成功则跳出循环，如果失败再次重试
for (;;) {
int wc = workerCountOf(c);
//当前总线程数是否大于等于指定线程数，如果大于等于则不进行创建线程来执行当前任务
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
//创建worker对象，实现了Runnable接口，在构造函数中创建了新的线程且把worker对象传给了这个新创建的线程，并赋值给其final Thread thread属性
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
//加锁，是为了线程池里个别属性的修改以及状态的判断
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
//加入到HashSet中，方便管理
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
//这一步就是启动新创建的线程，执行这一步后，就会执行worker对象的run()方法
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
这个addWorker线程的主要做了：先判断当前线程池的状态，根据状态来是否创建新线程和执行当前任务；
然后创建新的线程，并启动新线程来执行当前任务；
其实现了AbstractQueuedSynchronizer（AQS）框架，具有了独占锁的功能但不支持可重入，重写了里面的部分方法来得到了不可重入的效果；即可通过isHeldExclusively来判断线程是否处于独占状态；如果处于独占状态，则说明线程正在执行任务；如果处于非独占状态，则说明线程处于空闲状态；后面的执行shutdown()方法时，就是给空闲的线程加上中断状态，二这个不可重入的独占锁就是判断线程是否空闲的依据；
Worker对象的构造函数
Worker(Runnable firstTask) {
//初始化时，标识为-1,是为了刚创建的线程还没执行任务，是不允许被中断的；
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
//创建新线程，并传入当前对象；
this.thread = getThreadFactory().newThread(this);
}
看一下worker对象的run()方法：这个就是从阻塞队列中获取任务，执行任务
public void run() {
runWorker(this);
}
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
//循环获取阻塞队列中的任务；如果获取时返回为null，则就会跳出循环；这就是所谓的对线程进行销毁
while (task != null || (task = getTask()) != null) {
//获取独占锁
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
//如果线程池状态大于等于STOP，则给每个线程打上中断标记，在线程从阻塞队列获取任务时或报异常；直接销毁线程
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
//执行提交的任务
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
getTask()再看一下从阻塞队列获取任务的方法：
private Runnable getTask() {
//这个标识是为了控制销毁空闲线程时，总线程数维持在corePoolSize;
//当为true并且总线程数大于corePoolSize时，当前任务就会返回null，也就是当前线程被销毁
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
//如果当前线程池等于SHUTDOWN状态并且阻塞队列中没有任务，或者线程池状态大于等于STOP，则销毁当前线程；
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
//当前总线程数是否大于核心线程数，或者之前说的设置允许所有线程够可以超时；
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
//这一步判断及里面的逻辑是为了控制销毁空闲线程时，线程总数维持在核心线程数；
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
//从这里可以看出控制空闲线程超时和维持线程存活的原因是因为从阻塞队列中获取任务；
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
再看一下线程销毁或者执行任务出现异常退出获取阻塞队列任务循环的方法：
从上面代码可以看出如果任务执行时出现异常，则boolean completedAbruptly = true，否则等于false;
private void processWorkerExit(Worker w, boolean completedAbruptly) {
//如果任务出现异常则，总线程数减1；
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
//获取独占锁，这个在前面创建线程时使用过；
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
completedTaskCount += w.completedTasks;
//移除当前worker
workers.remove(w);
} finally {
mainLock.unlock();
}
tryTerminate();
int c = ctl.get();
//如果线程池状态小于STOP，也就是RUNNING或者SHUTDOWN状态；
if (runStateLessThan(c, STOP)) {
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
//则会新创建一个线程；加入线程池中；代替出现异常被销毁的线程；
addWorker(null, false);
}
}
462
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
