java的锁：公平锁，非公平锁，可重入锁，自旋锁，独占锁（写锁） / 共享锁（读锁） / 互斥锁
公平锁和非公平锁
公平锁
是指多个线程按照申请锁的顺序来获取锁，类似于排队买饭，先来后到，先来先服务，就是公平的，也就是队列
非公平锁
是指多个线程获取锁的顺序，并不是按照申请锁的顺序，有可能申请的线程比先申请的线程优先获取锁，在高并发环境下，有可能造成优先级翻转，或者饥饿的线程（也就是某个线程一直得不到锁），类似于允许排队加塞。。。
如何创建
并发包中ReentrantLock的创建可以指定析构函数的boolean类型来得到公平锁或者非公平锁，默认是非公平锁
synchronized修饰的也是非公平锁
/**
* 创建一个可重入锁，true 表示公平锁，false 表示非公平锁。默认非公平锁
*/
Lock lock = new ReentrantLock(true);
两者区别
公平锁：就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列中的第一个，就占用锁，否者就会加入到等待队列中，以后安装FIFO的规则从队列中取到自己
非公平锁： 非公平锁比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁那种方式。
可重入锁（递归锁）
概念
可重入锁就是递归锁
指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取到该锁的代码，在同一线程在外层方法获取锁的时候，在进入内层方法会自动获取锁
也就是说：线程可以进入任何一个它已经拥有的锁所同步的代码块
ReentrantLock / Synchronized 就是一个典型的可重入锁
代码举例：
package com.qcby.bilbil.gc;
/**
* @author HuangHaiyang
* @date 2020/08/19
* @description: description
* @version: 1.0.0
*/
class Method{
public synchronized void method1(){
method2();
}
public synchronized void method2(){
}
}
可重入锁就是，在一个method1方法中加入一把锁，方法2也加锁了，那么他们拥有的是同一把锁。也就是说我们只需要进入method1后，那么它也能直接进入method2方法，因为他们所拥有的锁，是同一把。
作用
可重入锁的最大作用就是避免死锁。
可重入锁验证
证明Synchronized
package com.qcby.bilbil.gc;
/**
* @author HuangHaiyang
* @date 2020/08/19
* @description: description
* @version: 1.0.0
*/
class Phone{
public synchronized void sendSms(){
System.out.println(Thread.currentThread().getName()+" 在发短信");
// 在同步方法中，调用另外一个同步方法
sendEmail();
}
public synchronized void sendEmail(){
System.out.println(Thread.currentThread().getName()+" 在发邮件");
}
}
public class ReentrantDemo {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(phone::sendSms,"t1线程").start();
new Thread(phone::sendSms,"t2线程").start();
}
}
结果
t1线程 在发短信
t1线程 在发邮件
t2线程 在发短信
t2线程 在发邮件
这就说明当 t1 线程进入sendSMS的时候，拥有了一把锁，同时t2线程无法进入，直到t1线程拿着锁，执行了sendEmail 方法后，才释放锁，这样t2才能够进入。t1线程在外层方法获取锁的时候，t1在进入内层方法会自动获取锁。
证明ReentrantLock
package com.qcby.bilbil.gc;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author HuangHaiyang
* @date 2020/08/19
* @description: description
* @version: 1.0.0
*/
class Phone{
Lock lock=new ReentrantLock();
public void getLock(){
lock.lock();
try {
System.out.println(Thread.currentThread().getName()+" getLock");
setLock();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void setLock() {
lock.lock();
try {
System.out.println(Thread.currentThread().getName()+" setLock");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
public class ReentrantDemo {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(phone::getLock,"t3线程").start();
new Thread(phone::getLock,"t4线程").start();
}
}
结果
t4线程 getLock
t4线程 setLock
t3线程 getLock
t3线程 setLock
最后输出结果我们能发现，结果和加synchronized方法是一致的，都是在外层的方法获取锁之后，线程能够直接进入里层
当我们在getLock方法加两把锁会是什么情况呢？
public void getLock(){
lock.lock();
lock.lock();
try {
System.out.println(Thread.currentThread().getName()+" getLock");
setLock();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
lock.unlock();
}
}
结果不变因为里面不管有几把锁，其它他们都是同一把锁，也就是说用同一个钥匙都能够打开
当我们在getLock方法加两把锁，但是只解一把锁会出现什么情况呢？
public void getLock(){
lock.lock();
lock.lock();
try {
System.out.println(Thread.currentThread().getName()+" getLock");
setLock();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
程序直接卡死，线程不能出来，也就说明我们申请几把锁，最后需要解除几把锁
当我们只加一把锁，但是用两把锁来解锁的时候，又会出现什么情况呢？
public void getLock(){
lock.lock();
try {
System.out.println(Thread.currentThread().getName()+" getLock");
setLock();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
这个时候，运行程序会直接报错
t3线程 getLock
t3线程 setLock
t4线程 getLock
t4线程 setLock
Exception in thread "t4线程" Exception in thread "t3线程" java.lang.IllegalMonitorStateException
at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)
at com.qcby.bilbil.gc.Phone.getLock(ReentrantDemo.java:35)
at java.lang.Thread.run(Thread.java:745)
java.lang.IllegalMonitorStateException
at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:457)
at com.qcby.bilbil.gc.Phone.getLock(ReentrantDemo.java:35)
at java.lang.Thread.run(Thread.java:745)
Process finished with exit code 0
自旋锁
自旋锁：spinlock，是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU
原来提到的CAS，底层使用的就是自旋，自旋就是多次尝试，多次访问，不会阻塞的状态就是自旋。
优缺点
优点：循环比较获取直到成功为止，没有类似于wait的阻塞
缺点：当不断自旋的线程越来越多的时候，会因为执行while循环不断的消耗CPU资源
手写自旋锁
通过CAS操作完成自旋锁，A线程先进来调用myLock方法自己持有锁5秒，B随后进来发现当前有线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到
package com.qcby.bilbil.gc;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
/**
* @author HuangHaiyang
* @date 2020/08/19
* @description: description
* @version: 1.0.0
*/
public class SpinLockDemo {
AtomicReference<Thread> acquireThread = new AtomicReference<> ();
public void myLock() {
// 获取当前进来的线程
Thread thread=Thread.currentThread();
System.out.println(Thread.currentThread().getName()+" 进入");
// 开始自旋，期望值是null，更新值是当前线程，如果是null，则更新为当前线程，否者自旋
while (!acquireThread.compareAndSet(null,thread)){
}
}
public void myUnlock(){
// 获取当前进来的线程
Thread thread=Thread.currentThread();
// 自己用完了后，把atomicReference变成null
acquireThread.compareAndSet(thread, null);
System.out.println(Thread.currentThread().getName()+" 完成");
}
public static void main(String[] args) {
SpinLockDemo spinLockDemo=new SpinLockDemo();
new Thread(()->{
// 开始占有锁
spinLockDemo.myLock();
//占有5秒
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
//释放锁
spinLockDemo.myUnlock();
},"t1线程").start();
// 让main线程暂停1秒，保证t1线程先执行
try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
// 1秒后，启动t2线程，开始占用这个锁
new Thread(() -> {
// 开始占有锁
spinLockDemo.myLock();
// 开始释放锁
spinLockDemo.myUnlock();
}, "t2线程").start();
}
}
t1线程 进入
t2线程 进入
。。。。
t1线程 完成
t2线程 完成
独占锁（写锁） / 共享锁（读锁） / 互斥锁
概念
独占锁：指该锁一次只能被一个线程所持有。对ReentrantLock和Synchronized而言都是独占锁
共享锁：指该锁可以被多个线程锁持有
对ReentrantReadWriteLock其读锁是共享，其写锁是独占
写的时候只能一个人写，但是读的时候，可以多个人同时读
为什么会有写锁和读锁
原来我们使用ReentrantLock创建锁的时候，是独占锁，也就是说一次只能一个线程访问，但是有一个读写分离场景，读的时候想同时进行，因此原来独占锁的并发性就没这么好了，因为读锁并不会造成数据不一致的问题，因此可以多个人共享读。多个线程 同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行，但是如果一个线程想去写共享资源，就不应该再有其它线程可以对该资源进行读或写。
读-读：能共存
读-写：不能共存
写-写：不能共存
代码实现
package com.qcby.bilbil.gc;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* @author HuangHaiyang
* @date 2020/08/19
* @description: description
* @version: 1.0.0
*/
class MyCache{
private volatile Map<String,String> map=new HashMap<>();
private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
public void put(String key, String value) {
readWriteLock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "\t 正在写入：" + key);
try {
// 模拟网络拥堵，延迟0.3秒
TimeUnit.MILLISECONDS.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
map.put(key, value);
System.out.println(Thread.currentThread().getName() + "\t 写入完成");
} catch (Exception e) {
e.printStackTrace();
} finally {
readWriteLock.writeLock().unlock();
}
}
public void get(String key) {
readWriteLock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "\t 正在读取:");
try {
// 模拟网络拥堵，延迟0.3秒
TimeUnit.MILLISECONDS.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
String value = map.get(key);
System.out.println(Thread.currentThread().getName() + "\t 读取完成：" + value);
} catch (Exception e) {
e.printStackTrace();
} finally {
readWriteLock.readLock().unlock();
}
}
}
public class ReadWriteLockDemo {
public static void main(String[] args) {
MyCache myCache = new MyCache();
// 线程操作资源类，5个线程写
for (int i = 0; i < 5; i++) {
// lambda表达式内部必须是final
final int tempInt = i;
new Thread(() -> {
myCache.put(tempInt + "", tempInt + "");
}, String.valueOf(i)).start();
}
// 线程操作资源类， 5个线程读
for (int i = 0; i < 5; i++) {
// lambda表达式内部必须是final
final int tempInt = i;
new Thread(() -> {
myCache.get(tempInt + "");
}, String.valueOf(i)).start();
}
}
}
0 正在写入：0
0 写入完成
1 正在写入：1
1 写入完成
2 正在写入：2
2 写入完成
3 正在写入：3
3 写入完成
4 正在写入：4
4 写入完成
0 正在读取:
2 正在读取:
1 正在读取:
4 正在读取:
3 正在读取:
0 读取完成：0
3 读取完成：3
4 读取完成：4
1 读取完成：1
2 读取完成：2
Process finished with exit code 0
从运行结果我们可以看出，写入操作是一个一个线程进行执行的，并且中间不会被打断，而读操作的时候，是同时5个线程进入，然后并发读取操作