Lock体系

AQS：int类型变量+同步队列

同步队列：带有头尾指针的双向链表，Node节点连接

节点状态：lockInterrupt响应中断

独占锁的获取

获取锁失败后调用AQS提供的acquire(int arg)模板方法

流程：acquire(int arg)->tryAcquire(int arg)尝试再次获取同步状态，成功方法退出，

失败调用addWaiter方法

addWaiter(Node.EXCLUSIVE,arg)将当前线以指定模式（独占式，共享式）程封装为Node节点后置入同步队列

private Node addWaiter(Node mode) {
        Node node = new Node(mode);

        for (;;) {
            Node oldTail = tail;
            if (oldTail != null) {
                node.setPrevRelaxed(oldTail);
                if (compareAndSetTail(oldTail, node)) {
                    oldTail.next = node;
                    return node;
                }
            } else {
                initializeSyncQueue();
            }
        }
    }

enq(Node node)当前队列为空或者CAS尾插失败调用，此方法用来初始化队列或者不断尾插

final boolean acquireQueued(final Node node, int arg) {
    boolean interrupted = false;
    try {
        //自旋
        for (;;) {
            final Node p = node.predecessor();
            //获取同步状态成功条件，if前驱节点为头结点并且获取状态成功，拿到锁
            if (p == head && tryAcquire(arg)) {
                //当前节点设为头结点
                setHead(node);
                //删除原来头结点
                p.next = null; // help GC
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node))
                interrupted |= parkAndCheckInterrupt();
        }
    } catch (Throwable t) {
        cancelAcquire(node);
        if (interrupted)
            selfInterrupt();
        throw t;
    }
}

acquireQueued方法获取锁成功，当前节点为头结点并且再次获取同步状态

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //获取前驱节点状态0初始，1取消，-2处于等待队列
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)//-1等待状态
        /*
         * 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.
         */
        //前驱节点状态不是取消状态，将前驱节点的状态置为-1，表示后继节点应该处于等待状态
        pred.compareAndSetWaitStatus(ws, Node.SIGNAL);
    }
    return false;
}

节点在同步队列获取锁

节点在同步队列获取锁失败调用shouldPackAfterFaildAcquire（Node pre，Node node）

此方法主要使用CAS将前驱节点状态置为SIGNAL，表示需要将当前节点阻塞

CAS失败将不断自旋，直到将前驱节点状态置为SIGNAL为止

acquireQueue()

1如果当前前驱节点为头结点并且成功获取同步状态，当前线程获取锁成功，方法调用当前线程

2如果获取失败，先不断自旋将前驱节点状态置为SIGNAL，然后调用LockSupport.park()将当前线程阻塞

独占锁的释放:release()

unlock()犯法实际调用AQS的release()模板方法 ，首先获取头结点的后继节点，当后继节点不为null，调用LockSupport.unpark()方法唤醒包装的线程

@ReservedStackAccess
protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

独占锁获取与释放总结：

1线程获取失败，将线程调用addWaiter封装成Node进行入队操作

独占特性：

获取锁时响应中断

死锁

产生原因：对并发资源的的加锁成环

线程池（JUC）

线程池优点 ：1.降低资源消耗通过重复利用以及创建的线程降低创建与销毁带来的损耗

​ 2.提供相应速度，新任务到达，任务不需要等待线程创建就能执行

​ 3.提供线程的管理性，使用线程池可以统一进行线程分配调度和监控

线程池执行流程：

1判断是否核心线程池是否已经满了，没满的话，如果有空闲线程就把任务交给他，如果没有创建

如果满了执行下一步

2判断工作队列是否已满，如果满了进入步骤三如果没满江任务交给工作

手工创建线程池

通过创建ThreadPool手工创建线程池

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

1.corePoolSize核心池的大小，当提交任务到线程池，线程池会创建一个新的线程池来执行任务

即使核心池有其他空闲线程，也会创建新线程，直到线程数达到核心池的大小

2.maximumPoolSize核心线程池最大容量如果队列已满并且已创建的线程数小于此参数，线程池再回创建新的参数执行任务，否则调用饱和策略，如果采用无界队列，此参数无意义

prestartAllCoreThreads()//线程池会提前创建启动所有核心线程

3.workQueue用于保存等待执行任务的阻塞队列

可以选择以下几个阻塞队列

1ArrayBlockingQueue：基于数组的有界队列，此队列安装FIFO对元素进行排序

2LinkedBlockingQueue基于链表，安装FIFO吞吐量高于ArraryBlockingQueue，

Executors内置固定大小newFixedThreadPool()采用此队列

3synchronousQueue一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量比LinkedBlockingQueue还高

Executors.newCachedThreadPool()采用此队列，无界队列

4PriorityBlockingQueue：具有优先级的无界队列

4.keepAliveTime线程保存活动时间，若任务很多，每个任务执行时间很短，可以跳大此参数来提高利用率

5TimeUnit（4的时间单位）

6.饱和策略RejectedExecutionHandler handler当队列和线程池都满了说明线程池处于饱和状态，此时采用饱和策略来处理任务，

a默认采用AbortPolicy，表示无法处理新任务无法抛出异常，JDK默认采用此次略

CallerRunsPolicy等待调用者线程空闲运行任务

DiscardOldestPolicy丢弃阻塞队列最近的任务并且执行当前任务

RejectedExecutionHandler不处理，将新任务丢弃，不报错

FutureTask类执行任务只执行一次FutureTask的get会阻塞其他线程，直到当前Callabe线程执行完毕拿到返回值

JDK内置4大线程池

I.创建固定大小的Executors，newCachedThreadPool适用于负载较重的服务器，为了满足资源管理的需求

II.使用于很多短期任务的小程序，负载较轻的服务器

III.单线程池，保证顺序的执行各个任务，并且咋任意时间点，不会有多个线程活动的场景

定时调度池