并发编程学习笔记（三十一、线程池源码一，工作线程Worker）

目录：

• ThreadPoolExecutor架构及类结构
• 工作线程Worker源码解析
• 总结

ThreadPoolExecutor架构及类结构

从上图来说ThreadPoolExecutor的锁同步是通过AQS来实现的。

注意：想要读懂ThreadPoolExecutor源码你先了解一下知识点：

• AQS源码
• CAS原理
• Unsafe类
• 位运算
• 设计模式

工作线程Worker源码解析

从整体架构上来说ThreadPoolExecutor的Worker是继承与AQS的，我们来看看Worker类的定义。

private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable {}

从Worker的定义来看我们不难猜到Worker需要有一些锁同步功能，所以继承了AQS；然后它本身想当成线程来使用，所以事先了Runnable接口。

接下来我们来看下Worker内部的实现：

private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{
    /**
     * This class will never be serialized, but we provide a
     * serialVersionUID to suppress a javac warning.
     */
    private static final long serialVersionUID = 6138294804551838833L;

    /** 当前Worker对象正在运行的线程。如果工厂构造失败值会null */
    final Thread thread;
    /** 运行的初始任务，可能为null */
    Runnable firstTask;
    /** 每个线程完成的任务计数器 */
    volatile long completedTasks;

    /**
     * Creates with given first task and thread from ThreadFactory.
     * @param firstTask the first task (null if none)
     */
    Worker(Runnable firstTask) {
        // 设置锁状态为-1（runWorker方法执行前禁止中断）
        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);
    }

    // 一下是锁相关的方法
    //
    // state=0，解锁状态
    // state=1，加锁状态

    /**
     * 判断是否处于独占锁状态
     */
    protected boolean isHeldExclusively() {
        return getState() != 0;
    }

    /**
     * 尝试加锁；
     * true=加锁成功，fasle=加锁失败
     */
    protected boolean tryAcquire(int unused) {
        // CAS从0变成1，也印证了上面所说的0解锁，1加锁
        if (compareAndSetState(0, 1)) {
            // 设置持有者为当前线程
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }

    /**
     * 尝试解锁；
     * true=解锁成功，fasle=解锁失败
     */
    protected boolean tryRelease(int unused) {
        // 解锁后清空持有者
        setExclusiveOwnerThread(null);
        // 解锁后state=0
        setState(0);
        return true;
    }

    /** 加锁，调用AQS.acquire **/
    public void lock()        { acquire(1); }
    /** 尝试加锁，调用AQS.tryAcquire **/
    public boolean tryLock()  { return tryAcquire(1); }
    /** 解锁，调用AQS.release **/
    public void unlock()      { release(1); }
    /** 判断当前锁是否处于加锁状态 **/
    public boolean isLocked() { return isHeldExclusively(); }

    /**
     * 中断，需要线程开始后才能中断
     */
    void interruptIfStarted() {
        Thread t;
        // state >=0：需要获取到锁（state = 1）
        // !t.isInterrupted()：线程未中断才能中断
        if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
            try {
                // 尝试中断线程
                t.interrupt();
            } catch (SecurityException ignore) {
            }
        }
    }
}

总结

1、线程池的Worker类实现了一个不可重进入的互斥锁，其实现主要还是依靠AQS类。

2、Worker类继承自AQS，实现了加锁、解锁等方法。

3、Worker类实现了Runmable接口，重写了run方法，其主要执行逻辑依托于外部类的runWloke方法。

• 在runWorcer方法中将会获取用户提交的任务，将其放在线程池中异步执行，并维护线程池中线程的创建和回收等动作。