锁的分类

• 公平锁/非公平锁：
  – 公平的意思是多个线程按照申请锁的顺序来获取锁。
  – 公平锁通常会造成系统更低的吞吐量
  – 非公平锁可能会出现线程饥饿的现象
  – ReentranLock：默认是非公平锁，可以通过构造参数指定为公平锁。
  – synchronized：默认是非公平锁，并且不能变为公平锁。
• 独享锁/共享锁：
  – 独享的意思是一个锁只能被一个线程持有。
  – ReentranLock是独享锁
  – ReadWriteLocK的读锁是共享锁，写锁是独享锁。
  – synchronized是独享锁
• 互斥锁/读写锁： 独享锁和共享锁的具体实现。
• 乐观锁/悲观锁：
  – 乐观锁认为数据不一定会被修改，所以不会加锁，而是不断尝试更新。
  – 悲观锁认为数据会被修改，所以采用加锁的方式实现同步。
  – 乐观锁适合读操作多余写操作的系统。
• 分段锁：一种锁的设计，例如ConcurentHashMap就使用了分段锁。
• 偏向锁/轻量级锁/重量级锁：synchronized的三种状态
  – 偏向锁指同一段同步代码一直被一个线程访问，那么该线程就会自动获取这个锁，以降低获取锁的代价。
  – 轻量级锁：当前锁是偏向锁，并且被另一个线程访问，偏向锁会升级成轻量级锁，其他线程会通过自旋（CAS）的形式尝试获取锁。不会阻塞其他线程。
  – 重量级锁：当前锁是轻量级锁，另一个线程自旋到一定次数的时候还没获取到该锁，轻量级锁就会升级为重量级锁，会阻塞其他线程。
• 自旋锁/调度锁：
  – 自旋锁：反复参数直到满足条件。
  – 调度锁：跟系统调度机构交互，实现并发控制。
• 可重入锁：指同一线程再外层方法获取锁的时候，进入内层方法时会自动获取锁。

synchronized

synchronized是基于JVM实现的锁。

万物即可为锁

//给对象上锁----锁对象
synchronized Object obj = new Object();
//给方法上锁---锁对象
public synchronized void function(){}
//给静态方法上锁---锁class对象
public synchronized static void funciton(){}

同一个实例的两个方法都有synchronize锁，当方法1被一个线程上锁后，另一个线程能进入方法2吗？

方法上加锁，锁的是对象，静态方法上加锁，锁的是class对象，既然如此，答案肯定是不能进入。代码验证：

public class LockService {public synchronized void lock1(){System.out.println(Thread.currentThread().getName()+"进入lock1");try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"离开lock1");}public synchronized void lock2(){System.out.println(Thread.currentThread().getName()+"进入lock2");try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"离开lock2");}
}public class LockTest {public static void main(String[] args) {LockService lockService = new LockService();new Thread(lockService::lock1).start();new Thread(lockService::lock2).start();System.out.println("等待任务执行完成");}
}Thread-0进入lock1
等待任务执行完成
Thread-0离开lock1
Thread-1进入lock2
Thread-1离开lock2

疑问？ synchronized(this) {}是锁代码块？这不是锁当前对象吗？

synchronized的实现

synchronized是通过对象头的锁标志位实现对象加锁的。

1.5以前synchronized是重量级锁，悲观锁，来就会加锁。
1.6以后优化了，有了锁升级的过程。

锁升级

1.6以后被synchronized标记的对象存在一个锁升级的过程，依次是：

注意：锁升级是按无锁>偏向锁>轻量级锁>重量级锁进行升级的，并且除了偏向锁可以重置为无锁外，锁是无法降级的。

Lock

lock是一个接口，用代码来实现锁。

AQS

AQS是jdk种Lock的实现基础，AQS使用模板方法模式，提供一个框架来实现依赖于FIFO等待队列的阻塞锁和相关的同步器（信号量、事件等），底层实现是volatile修饰的state和CAS。

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {/*** 等待队列的NODE节点类，等待队列是LCH锁队列的一种变种。CLH锁通常用于自旋锁。* 相反，等待队列将它们用于阻塞同步器，但使用相同的基本策略，即在上一节点中保留有关线程的一些控制信息。* 当一个线程在等待某个资源时，它会被放入等待队列中，等待队列中的每个元素都是一个NODE对象。*      +------+  prev +-----+       +-----+* head |      | <---- |     | <---- |     |  tail*     +------+       +-----+       +-----+*/static final class Node{/** 用于指示节点正在共享模式下等待的标记 */static final Node SHARED = new Node();/** 用于指示节点正在独占模式下等待的标记 */static final Node EXCLUSIVE = null;    /*** waitStatus是AQS的重要属性，表示当前节点的状态。有五种取值：* CANCELLED（1）：表示当前结点已取消调度。当timeout或被中断（响应中断的情况下），会触发变更为此状态，进入该状态后的结点将不会再变化。* SIGNAL（-1）：表示后继结点在等待当前结点唤醒。后继结点入队时，会将前继结点的状态更新为SIGNAL。* CONDITION（-2）：表示节点在条件等待队列中，当其他线程调用了Condition的signal()方法之后，该节点就会从条件等待队列移动到同步队列中。* PROPAGATE(-3):表示当前节点需要被传播或者传递到下一个节点。*  当一个线程在获取资源时，如果当前节点不是头节点，并且前继节点的状态为SIGNAL或CONDITION，那么当前节点的状态将被更新为PROPAGATE。*  这个状态的作用是让当前节点能够将前继节点的状态传递下去，从而让下一个节点有机会获取资源。*  0：表示线程节点进入就绪状态，可以继续尝试获取锁了。*/volatile int waitStatus;//连接到前一个节点，当前节点的waitStatus检查依赖前一节点。入队时分配，出队时设为null（为了GC）	。volatile Node prev;//连接到下一节点，volatile Node next;//将此节点排入队列的线程。在构造时初始化，使用后为nullvolatile Thread thread;Node nextWaiter;}//等待队列的头和尾private transient volatile Node head;private transient volatile Node tail;/*** 同步状态，有三种状态：*  0：没有线程持有*  1：已被线程持有*  >1: 被线程多次持有* 当一个线程来尝试加锁时，会对state进行CASE操作，将state从0改为1，如果操作成功，则将线程信息设置成自己。如果操作失败，则会进入等待队列。如果线程需要释放锁时会对state进行减1，如果减1后为0，则会彻底释放锁，将加锁线程置为null，然后从等待队列唤醒下一个线程。*/private volatile int state;/*** Condition同样时一个队列，用于维护等待队列（条件队列）。Condition是基于Node实现的。* 每一个Condition都拥有一个等待队列（NODE队列），一个Lock可以有多个Condition，每一个Condition都是对应了一个单独的条件。*/public class ConditionObject implements Condition, java.io.Serializable {private transient Node firstWaiter;private transient Node lastWaiter;}
}

LockSupport

LockSupport通过许可（permit）实现线程挂起、挂起线程唤醒功能。许可可以理解为每个已启动线程维持的一个int类型状态位counter。线程分别通过执行LockSupport静态方法park()、unPark()方法来完成挂起、唤醒操作2。LockSupport通常不会被直接使用，更多是作为锁实现的基础工具类1。

CLH

CLH是Craig、Landin、Hagersten三人发明的一种基于双向链表数据结构的队列，是FIFO先入先出线程等待队列，Java中的CLH队列是原CLH队列的一个变种，线程由原自旋机制改为阻塞机制1。

CAS

CAS全称为Compare And Swap，是unsafe的一个方法。CAS机制的原理是利用CPU的CAS指令，同时借助JNI来完成Java的非阻塞算法，该操作时原子的。
CAS操作包括三个操作数：内存位置V、预期原值A和新值B。当内存位置V的值与预期原值A相匹配时，将内存位置V的值设置为新值B，并且返回true；否则，不做任何操作，并返回false。

Lock实现

上面对AQS的概念还是比较模糊，下面将从锁的具体实现来理解下AQS

ReentrantLock

//提供锁实现的同步基础，分为以下公平和非公平版本。使用AQS状态表示锁上的挂起次数。private final Sync sync;abstract static class Sync extends AbstractQueuedSynchronizer {//……final boolean nonfairTryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {if (compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);return true;}}else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;if (nextc < 0) // overflowthrow new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;}}
//非公平锁static final class NonfairSync extends Sync {/*** 立即尝试获取锁，否则以独占锁形式进入队列获取锁。*/final void lock() {if (compareAndSetState(0, 1))setExclusiveOwnerThread(Thread.currentThread());elseacquire(1);}protected final boolean tryAcquire(int acquires) {return nonfairTryAcquire(acquires);}}//公平锁static final class FairSync extends Sync {/*** 直接进入队列获取锁*/final void lock() {acquire(1);}/*** Fair version of tryAcquire.  Don't grant access unless* recursive call or no waiters or is first.*/protected final boolean tryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {if (!hasQueuedPredecessors() &&compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);return true;}}else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;if (nextc < 0)throw new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;}}public void lock() {sync.lock();}public boolean tryLock() {return sync.nonfairTryAcquire(1);}

注意看lock()方法，非公平锁和公平锁的差异就是:

• 非公平锁会在lock的时候不管三七二十一，先尝试获取锁一次，如果获取失败，则会再查看下state是不是0，如果是0，再抢一次锁。如果没抢到才会乖乖入队。
• 而公平锁则是查看state是否为0，并且是否其他线程在等待，如果没有才会尝试加锁。

lock和tryLock的区别是：

• lock：获取锁失败会阻塞。
• tryLock：获取锁失败则返回false，成功则返回true。不会阻塞。

阻塞方法acquire

	/*********AQS*****************/public final void acquire(int arg) {if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();}/***  在一个死循环里面，不断检测上一个节点的状态，直到上一个节点状态为SIGNAL则将当前线程挂起来等待唤醒或被中断*/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 GCfailed = false;return interrupted;}/***shouldParkAfterFailedAcquire只有检测到前一个节点状态为SIGNAL才会返回true，此时当前节点才能安全的挂起。*parkAndCheckInterrupt负责将当前线程挂起，并判断是否中断。如果线程未中断，则继续阻塞；如果线程中断，则抛出InterruptedException异常*/if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())interrupted = true;}} finally {if (failed)cancelAcquire(node);}}

ReadWriteLock

ReadWriteLock读写锁是一个接口，定义了两个获取锁的接口readLock和writeLock，在jdk里面其有两个实现：

ReentrantReadWriteLock

ReentrantReadWriteLock故名思意，可重入读写锁。
读写锁的读锁和写锁的关系是什么？

• 读锁之间不互斥，可多个线程同时获取；
• 读锁与写锁互斥，即写锁已经被某个线程获取时，其他线程不能获取读锁；读锁被某个线程获取时，其他线程不能获取写锁。
• 写锁之间互斥，即一次只能有一个线程获取写锁；
• 这两种锁之间会有优先级，当有等待的线程时，写锁锁住优先于读锁锁住；

锁降级是什么？

锁降级是说一个线程在拥有写锁的情况下可以不释放写锁，直接获取读锁，然后再释放写锁。这个过程就完成了锁降级。锁降级的好处是可以在写操作后直接进行读操作，避免了无谓的锁竞争和线程阻塞，提高了程序的并发性能。需要注意的是，锁降级是可逆的，即读锁可以再升级为写锁。但是锁升级的操作会导致死锁的风险，因此在使用锁降级时需要谨慎处理锁的获取和释放顺序。

StampedLock

StampedLock是JDK1.8中新增的一个读写锁，也是对JDK1.5中的读写锁ReentrantReadWriteLock的读性能的优化。
StampedLock有一个stamp变量（戳记，long类型）代表了锁的状态。当stamp返回零时，表示线程获取锁失败。并且，当释放锁或者转换锁的时候，都要传入最初获取的stamp值1。StampedLock有以下3种模式：

• 悲观读锁。与ReadWriteLock的读锁类似（这里的读锁不可重入），多个线程可以同时获取悲观读锁，悲观读锁是一个共享锁。
• 乐观读锁。相当于直接操作数据，不加任何锁，连读锁都不要。在操作数据前并没有通过CAS设置锁的状态，仅仅通过位运算测试。
• 写锁。与ReadWriteLock的写锁类似，写锁和悲观读锁是互斥的。