java线程池 -- 大话笔记

• java线程池的概念
• java线程池知识点扫盲
• java线程池的模式
• java线程池源码解析

java线程池概念

我们知道，java最大的特性在于其对多线程以及并发性的友好支持，但线程的创建是和我们的cpu有关系的，持续不断的创建势必会带来更多的开销，当我们有多个请求并发而来，且访问的时间很短，这就势必会造成我们cpu的压力，而java线程池就是为了解决这个问题而产生的，利用已有的线程来处理多个任务，以减少cpu创建线程时所带来的开销

java线程池知识点扫盲

在学习java线程池首先必须掌握几个要点

1. 线程的创建以及其生命周期
2. 锁机制

对于线程的创建以及其生命周期想必肯定是知道了，而在线程池的源代码中出现了一个类需要我们先了解一下ReentrantLock，由于对多线程用的还是比较少，所以就去了解了一下,读到源代码的时候，由于ReentrantLock主要依赖于abs来实现，然后读着读着发现aqs中出现了重入锁，一脸蒙蔽，什么是重入锁呢，用下面一个例子简单说明一下。

public class ReentrantTest {
    public void method1() {
        synchronized (ReentrantTest.class) {
            System.out.println("方法1获得ReentrantTest的内置锁运行了");
            method2();
        }
    }
    public void method2() {
        synchronized (ReentrantTest.class) {
            System.out.println("方法1里面调用的方法2重入内置锁,也正常运行了");
        }
    }
    public static void main(String[] args) {
        new ReentrantTest().method1();
    }
}

由以上例子可得，只有同一线程的才有资格访问method2，而在abs中，通常用的是lock来做，举例

public class RepeatLock1 {
    boolean isLocked = false;
    Thread  lockedBy = null;
    int lockedCount = 0;
    public synchronized void lock()
        throws InterruptedException{
        Thread callingThread = Thread.currentThread();
        while(isLocked && lockedBy != callingThread){
            wait();
        }
        isLocked = true;
        lockedCount++;
        lockedBy = callingThread;
  }
    public synchronized void unlock(){
        if(Thread.currentThread() == this.lockedBy){
            lockedCount--;
            if(lockedCount == 0){
                isLocked = false;
                notify();
            }
        }
    }
}

由于ReentrantLock比较高级，他可以控制线程是否可以获取锁而不是像synchronized一样，一直处于等待状态，同时为了节省线程的开销，aqs提供了同一线程是否可以获得锁，如果已获取，那就+1，这在我们后面读源码的时候会讲到
接下来我们就来讲解一下ReentrantLock这个类

由上图我们可知，在ReentrantLock中的有两个内部类，公平锁和非公平锁，两个子类都是继承abs的，现在我们来跟一下非公平锁的实现方式吧。

 final void lock() {
            acquire(1);
        }

当我们要获取锁的时候会调用这个lock方法，lock方法里面有个acquire（1）方法，那么这个方法有什么用呢，我们不妨在看一下源代码。

public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

这里我们不妨可以做个比喻，假如现在有一个线程已经占用了锁对象，那么第二个线程请求过来的时候就要通过tryAcquire（）方法去判断是否可以获得锁，这里显然是获取不到，那么我们就会执行第二方法，将请求放到请求队列中去，我们先来看看addwaiter这个方法是如何放的。

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

这里会将当前的线程放到节点中去，然后再判断tail是否不为空，这里很显然的是tail为null，所以我们会执行enq这个方法，如下

private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

由代码我们可求得，首先会把一个空节点加入到头部，然后再将tail=head，又由于他是循环的，那么接下来就会执行到else这一步，将node的前置节点指向head，通过compareAndSetTail(t, node)将node节点放到CLH尾部，然后再将刚刚header的下一个节点指向next，如图

然后返回节点，接下来我们在来看看会执行到的代码

   final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

由上我们不难知道首先我们会获取第一个节点是不是和clh中的第一个节点是否一致，这里很显然是一致的，不过由于我们的锁还没有释放，所以会执行第二步
shouldParkAfterFailedAcquire(p, node)会将header的waitstatus由0转变为-1，然后返回true，下一步parkAndCheckInterrupt()通过这个方法将线程暂时挂起来，防止死锁。
现在假设我们的后面又多了一个线程来请求，这时的队列会是什么样呢？

 private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

这时会执行第一个if，图如下：

 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

接下来又会执行如上代码，判断waitStatus是否>0，大于0表示已经过期，需要剔除掉，再判断节点waitStatus是不是等于0，如果等于0就把他变为-1，然后返回false，重新进入循环到下一步，与之前一样，当然了，当锁释放后，线程2会得到锁，这时后header节点会被剔除，第二个节点会变成header节点，感兴趣的可以自行去看源码。

ExecutorService

下面我们就来看看线程池ExecutorService这个类，下面有一副图表明他在api中的位置

暂时写到这，我继续去扫盲