线程池源码解析——工作线程

ThreadPoolExecutor类图

Worker类的声明

private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable

线程池中的工作线程是通过内部类Worker表示的。Worker继承自AbstractQueueSynchronizer，可以实现同步器的功能；同是实现了Runable接口，因此Worker是可以当做线程使用的。

Worker源码分析

    private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        /**
         * serialVersionUID
         */
        private static final long serialVersionUID = 6138294804551838833L;

        /** 当前Worker对象运行的环境 */
        final Thread thread;
        /** Worker要执行的初始任务，可能为null */
        Runnable firstTask;
        /** 每个线程执行完的任务个数 */
        volatile long completedTasks;

        /**
         * 构造器
         */
        Worker(Runnable firstTask) {
        	//runWorker方法执行前禁止中断
            setState(-1); // inhibit interrupts until runWorker
            //初始化firstTask属性
            this.firstTask = firstTask;
            //从线程工厂中创建一个线程
            this.thread = getThreadFactory().newThread(this);
        }

        /** 
        * 重写run方法
        * 调用外部类ThreadPoolExecutor的runWorker方法
        */
        public void run() {
            runWorker(this);
        }

        // 以下是锁的方法
        //
        // state等于0 表示解锁状态
        // state等于1 表示加锁状态
		
		/**
		 * 判断是否处于独占锁状态
		 */
        protected boolean isHeldExclusively() {
            return getState() != 0;
        }
		
		/**
		 * 尝试加锁
		 */
        protected boolean tryAcquire(int unused) {
        	//CAS修改state状态0----->1
            if (compareAndSetState(0, 1)) {
            	//如果CAS成功
            	//将当前线程设置为锁的持有者
                setExclusiveOwnerThread(Thread.currentThread());
                //返回加锁成功
                return true;
            }
            //返回加锁失败
            return false;
        }
		
		/**
		 * 尝试解锁
		 */
        protected boolean tryRelease(int unused) {
        	//将锁的持有者设置为null
            setExclusiveOwnerThread(null);
            //将state状态设置为0
            setState(0);
            //返回解锁成功
            return true;
        }
		
		/** 加锁方法，调用父类AQS的acquire方法 */
        public void lock()        { acquire(1); }
        /** 尝试加锁方法，调用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（初始状态为-1）
            //Worker对象的thread属性非空
            //t.isInterruted为false，线程未被中断
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                }
            }
        }
    }

总结

• 线程池的Worker类实现了一个不可重入的互斥锁，其实现主要是依赖AQS类。
• Worker类继承自AQS，实现了加锁/解锁等方法。
• Worker类实现了Runable接口，重写了run方法，其主要执行逻辑依托于外部类的runWorker方法。在runWorker方法中将会获取用户提交的任务，将其放在线程池中异步执行，并维护线程池中线程的创建和回收等动作。