1、锁的概述
锁，是对权限的控制。在生活中，有门锁，电子锁；数据库中有数据库行锁、表锁；Java中也有对应的锁。
java中锁的实现方式有两种，一种是jvm底层提供的关键字synchronized,一种是jdk提供的api定义了锁接口Lock，可以通过实现Lock接口来实现自定义锁。
2、Java锁的使用场景
在Java编程中，为了对CPU的充分利用，需要并发的执行程序功能就会对共享制资源的访问，如果多个线程对同一个资源的访问，由于原子性问题，就可能出现数据错乱，导致数据异常。这个时候就需要使用锁来对这些共享资源的管理。
3、Java中的锁的实现
java中锁的实现方式有两种，一种是jvm底层提供的关键字synchronized,一种是jdk提供的api定义了锁接口Lock，可以通过实现Lock接口来实现自定义锁。
4、synchronized的使用和原理
4.1、 基本使用
Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍可以访问该object中的非加锁代码块。
/**
* 代码块加锁
*/
public void test1(){
//这里的this代表是调用这个方法的对象，锁住对象
synchronized (this){
num ++;
}
//锁住类
synchronized (SynchronizedTest.class){
num ++;
}
}
/**
* 方法加锁
* 锁对象
*/
public synchronized void test2(){
//这里的this代表是调用这个方法的对象，锁住对象
num ++;
}
/**
* 方法加锁
* 锁类
*/
public static synchronized void test3(){
num ++;
}
4.1、 原理探究
1）synchronized是怎么实现对对象的锁定？对java代码进行反编译：
对synchronized进行反编译查看C语言的代码，看到代码块是被monitorenter和monitorexit包围着，简单的理解就是程序执行过程中，栈帧执行进入sychronozed的代码块，就会执行monitorenter方法，对锁住的对象的一个变量添加标记和记住线程地址，执行完代码块，就会执行monitorexit，去除标记。
2）monitorenter和monitorexit是怎么操作对象的？对象的标记是什么？对象是怎么存储信息的？
堆里面的对象分为两部分，对象头和对象的具体信息。对象头包括Mark Work，指向类的指针，数组长度（只有数组对象才有），锁相关的信息在Mark Work中.
对象头的相关信息
Mark Word在32位JVM中的长度是32bit，在64位JVM中长度是64bit。Mark Word在不同的锁状态下存储的内容不同，在32位JVM中是这么存的：
| 锁状态 | 25bit | age(4bit) | 是否偏向锁biased_lock(1bit) | 锁标志位lock(2bit) |
|---|---|---|---|---|
| 无锁 | 对象的HashCode | 分代年龄 | 0 | 01 |
| 偏向锁 | 线程ID,Epoch | 分代年龄 | 1 | 01 |
| 轻量级锁 | 指向栈中锁记录的指针 | 00 | ||
| 重量级锁 | 指向重量级锁monitor的指针 | 10 | ||
| GC标记 | 空 | 11 | ||
| JVM一般是这样使用锁和Mark Word的： |
1，当没有被当成锁时，这就是一个普通的对象，Mark Word记录对象的HashCode，锁标志位是01，是否偏向锁那一位是0。
2，当对象被当做同步锁并有一个线程A抢到了锁时，锁标志位还是01，但是否偏向锁那一位改成1，前25bit记录抢到锁的线程id，表示进入偏向锁状态。
3，当线程A再次试图来获得锁时，JVM发现同步锁对象的标志位是01，是否偏向锁是1，也就是偏向状态，Mark Word中记录的线程id就是线程A自己的id，表示线程A已经获得了这个偏向锁，可以执行同步锁的代码。
4，当线程B试图获得这个锁时，JVM发现同步锁处于偏向状态，但是Mark Word中的线程id记录的不是B，那么线程B会先用CAS操作试图获得锁，这里的获得锁操作是有可能成功的，因为线程A一般不会自动释放偏向锁。如果抢锁成功，就把Mark Word里的线程id改为线程B的id，代表线程B获得了这个偏向锁，可以执行同步锁代码。如果抢锁失败，则继续执行步骤5。
5，偏向锁状态抢锁失败，代表当前锁有一定的竞争，偏向锁将升级为轻量级锁。JVM会在当前线程的线程栈中开辟一块单独的空间,复制对象的HashCode
到线程栈中进行CAS操作，里面保存指向对象锁Mark Word的指针，同时在对象锁Mark Word中保存指向这片空间的指针。上述两个保存操作都是CAS操作，如果保存成功，代表线程抢到了同步锁，就把Mark Word中的锁标志位改成00，可以执行同步锁代码。如果保存失败，表示抢锁失败，竞争太激烈，继续执行步骤6。如果上述复制hashCode失败,代表其他线程已经抢到锁,直接升级成重量锁.
6，轻量级锁抢锁失败，JVM会使用自旋锁，自旋锁不是一个锁状态，只是代表不断的重试，尝试抢锁。从JDK1.7开始，自旋锁默认启用，自旋次数由JVM决定。如果抢锁成功则执行同步锁代码，如果失败则继续执行步骤7。
7，自旋锁重试之后如果抢锁依然失败，同步锁会升级至重量级锁，锁标志位改为10。在这个状态下，未抢到锁的线程都会被阻塞。
如上图所示,当锁升级成重量锁,对象会指向重量级锁地址monitor,monitor包括entryList,owner,WaitSet.
owner:指向该重量锁被占用的线程地址;
entryList:锁池,线程获取锁,如果该锁是重量级锁,该线程到entryList里面进行等待,线程变为阻塞状态.
waitSet:对象调用wait方法,调用方法所在的线程会进入等待池,调用对象的notify/notifyAll,等待池里面的对象会进入锁池,上面反编译的代码monitorEnter就是操作该内存空间.
注意:锁只有升级没有降级,升级升重量锁有两种情况,自旋次数达到JVM规定或者是没有复制到hashCode,没法进行CAS操作.
5、Lock的使用
JDK提供Lock接口的两个常用实现类ReentrantLock和ReentrantReadWriteLock两种可重入锁,两种锁都是基于AbstractQueuedSynchronizer(AQS)实现的.具体可以了解下另一篇博客。
https://mp.csdn.net/mdeditor/102422402#
1)ReentrantLock:可重入锁,相同线程可以多次获取锁,只有该线程全部释放锁,其他线程才能获取锁,使用AQS里面的独占锁.
2)ReentrantReadWriteLock:可重入锁,相同线程可以多次获取锁,只有该线程全部释放锁,其他线程才能获取锁,使用AQS里面的独占锁和共享锁.
3)如图所示:AQS中有几个重要的概念,包括owner,waiters,state
owner:占用共享锁的线程相关地址;
waiters:锁池;
count:记录锁占用的数量;
state:同步状态;
获取锁的大概逻辑:
共享锁:没有线程获取独占锁,线程就可以获取对应的共享锁.
独占锁:没有其他线程获取共享锁和独占锁,就可以获取独占锁
线程通信
在synchronized中，能够根据wait/notify进行线程通信，Lock接口也提供了类似的通信方式，需要实现Condition的相关方法。
具体方法对比如下
- condition/Object 调用对象
- await() /wait() 使当前线程等待，释放对应锁，进入等待池
- signal() /notify 唤醒等待池中一个线程
- signalAll() /notifyAll 唤醒等待池中所有线程
两者的差异：synchronized的等待池只有一个，跟锁对应的对象相关联，Lock的等待池可以有多个，跟lock创建的condition数量有关,代码示例如下：
/*
put时，若队列未满，直接put，
若队列满，就阻塞，直到再有空间
get时，若队列中有元素，则获取到元素
若无元素，则等待元素
*/
class Queue{
List<Object> list = new ArrayList<>();
Lock lock = new ReentrantLock();
Condition putCondition = lock.newCondition();
Condition takeCondition = lock.newCondition();
private int length;
public Queue(int length){
this.length = length;
}
public void put(Object obj){
lock.lock();
try {
if (list.size() < length){
list.add(obj);
System.out.println("put:" + obj);
takeCondition.signal();
}else{
putCondition.await();
}
}catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
public Object take(){
lock.lock();
Object obj = null;
try {
for (;;) {
if (list.size() > 0) {
obj = list.get(0);
list.remove(0);
System.out.println("take：" + obj);
putCondition.signal();
break;
} else {
takeCondition.await();
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
return obj;
}
在上面代码中，使用列表构造一个阻塞的生产者消费者队列，使用了两个等待池实现线程之间的通信。
6、锁的其他概念
公平锁/非公平锁
可重入锁
独享锁/共享锁
互斥锁/读写锁
乐观锁/悲观锁
分段锁
偏向锁/轻量级锁/重量级锁
自旋锁
锁的其他概念可以阅读这篇博客
https://www.cnblogs.com/doit8791/p/7776501.html
