由于最近在开发一个嵌入式设备时，用户会进行频繁的取消功能、手机频繁的按返回键等，而且客户的手机配置又低，导致程序在极端测试时出现了屏幕卡顿或应用崩溃的问题。而且我本身的应用框架线程间的通讯主要用的还是AsynchTask与Handler。但是由于android本身提供的这些框架不能让子线程实现立刻停止运行，没法让应用达到最后的体验。所以我决定深研线程，首先从java本身提供的多线程框架与android提供的线程间的通信入手，将其彻底研究透，这样为我自身的框架做一个知识铺垫。没有办法，谁让我是一个喜欢将应用做到极致美的程序猿。接下来就开始我的学习。
java提供的线程池框架
java1.5后引入了Executor框架与Lock锁等。这样我们可以很方便的处理多线程的问题。使用他们很容易，按照api去操作就可以，但是具体是怎么实现的，这个需要深入的学习一下。那么从调用与源码开始。
1、通过Executors入口创建线程池，这是java提供的初始化接口
ExecutorService mCacheThreadExecutor = Executors.newCachedThreadPool();// 一个没有限制最大线程数的线程池
ExecutorService mFixedThreadExecutor = Executors.newFixedThreadPool(count);// 限制线程池大小为count的线程池
ExecutorService mScheduledThreadExecutor = Executors.newScheduledThreadPool(count);// 一个可以按指定时间可周期性的执行的线程池
ExecutorService mSingleThreadExecutor = Executors.newSingleThreadExecutor();// 每次只执行一个线程任务的线程池该四个基本线程池的基本用法与区别，请看这片文章：点击打开链接
2、自定义线程池
ThreadPoolExecutor pool = new ThreadPoolExecutor(1,
2,
60,
TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.DiscardPolicy()
);
pool.prestartAllCoreThreads();3、参数分析
进入Executors内部发现除了newScheduledThreadPool比较特殊，其他三个线程池都使用了ThreadPoolExecutor线程池工厂类，通过它可以快速初始化一个符合业务需求的线程池。例如：
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}其本质是通过不同的参数初始化一个ThreadPoolExecutor对象，具体参数描述如下：
corePoolSize：线程池的核心线程数
当提交一个任务时(1)若线程池数小于该核心数，则创建新线程执行任务
(2)若线程数大于该核心数，则任务被保存到阻塞队列中
另外，ThreadPoolExecutor提供了parestartAllCoreThreads()方法，该方法只能在自定义的线程池中使用。
maximumPoolSize:线程池中允许的最大线程数。
如果当前阻塞队列满了。且继续提交任务，则创建新的线程执行任务，前提是当前的线程数小于maximumPoolSize.
keepAliveTime：线程空闲的存活时间。
当线程没有任务执行时，继续存活的时间，默认情况下，该参数只有线程数大于corePoolSize时才有用。
unit：keepAliveTime的单位。
WorkQueue：用来保存等待被执行的任务的阻塞队列，且任务必须实现Runable接口。提供了如下阻塞队列：
1、ArrayBlockingQueue：基于数组结构的有界阻塞队列，大小固定，按FIFO排序任务；
2、LinkedBlockingQuene：基于链表结构的阻塞队列，按FIFO排序任务，吞吐量通常要高于ArrayBlockingQuene。可以指定大小，也可以不指定大小，不指定的话，大小就是Integer.MAX_VALUE。
3、SynchronousQuene：这个是同步Queue，属于线程安全的BlockingQueue的一种，在SynchronousQueue中，生产者线程的插入操作必须要等待消费者线程的移除操作，Synchronous内部没有数据缓存空间，因此我们无法对SynchronousQueue进行读取或者遍历其中的数据，元素只有在你试图取走的时候才有可能存在。我们可以理解为生产者和消费者互相等待，等到对方之后然后再一起离开。吞吐量通常要高于LinkedBlockingQuene；
4、priorityBlockingQuene：具有优先级的无界阻塞队列。大小就为a和LinkedBlockingQueue类似，不同的是PriorityBlockingQueue中的元素不是按照FIFO来排序的，而是按照元素的Comparator来决定存取顺序的（这个功能也反映了存入PriorityBlockingQueue中的数据必须实现了Comparator接口）。
threadFactory；创建线程的工厂
static class DefaultThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "pool-" +
poolNumber.getAndIncrement() +
"-thread-";//给每个新建的线程设置一个具有识别度的线程名。
}
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
0);
if (t.isDaemon())
t.setDaemon(false);//标记不是守护线程
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);//设置线程优先级为普通
return t;
}
}handler；线程池的饱和策略
当阻塞队列满了，且没有空闲的工作线程，如果继续提交任务，必须采取一种策略处理该任务，线程池提供了4种策略：
1、AbortPolicy：直接抛出异常，默认策略；
2、CallerRunsPolicy：用调用者所在的线程来执行任务；
3、DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
4、DiscardPolicy：直接丢弃任务；
5、也可以根据应用场景实现RejectedExecutionHandler接口，自定义饱和策略，如记录日志或持久化存储不能处理的任务。
4、线程池内部：ThreadPoolExecutor类分析
1、线程池内部状态，通过该类的字段参数控制
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;//32-3=29
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// runState is stored in the high-order bits
private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
private static final int STOP = 1 << COUNT_BITS;
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;
// Packing and unpacking ctl
private static int runStateOf(int c) { return c & ~CAPACITY; }//线程池运行状态
private static int workerCountOf(int c) { return c & CAPACITY; }//工作线程数
private static int ctlOf(int rs, int wc) { return rs | wc; }参数ct1的功能很强大，由于java中int类型是32位的，所以利用低29位表示线程池中线程池数，通过高3位表示线程的运行状态：
1、RUNNING：-1 << COUNT_BITS，即高3位为111，该状态的线程池会接收新任务，并处理阻塞队列中的任务；
2、SHUTDOWN： 0 << COUNT_BITS，即高3位为000，该状态的线程池不会接收新任务，但会处理阻塞队列中的任务；
3、STOP ： 1 << COUNT_BITS，即高3位为001，该状态的线程不会接收新任务，也不会处理阻塞队列中的任务，而且会中断正在运行的任务；
4、TIDYING ： 2 << COUNT_BITS，即高3位为010；
5、TERMINATED： 3 << COUNT_BITS，即高3位为011；
2、SHUTDOWN： 0 << COUNT_BITS，即高3位为000，该状态的线程池不会接收新任务，但会处理阻塞队列中的任务；
3、STOP ： 1 << COUNT_BITS，即高3位为001，该状态的线程不会接收新任务，也不会处理阻塞队列中的任务，而且会中断正在运行的任务；
4、TIDYING ： 2 << COUNT_BITS，即高3位为010；
5、TERMINATED： 3 << COUNT_BITS，即高3位为011；
2、execute方法解析
public void execute(Runnable command) {
if (command == null)//如果任务为空，则抛出异常
throw new NullPointerException();
int c = ctl.get();//获取线程池状态
if (workerCountOf(c) < corePoolSize) {//工作线程数小于核心线程数
if (addWorker(command, true))//添加核心线程数来执行任务<
return;
c = ctl.get();//若新添线程失败，则从新检测线程池状态
}
if (isRunning(c) && workQueue.offer(command)) {//往队列中添加任务,并且成功
int recheck = ctl.get();//再次获取线程池状态
if (! isRunning(recheck) && remove(command))//线程池已经停止工作，并且任务还在队列中
reject(command);//拒绝执行任务
else if (workerCountOf(recheck) == 0)//如果工作线程数为0
addWorker(null, false);
}
else if (!addWorker(command, false))//添加扩展线程
reject(command);
}
3、addWorker实现
从方法execute的实现可以看出：addWorker主要负责创建新的线程并执行任务
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
//尝试增加线程数，增加成功则跳出该循环，否则返回false
for (;;) {//循环1
int c = ctl.get();
int rs = runStateOf(c);//线程池运行状态
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))//如果线程池已经停止工作并且线程池状态不为SHUTDOWN或者firstTask不为null或者workQueue为空其中之一
return false;
for (;;) {
int wc = workerCountOf(c);//或取核心线程数
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))//判断线程数是否已经饱和
return false;
if (compareAndIncrementWorkerCount(c))//增加线程数
break retry;//增加线程数成功，跳出循环1
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)//线程池状态有所变化
continue retry;//继续循环1
// else CAS failed due to workerCount change; retry inner loop
}
}
//添加线程数成功，开始执行下面的代码
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
w = new Worker(firstTask);//创建worker，新线程也是在这里创建的，通过ThreadFactory
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();
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}1、判断线程池的状态，如果线程池的状态值大于或等SHUTDOWN，则不处理提交的任务，直接返回；
2、通过参数core判断当前需要创建的线程是否为核心线程，如果core为true，且当前线程数小于corePoolSize，则跳出循环，开始创建新的线程。
线程池的工作线程通过Woker类实现，在ReentrantLock锁的保证下，把Woker实例插入到HashSet后，并启动Woker中的线程，其中Worker类设计如下：
1、继承了AQS类，可以方便的控制工作线程的状态操作，然后通过线程池的状态与worker的状态来控制是否中止线程。
2、实现了Runnable接口，可以将自身作为一个任务在工作线程中执行；
3、当前提交的任务firstTask作为参数传入Worker的构造方法；
1、继承了AQS类，可以方便的控制工作线程的状态操作，然后通过线程池的状态与worker的状态来控制是否中止线程。
2、实现了Runnable接口，可以将自身作为一个任务在工作线程中执行；
3、当前提交的任务firstTask作为参数传入Worker的构造方法；
代码如下：
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
/** Thread this worker is running in. Null if factory fails. */
final Thread thread;
/** Initial task to run. Possibly null. */
Runnable firstTask;
/** Per-thread task counter */
volatile long completedTasks;
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
/** Delegates main run loop to outer runWorker. */
public void run() {
runWorker(this);
}
// Lock methods
//
// The value 0 represents the unlocked state.
// The value 1 represents the locked state.
protected boolean isHeldExclusively() {
return getState() != 0;
}
protected boolean tryAcquire(int unused) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
protected boolean tryRelease(int unused) {
setExclusiveOwnerThread(null);
setState(0);
return true;
}
public void lock() { acquire(1); }
public boolean tryLock() { return tryAcquire(1); }
public void unlock() { release(1); }
public boolean isLocked() { return isHeldExclusively(); }
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
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
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);
}
}1、线程启动之后，通过unlock方法释放锁，设置AQS的state为0，表示当前线程为正常状态，可以工作。
2、获取第一个任务firstTask，这个任务是创建该线程时就传递进来的任务。执行任务的run方法，不过在执行任务之前，会进行加锁操作，任务执行完会释放锁；
3、在执行任务的前后，可以根据业务场景自定义beforeExecute和afterExecute方法，这个需要从新定义ThreadPoolExecutor，实现里面的方法。我会在最后将这个功能用代码实现。
4、firstTask执行完成之后，通过getTask方法从阻塞队列中获取等待的任务(上述代码的第八行)，如果队列中没有任务，getTask方法会被阻塞并挂起，不会占用cpu资源；
getTask实现代码如下：
private Runnable getTask() {
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.
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;
}
}
}1、workQueue.take：如果阻塞队列为空，当前线程会被挂起等待；当队列中有任务加入时，线程被唤醒，take方法返回任务，并执行；(在倒数第10行可以看到)
2、workQueue.poll：如果在keepAliveTime时间内，阻塞队列还是没有任务，则返回null；
所以，线程池中实现的线程可以一直执行由用户提交的任务。
线程的挂起与唤醒，是在队列中实现的，实质还是Lock锁的休眠与唤醒代码如下：
public E take() throws InterruptedException {
E x;
int c = -1;
final AtomicInteger count = this.count;
final ReentrantLock takeLock = this.takeLock;
takeLock.lockInterruptibly();
try {
while (count.get() == 0) {
notEmpty.await();
}
x = dequeue();
c = count.getAndDecrement();
if (c > 1)
notEmpty.signal();
} finally {
takeLock.unlock();
}
if (c == capacity)
signalNotFull();
return x;
} /**
* Signals a waiting take. Called only from put/offer (which do not
* otherwise ordinarily lock takeLock.)
*/
private void signalNotEmpty() {
final ReentrantLock takeLock = this.takeLock;
takeLock.lock();
try {
notEmpty.signal();
} finally {
takeLock.unlock();
}
}
线程池实现beforeExecute和afterExecute方法，示例代码如下：
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* Created by Xi on 2017
*/
public class DefineThreadPoolExecutor {
public void toDefine(){
final Runnable ru=new Runnable() {
@Override
public void run() {
System.out.println("run1执行了。。。。");
}
};
final Runnable ru2=new Runnable() {
@Override
public void run() {
System.out.println("run2执行了。。。。");
}
};
//自定义线程池，实现beforeExecute、afterExecute方法
ThreadPoolExecutor pool = new ThreadPoolExecutor(3,
5,
60,
TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.DiscardPolicy()
){
@Override
protected void beforeExecute(Thread t, Runnable r) {
super.beforeExecute(t, r);
if(r.equals(ru)){//若当前Runnable为任务1才输出日志
System.out.println("之前执行了。。。。");
}
}
@Override
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
System.out.println("之后执行了。。。。");
}
};
pool.execute(ru);
pool.execute(ru2);
}
}
new DefineThreadPoolExecutor().toDefine();
下面来一个重磅，线程池内部整体流程图：
1131
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
