java里面的锁详解

##1、为什么要用锁
      在了解为什么要用锁之前需要了解两个概念，线程安全和线程不安全，线程安全指的是多个线程对共享变量访问时的结果和单线程下顺序对共享变量访问的结果是一致的，是符合预期的；而线程不安全指的是多个线程对共享变量访问的结果每次都是不确定的。为了保证线程安全这里又几种方法，第一个不用共享变量，各自用各自的变量就不会有线程安全的问题；第二采用加锁机制，synchronized和Lock接口下的各种锁；第三就是采用JUC下面的一些并发容器，其实还是用锁实现的。所以用锁的目的就是保证线程安全。

##2、volatile关键字
      这也是个容易和锁的作用混淆的关键字，这个关键字的作用是用来保证多线程中变量的可见性和禁止指令重排序。可见性的理解：多CPU的情况下，由于CPU的处理速度远远快于内存中数据的数据的读取速度，所以为了提升效率，每个CPU都会有自己的一个缓存区域，访问数据时会先数据存储到缓存中，如果下次访问数据的地址在缓存缓存中已经有，就直接从缓存中取，写入也是一样，但是不确定什么时候会将缓存中的数据更新到内存中，所以如果一个线程在CPU1中处理了一个数据，这个数据CPU2的缓存中也有，但是由于没有及时更新，下次CPU2访问这个数据的时候直接从缓存中拿数据，就会导致数据的错误，这就没有保持数据的可见性。如果使用了volatile变量，访问时会直接从内存中读取数据而不是缓存中，而写数据时会直接将缓存中的数据写到内存，并且使其他CPU中缓存的数据无效，这样也就保证变量的可见性。但是这里保证了可见性并不是保证了原子性，所以并不能保证线程安全。要保证线程安全还是要加锁。volatile还有一个作用就是禁止指令重排序，指令重排序是编译器和CPU的行为，是为了提高代码执行的并行度而采取的措施，例如，这里又5句代码，三个乘法两个除法，并且代码直接没有数据依赖性，因为CPU的各个部件有不同的功能，如果顺序执行，五个代码，会有4个时钟周期会运行完，但是做了指令重排序后，两个除法插入到乘法指令中，三个时钟周期就运行完了。指令重排序要遵守几个规则，第一，数据依赖性的指令不能重排序，但是仅仅对单线程有约束，多线程变约束不了了**。第二是as-if-serial语义**，意思就是不管怎么重排序，单线程的语义不能被改变。但是这些约束可以看到的是都是在单线程中的限制，对于多线程是没有限制的，所以多线程中的指令重排序可能会有与预期不符的结果。例如：

线程1中：
a=1；
flag=true；
线程2中：
if（flag == true）{
	b=a；
}

这个时候因为，线程一种的两句话没有数据依赖性，所有将顺序调换，这个时候flag=true先运行，然后线程1的时间片用完，线程2运行，这个是后就是直接给b赋值了，并且值不是1，这样就出现了与预期不符合的结果。所有volatile变量的作用变体现出来了。禁止指令重排序其实是在指令之间加内存屏障实现的。

##3、synchronized锁
      介绍完了线程安全和线程不安全，这里介绍一下jdk中的对象锁synchronized，这个锁是每个对象都有的一个锁，是一个重量级锁，jdk1.6中引入了偏向锁和轻量级锁来提高效率，java的锁是存放在java对象头中的，每个对象都有自己的对象头，普通对象对象头占两个字，数组占用三个字。对象头主要有Mark Word和Class Metadata Address 组成，后者是用来保存对象类型数据的指针，核心是Mark Word，这个的结构如下：

可以看到，这里无锁状态下主要存储了对象的hashcode和分代年龄，偏向锁状态主要存储拥有锁的线程ID和分代年龄和偏向锁标志，轻量级锁和重量级锁都存储了栈中锁记录的指针。这里详细介绍下三种锁的争抢流程，偏向锁：
A线程检查对象头中标志是否是偏向锁，是否存储了线程，没有的话通过Cas操作替换为自己的线程ID，然后执行同步体，这个时候如果有B线来访问同步块，首先也是检查对象头中有不有线程，如果有，先检查这个线程还在不在，如果在的话，暂停线程，解锁，将对象头中的线程id，偏向锁标志清空，升级为轻量级锁，恢复线程。轻量级锁：A线程访问同步块，通过CAS修改Mark Word，将Mark Word中对应的位指向自己栈中的锁记录，执行同步体，如果这个时候有B线程访问，首先也是尝试CAS修改，然后发现失败，就自旋获取锁，如果还是失败，那么就将锁升级为重量级锁，然后自己进入阻塞态。从这里看出java通过以前的一个重量级锁，变成了三种锁来适应不同状态下的情况，首先偏向锁适用于一直只有一个线程持有锁的情况，这个时候的运行效率基本和不加锁是一致的，第二种情况适用于A线程占有锁（但时间很短），B线程自旋等待的代价比上下文切换的代价小的情况，最后就是我们的重量级锁，这里锁只能升级，不能降级。

##4、JUC包中的各种锁
      相比于同步锁，JUC包中提供了一个锁的框架，提供了更加灵活功能更加强大的锁，首先看框架图：

可以看到这个框架里面又Lock接口和ReadWriteLock接口和AbstractQueuedSynchronizer抽象类,LockSupport，和Conditoin。AQS是一个同步器，用来实现同步组件，锁是同步组件，意思AQS不仅能实现锁，还能实现其他类型的同步器，AQS和Lock接口的关系是，Lock接口定义了锁的实现规范，锁类通过聚合AQS来实现锁，然后通过集成Lock接口来实现锁的更多的功能。通过Lock接口和AQS实现了独占锁，共享锁，可重入锁，可重入读写锁，公平锁和非公平锁。LockSupport，和Conditoin实现了一个等待队列，类似于同步锁中的wait和notify方法。这些锁与同步锁不同的是**，首先这些是显示的释放锁和显示的获取锁，不像同步锁是隐式的，这样操作要灵活一点，然后同步锁升级为重量级锁后一旦没抢占到就要进入阻塞状态，而这些锁可以进入阻塞态，也能直接返回，最后，能够超时获取锁，和第一个差不多，如果时间过了则返回。**这里再通过一个独占锁的实现来分析一下这些锁的核心机制，核心机制是一样的，不同的是通过一些方法实现了独占、共享、读写、重入、公平和非公平。首先独占锁的的获取是通过lock方法获取的。

final void lock() {
            acquire(1);
        }
//lock又调用了acquire方法
public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }     

    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);
        }
    }
    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
        private void unparkSuccessor(Node node) {
        /*
         * If status is negative (i.e., possibly needing signal) try
         * to clear in anticipation of signalling.  It is OK if this
         * fails or if status is changed by waiting thread.
         */
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        /*
         * Thread to unpark is held in successor, which is normally
         * just the next node.  But if cancelled or apparently null,
         * traverse backwards from tail to find the actual
         * non-cancelled successor.
         */
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }    

acquire里面首先会通过tryAcquire方法来尝试获取锁，如果获取到就返回，如果没获取到再将当前线程做成一个节点，节点包含了线程的引用，线程的状态，前驱节点，和后继节点，然后将这个节点加入到同步队列中，就像同步锁中的block态一样，这些同步队列里面的线程会通过LockSupport类实现的方法进入到阻塞态。同步队列是由AQS同步器实现的，结构如下：

加入队列这里是CAS操作实现的，因为可能会有多个节点同时抢占失败同时添加，所以这里采用CAS操作实现。然后可以看到加入队列后还调用了acquireQueued方法。
在acquireQueued方法里面，我们可以看到，首先这个方法里面会判断当前节点是不是头节点的后继节点，如果是的话就不停的获取锁，如果获取到锁，证明头节点已经释放了锁，那么就将本节点设置为头结点，从这里可以看出，头结点是获取到锁的节点，如果后继节点获取锁失败，那么就会进入阻塞状态，等待头结点释放锁的时候唤醒这个节点，然后再来获取锁。这里分析释放的代码：节点释放锁的时候，会将头节点的后继节点唤醒。然后让后继节点来继续获锁，获取到锁后，后继节点成为头结点，之前的头结点出队列。这里会有个疑问，最开始的时候如果当前节点获取同步状态然后又不在同步队列中，也要唤醒头结点的后继节点而不是头结点吗？答案是是的，看添加到队列的代码：

这里可以看到如果最开始同步队列为空的情况下，这里会随意添加一个节点为头节点，所以需要被唤醒的还是头结点的后继节点。这里对同步队列做一个总结，同步队列遵循FIFO原则，正常情况下，头结点是获取到锁的节点，先进队列的节点会先获取到锁，获取不到锁的节点会被阻塞，等待头结点释放锁的时候会唤醒头结点的后继节点，头节点的出队条件是后继节点获取到锁并成为新的头结点。再总结一下获取锁的一个流程图：

这里核心机制基本完成了一大半，获取锁，释放锁，阻塞状态实现了，还有一小部分就是实现同步锁中的等待和唤醒状态。这里是通过LockSupport和Condition实现同步锁中的等待和唤醒，每个Condition对象都包含着一个队列，下面分析condition对象的实现：等待队列、等待和通知。Condition对象是AQS的内部类，每个AQS可以包含多个Condition对象，也就说明可以有多个等待队列，同步锁中只有一个等待队列。等待队列也是一个FIFO的队列，结构如下：

是一个单向链表，等待队列中的节点和同步队列中的节点是共用的，如果线程调用了Conditon.await()方法，那么就会释放锁，进入到等待队列中，成为等待状态。同步队列加入等待队列的图示：

然后通过调用Condition.signal()方法，使等待队列的头结点（FIFO）进入到同步队列的尾节点。图示：

这样就完成等待通知功能，到这里锁的核心机制便介绍完了，其他的几种锁，如公平非公平，重入不重入，独占共享核心机制一样，对这几个小功能写了特定的方法。这里着重介绍下公平非公平的含义：其实从核心机制来看，所有的线程只要进入到同步队列中，都是公平的先来先得的，**公平和非公平的真正区别在余，线程在获取公平的锁之前会判断有不有同步队列存在或者这个节点还前面还有不有节点在等待，如果有那么这个线程直接会加入到同步队列进行等待，但是非公平锁便没有检查队列这一步，直接后来就争抢锁了，**但是如果争抢失败后加入到同步队列是公平的。至此，锁的机制基本介绍完毕。