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;

    /** 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;

    /**
      * Creates with given first task and thread from ThreadFactory.
      * @param firstTask the first task (null if none)
      */
    Worker(Runnable firstTask) {
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }

}

/**
  * Set containing all worker threads in pool. Accessed only when
  * holding mainLock.
  */
private final HashSet<Worker> workers = new HashSet<Worker>();

/**
    * The queue used for holding tasks and handing off to worker
    * threads.  We do not require that workQueue.poll() returning
    * null necessarily means that workQueue.isEmpty(), so rely
    * solely on isEmpty to see if the queue is empty (which we must
    * do for example when deciding whether to transition from
    * SHUTDOWN to TIDYING).  This accommodates special-purpose
    * queues such as DelayQueues for which poll() is allowed to
    * return null even if it may later return non-null when delays
    * expire.
    */
private final BlockingQueue<Runnable> workQueue;

public ThreadPoolExecutor(int corePoolSize,
                        int maximumPoolSize,
                        long keepAliveTime,
                        TimeUnit unit,
                        BlockingQueue<Runnable> workQueue,
                        ThreadFactory threadFactory,
                        RejectedExecutionHandler handler) {}

/**
  * Returns true if this pool allows core threads to time out and
  * terminate if no tasks arrive within the keepAlive time, being
  * replaced if needed when new tasks arrive. When true, the same
  * keep-alive policy applying to non-core threads applies also to
  * core threads. When false (the default), core threads are never
  * terminated due to lack of incoming tasks.
  *
  * @return {@code true} if core threads are allowed to time out,
  *         else {@code false}
  *
  * @since 1.6
  */
public boolean allowsCoreThreadTimeOut() {
    return allowCoreThreadTimeOut;
}

    /** Lock held by take, poll, etc */
    private final ReentrantLock takeLock = new ReentrantLock();

    /** Wait queue for waiting takes */
    private final Condition notEmpty = takeLock.newCondition();

    /** Lock held by put, offer, etc */
    private final ReentrantLock putLock = new ReentrantLock();

    /** Wait queue for waiting puts */
    private final Condition notFull = putLock.newCondition();

    /** 存储队列元素的数组 */
    final Object[] items;

    /** 取下一个元素的index */
    int takeIndex;

    /** 放下一个元素的index */
    int putIndex;

    /** 队列中元素的个数 */
    int count;

    public void put(E e) throws InterruptedException {
        checkNotNull(e);    //非空
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();   //加锁
        try {
            while (count == items.length)   //队列已满，阻塞
                notFull.await();
            enqueue(e); //入队
        } finally {
            lock.unlock();  //解锁
        }
    }

public boolean offer(E e) {
    if (e == null)
        throw new NullPointerException();
    final ReentrantLock lock = this.lock;
    lock.lock();    //加锁
    int n, cap;
    Object[] array;
    //如果当前元素个数>=数组容量，扩容
    while ((n = size) >= (cap = (array = queue).length))
        tryGrow(array, cap);
    try {
        //比较元素，放入队列
        Comparator<? super E> cmp = comparator;
        if (cmp == null)
            siftUpComparable(n, e, array);
        else
            siftUpUsingComparator(n, e, array, cmp);
        //数组元素个数+1
        size = n + 1;
        //唤醒notEmpty条件队列上的一个元素
        notEmpty.signal();
    } finally {
        lock.unlock();  //释放锁
    }
    return true;
}

private void tryGrow(Object[] array, int oldCap) {
    lock.unlock(); //扩容前，先释放锁，不阻塞take操作
    Object[] newArray = null;
    //cas保证只会有一个线程进行扩容
    if (allocationSpinLock == 0 &&
        UNSAFE.compareAndSwapInt(this, allocationSpinLockOffset,
                                    0, 1)) {
        try {
            //计算新容量，上限是Integer.MAX_VALUE - 8
            int newCap = oldCap + ((oldCap < 64) ?
                                    (oldCap + 2) : // grow faster if small
                                    (oldCap >> 1));
            if (newCap - MAX_ARRAY_SIZE > 0) {    // possible overflow
                int minCap = oldCap + 1;
                if (minCap < 0 || minCap > MAX_ARRAY_SIZE)
                    throw new OutOfMemoryError();
                newCap = MAX_ARRAY_SIZE;
            }
            //创建新的数组
            if (newCap > oldCap && queue == array)
                newArray = new Object[newCap];
        } finally {
            allocationSpinLock = 0;
        }
    }
    //并发时，只会有一个线程能通过cas，其他线程会调用Thread.yield()，让出cpu
    //但是还是有可能在newArray=null(未完成扩容)的情况下，其他的获取了锁(概率比较小而已)
    if (newArray == null) // back off if another thread is allocating
        Thread.yield();
    lock.lock();
    if (newArray != null && queue == array) {
        queue = newArray;
        System.arraycopy(array, 0, newArray, 0, oldCap);
    }
}

 public boolean offer(Runnable x) {
    RunnableScheduledFuture<?> e = (RunnableScheduledFuture<?>)x;
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        int i = size;
        //扩容
        if (i >= queue.length)
            grow();
        size = i + 1;
        //如果原来队列为空，存放到数组第一个位置
        if (i == 0) {
            queue[0] = e;
            setIndex(e, 0);
        } else {
            //按二叉树堆的存放顺序存放到数组中
            siftUp(i, e);
        }
        //如果之前队列为空，添加了元素，通知在等待的线程
        if (queue[0] == e) {
            leader = null;
            available.signal();
        }
    } finally {
        lock.unlock();
    }
    return true;
}

 public RunnableScheduledFuture<?> take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        for (;;) {
            //获取第一个元素，如果为空，则说明队列为空，等待唤醒
            RunnableScheduledFuture<?> first = queue[0];
            if (first == null)
                available.await();
            else {
                //获取延迟时间
                long delay = first.getDelay(NANOSECONDS);
                //如果任务不用等待，从堆上拿走返回给线程
                if (delay <= 0)
                    return finishPoll(first);
                first = null; // don't retain ref while waiting
                //如果任务需要等待，且已经有一个线程在等待执行任务了(在等待的肯定先执行)，当前线程等待唤醒
                if (leader != null)
                    available.await();
                else {
                    //设置leader为当前线程，等待delay时间
                    Thread thisThread = Thread.currentThread();
                    leader = thisThread;
                    try {
                        available.awaitNanos(delay);
                    } finally {
                        //重置leader
                        if (leader == thisThread)
                            leader = null;
                    }
                }
            }
        }
    } finally {
        //拿到任务，唤醒在等待的线程，释放锁。
        if (leader == null && queue[0] != null)
            available.signal();
        lock.unlock();
    }
}

public static void main(String[] args) throws ExecutionException, InterruptedException {
    //testCallable();
    testRunnable();
}

public static void testCallable() throws ExecutionException, InterruptedException {
    Callable<String> callable = () -> {
        System.out.println("Callable started");
        Thread.sleep(3000L);
        System.out.println("Callable over");
        return "callable result";
    };
    FutureTask<String> futureTask = new FutureTask<>(callable);
    new Thread(futureTask).start();
    while (true) {
        if (!futureTask.isDone()) {
            System.out.println("callable task is done!");
            System.out.println(futureTask.get());
            break;
        }
    }
    System.out.println("main thread over");
}

public static void testRunnable() throws ExecutionException, InterruptedException {
    Runnable runnable = () -> {
        System.out.println("Runnable started");
        try {
            Thread.sleep(3000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Runnable over");
    };
    FutureTask<String> futureTask = new FutureTask<>(runnable, "runnable result");
    new Thread(futureTask).start();
    while (true) {
        if (!futureTask.isDone()) {
            System.out.println("Runnable task is done!");
            System.out.println(futureTask.get());
            break;
        }
    }
    System.out.println("main thread over");
}

static class DelegatedExecutorService extends AbstractExecutorService {
    private final ExecutorService e;
    DelegatedExecutorService(ExecutorService executor) { e = executor; }
    public void execute(Runnable command) { e.execute(command); }
    public void shutdown() { e.shutdown(); }
    public List<Runnable> shutdownNow() { return e.shutdownNow(); }
    public boolean isShutdown() { return e.isShutdown(); }
    public boolean isTerminated() { return e.isTerminated(); }
    public boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException {
        return e.awaitTermination(timeout, unit);
    }
    public Future<?> submit(Runnable task) {
        return e.submit(task);
    }
    public <T> Future<T> submit(Callable<T> task) {
        return e.submit(task);
    }
    public <T> Future<T> submit(Runnable task, T result) {
        return e.submit(task, result);
    }
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException {
        return e.invokeAll(tasks);
    }
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                            long timeout, TimeUnit unit)
        throws InterruptedException {
        return e.invokeAll(tasks, timeout, unit);
    }
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException {
        return e.invokeAny(tasks);
    }
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                            long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
        return e.invokeAny(tasks, timeout, unit);
    }
}

public static void main(String[] args) throws ClassNotFoundException {
    while (true) {
        byte[] dd = new byte[1024 * 1024 * 10];
        AtomicBoolean atomicBoolean = new AtomicBoolean(true) {
            @Override
            protected void finalize() throws Throwable {
                System.out.println("java.util.concurrent.atomic.AtomicBoolean#finalize");
                super.finalize();
            }
        };

        Class<?> finalizable = Class.forName("java.util.concurrent.Executors.FinalizableDelegatedExecutorService");

        ExecutorService single = Executors.newSingleThreadExecutor();

        int i = 0;
        while (i++ <= 10) {
            single.submit(() -> {});
        }
        single = null;
        System.gc();
//            Thread.sleep(1000);
    }
}

public static void main(String[] args) {
    int j = 0;
    while (true) {
        System.out.println(j++);
        byte[] dd = new byte[1024 * 1024 * 10];
        AtomicBoolean atomicBoolean = new AtomicBoolean(true) {
            @Override
            protected void finalize() throws Throwable {
                System.out.println("java.util.concurrent.atomic.AtomicBoolean#finalize");
                super.finalize();
            }
        };
        ThreadPoolExecutor threadPoolExecutor =
                new ThreadPoolExecutor(50, 100, 1000L, TimeUnit.MICROSECONDS, new ArrayBlockingQueue<>(1000)) {
                    @Override
                    protected void finalize() {
                        System.out.println("java.util.concurrent.ThreadPoolExecutor.finalize");
                        super.finalize();
                    }
                };
        int i = 0;
        while (i++ <= 10) {
            threadPoolExecutor.submit(() -> {});
        }
//            Thread.sleep(1000);
//            threadPoolExecutor.shutdown();
        System.gc();
    }
}