JUC-08-java中的锁

文章目录

01、乐观锁和悲观锁
- 悲观锁：
- 乐观锁：
- 小结
02、公平锁和非公平锁
- 公平锁
- 非公平锁：
- 小结
03、可重入锁
- 概述
- synchronized关键字
- - 演示可重入锁
  - 不需要手动释放锁
- ReentrantLock
- - 演示可重入锁
- ReentrantLock需要手动释放锁
04、自旋锁
05、死锁
- 如何排查死锁
- 如何解开死锁
06、独占锁和共享锁
- 独享锁
- 共享锁
07、互斥锁和读写锁

01、乐观锁和悲观锁

悲观锁：

当线程去操作数据的时候，总认为别的线程会去修改数据，所以它每次拿数据的时候总会上锁，别的线程去拿数据的时候就会阻塞，比如synchronized

乐观锁：

每次去拿数据的时候都认为别人不会修改，更新数据的时候会判断是别人是否回去更新数据，通过版本来判断，如果数据被修改了就拒绝更新，比如CAS是乐观锁，但严格来说并不是锁，通过原子性来保证数据的同步，比如说数据库的乐观锁，通过版本控制来实现，CAS不会保证线程同步，乐观的认为在数据更新期间没有其他线程影响
注意：拿数据的时候不判断，更新数据的时候才会判断。

小结

悲观锁适合写操作多的场景
乐观锁适合读操作多的场景
乐观锁的吞吐量会比悲观锁大

02、公平锁和非公平锁

公平锁

指多个线程按照申请锁的顺序来获取锁
公平锁：非常公平，不能够插队，必须先来后到！

非公平锁：

获取锁的方式是随机获取的，保证不了每个线程都能拿到锁，也就是存在有线程饿死，一直拿不到锁，比如synchronized、ReentrantLock
非公平锁：非常不公平，可以插队（默认都是非公平锁）

小结

非公平锁性能高于公平锁，更能重复利用CPU的时间
参考可重入锁（ReentrantLock）的两个构造：一个可以传参，一个不可以传参，默认是非公平锁

public ReentrantLock() {//非公平锁：默认的sync = new NonfairSync();
}public ReentrantLock(boolean fair) {//true为公平锁，false为非公平锁sync = fair ? new FairSync() : new NonfairSync();
}

03、可重入锁

概述

什么是可重入

可重入就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁

可重入锁有

synchronized
ReentrantLock

synchronized关键字和ReentrantLock的区别：

synchronized不需要手动释放锁，而ReentrantLock需要手动释放锁

synchronized关键字

演示可重入锁

public class SynchronizedReentrantLock {public static void main(String[] args) {new Thread(new Runnable() {@Overridepublic void run() {synchronized (this){System.out.println("第1次获取锁，这个锁是："+this);int index=1;while (true){synchronized (this){System.out.println("第"+(++index)+"次获取锁，这个锁是："+this);}//重复获取十次锁if(index==10){break;}}}}}).start();}
}

运行结果：可以重复的获取同一把锁，不出现死锁

第1次获取锁，这个锁是：com.aismall.somelocks.reentrantlock.SynchronizedReentrantLock$1@2f5aff2b
第2次获取锁，这个锁是：com.aismall.somelocks.reentrantlock.SynchronizedReentrantLock$1@2f5aff2b
第3次获取锁，这个锁是：com.aismall.somelocks.reentrantlock.SynchronizedReentrantLock$1@2f5aff2b
第4次获取锁，这个锁是：com.aismall.somelocks.reentrantlock.SynchronizedReentrantLock$1@2f5aff2b
第5次获取锁，这个锁是：com.aismall.somelocks.reentrantlock.SynchronizedReentrantLock$1@2f5aff2b
第6次获取锁，这个锁是：com.aismall.somelocks.reentrantlock.SynchronizedReentrantLock$1@2f5aff2b
第7次获取锁，这个锁是：com.aismall.somelocks.reentrantlock.SynchronizedReentrantLock$1@2f5aff2b
第8次获取锁，这个锁是：com.aismall.somelocks.reentrantlock.SynchronizedReentrantLock$1@2f5aff2b
第9次获取锁，这个锁是：com.aismall.somelocks.reentrantlock.SynchronizedReentrantLock$1@2f5aff2b
第10次获取锁，这个锁是：com.aismall.somelocks.reentrantlock.SynchronizedReentrantLock$1@2f5aff2b

不需要手动释放锁

对于线程Thread_A：调用sendMsg方法的时候拿到一把锁，然后会自动拿到里面的call()方法的锁
等两个方法都执行完就释放锁，Thread_B拿到锁继续执行，不用手动释放锁

public class synchronizedLock {public static void main(String[] args) {Phone phone=new Phone();new Thread(()->{phone.sendMSG();},"Thread_A").start();new Thread(()->{phone.sendMSG();},"Thread_B").start();}
}class Phone{public  synchronized void sendMSG(){//这里有锁System.out.println(Thread.currentThread().getName()+" :sendMSG.....");call();//这里也有锁}public  synchronized void call(){System.out.println(Thread.currentThread().getName()+" :call.....");}
}

运行结果

Thread_A :sendMSG.....
Thread_A :call.....
Thread_B :sendMSG.....
Thread_B :call.....

ReentrantLock

演示可重入锁

//加了多少次，解了多少次
public class ReentrantLockDemo {public static void main(String[] args) {//创建一个可重入锁ReentrantLock lock=new ReentrantLock();new Thread(new Runnable() {@Overridepublic void run() {try {//加锁lock.lock();System.out.println("第1次获取锁，这个锁是：" + lock);int index = 1;while (true) {try {//加锁lock.lock();System.out.println("第" + (++index) + "次获取锁，这个锁是：" + lock);if (index == 10) {break;}} finally {//解锁System.out.println("第" + (index) + "次解锁，这个锁是：" + lock);lock.unlock();}}} finally {//解锁lock.unlock();System.out.println("第1"  + "次解锁，这个锁是：" + lock);}}}).start();}
}

运行结果：加了多少次，解了多少次

第1次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第2次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第2次解锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第3次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第3次解锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第4次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第4次解锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第5次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第5次解锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第6次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第6次解锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第7次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第7次解锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第8次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第8次解锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第9次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第9次解锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第10次获取锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第10次解锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Locked by thread Thread-0]
第1次解锁，这个锁是：java.util.concurrent.locks.ReentrantLock@749c37a6[Unlocked]

ReentrantLock需要手动释放锁

注意：拿锁和解锁的顺序相反，最后哪的最先解锁

Thread_A先拿到锁A，有拿到锁B，然后拿到锁C，如果这个三个锁有一个不解锁，Thread_B都不能执行，因为Thread_A拿锁和解锁的数量不一样，造成死锁。

public class ReentrantLockDemo  {public static void main(String[] args) {Phone02 phone02=new Phone02();new Thread(()->{phone02.sendMSG();},"Thread_A").start();new Thread(()->{phone02.sendMSG();},"Thread_B").start();}
}
class Phone02{Lock lock= new ReentrantLock();public void sendMSG(){// 细节问题：lock.lock(); lock.unlock()必须配对，否则就会死在里面lock.lock(); //锁Alock.lock();//锁Btry {System.out.println(Thread.currentThread().getName() + " sendMSG");call(); // 调用：锁C} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();//解锁Block.unlock();//解锁A}}public void call(){lock.lock();//锁Ctry {System.out.println(Thread.currentThread().getName() + "  call");} catch (Exception e) {e.printStackTrace();} finally {lock.unlock();//解锁C}}
}

运行结果

Thread_A sendMSG
Thread_A  call
Thread_B sendMSG
Thread_B  call

04、自旋锁

自旋锁里面使用了CAS，java自带的元子类包中的很多类都是用CAS来实现自旋锁，例如java.util.concurrent.atomic. AtomicReference类中的很多方法都利用CAS实现了自旋锁

例如这个方法：getAndUpdate

public final V getAndUpdate(UnaryOperator<V> updateFunction) {V prev, next;do {// 获取当前值，如果使用AtomicReference的空参构造，类型为传入的泛型，值为null，//使用AtomicReference的有参构造，类型为传入的泛型，值为形参值。prev = get();// 根据我们重写的apply方法获取到一个新的值next = updateFunction.apply(prev);//调用compareAndSet方法，如果我们获取的prev值不等于构造的时候传入的值//也就是在执行完构造方法之后，我们使用set方法更改了这个值，判断就会失败，//就会进入循环体，不对值进行更新，返回原始值，直到这个值为构造时传入的值才会替换//这就是自旋，一直等待，直到结果为true。} while (!compareAndSet(prev, next));return prev;}

分析

- 这个方法的参数是一个UnaryOperator<V>类型的参数，如果不说一下这个参数什么意思，估计这段代码是看不懂的。- UnaryOperator<V>是一个函数式接口，这个接口继承自Function<T, R>接口，UnaryOperator意思是一元运算符
- 因为Function<T, R>接口是传入T类型的参数，返回R类型的值，如果传入的参数类型和返回的值类型相同，
- 就可以简化使用UnaryOperator<V>这个一元运算符接口。- Function<T, R>接口源码如下：我们只关注   R apply(T t);这个抽象方法@FunctionalInterfacepublic interface Function<T, R> {/*** Function接口中的抽象方法：传入一个T类型的参数，结果返回一个R类型的值*/R apply(T t);default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {Objects.requireNonNull(before);return (V v) -> apply(before.apply(v));}default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {Objects.requireNonNull(after);return (T t) -> after.apply(apply(t));}static <T> Function<T, T> identity() {return t -> t;}}-  UnaryOperator<V>接口源码如下：没什么好看的，我们可以看到Function<T, T>，也就是我们传入什么
- 类型的值，就返回什么类型的参数，我们使用这个接口要从写父类的抽象方法。@FunctionalInterfacepublic interface UnaryOperator<T> extends Function<T, T> {static <T> UnaryOperator<T> identity() {return t -> t;}}- 举例：
UnaryOperator<Integer> uop = x -> x + 1;
System.out.println(uop.apply(10)); // 11

我们也可以利用java自带的原子类来手动写一个自旋锁：

public class MySpinLock {//使用 AtomicReference类，使用的是空参构造，所以初始化值为Thread类型的null值AtomicReference<Thread> atomicReference = new AtomicReference<>();// 加锁public void myLock(){Thread thread = Thread.currentThread();// 自旋锁：/*** 解析：因为创建atomicReference实例使用的是空参构造*      当创建对象的时候，默认为Thread类型的null*      第一个线程进来，利用空参构造创建一个对象，得到默认值null*      此时判断成立，将其替换为thread对象的地址，返回true，所以第一个*      进来的线程不会进入while循环*      第二个线程进来以后，由于默认值被替换为thread的地址不是null，所以进入while循环*      并且一直等待，直到第一个线程调用解锁方法，把这个thread的值替换为null，第二个线程才能执行*        */while (!atomicReference.compareAndSet(null,thread)){System.out.println(Thread.currentThread().getName() + "==> 拿不到锁");}}// 加锁public void myUnLock(){Thread thread = Thread.currentThread();System.out.println(Thread.currentThread().getName() + "==> 解锁");atomicReference.compareAndSet(thread,null);}public static void main(String[] args) {//创建一个锁MySpinLock lock=new MySpinLock();Thread thread01=new Thread(new Runnable() {@Overridepublic void run() {//加锁lock.myLock();System.out.println("thread01==> 拿到锁");try {//让线程睡1毫秒，看看线程thread02能不能拿到锁Thread.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}//解锁lock.myUnLock();}},"thread01");Thread thread02=new Thread(new Runnable() {@Overridepublic void run() {//加锁lock.myLock();System.out.println("thread01==> 拿到锁");//解锁lock.myUnLock();}},"thread02");thread01.start();thread02.start();}
}

运行结果

thread01==> 拿到锁
thread02==> 拿不到锁
thread02==> 拿不到锁
thread02==> 拿不到锁
thread01==> 解锁
thread02==> 拿不到锁
thread01==> 拿到锁
thread02==> 解锁

05、死锁

死锁就是：

A线程拿着A锁，想要B锁，等待获取B锁
B线程拿着B锁，想要A锁，等待获取A锁
两个线程相互等待，造成死锁

举个例子吧：

public class DeadLock {public static void main(String[] args) {String lockA="lockA";String lockB="lockB";//注意这个两个实例拿锁的顺序。。。。。MyDeadLockThread A=new MyDeadLockThread(lockA,lockB);MyDeadLockThread B=new MyDeadLockThread(lockB,lockA);new Thread(A).start();new Thread(B).start();}
}class MyDeadLockThread implements Runnable{private String lockA;private String lockB;public MyDeadLockThread(String lockA, String lockB) {this.lockA = lockA;this.lockB = lockB;}@Overridepublic void run() {synchronized (lockA){System.out.println(Thread.currentThread().getName() + "：拿到"+lockA+"=>想得到"+lockB);try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}synchronized (lockB){System.out.println(Thread.currentThread().getName() + "：拿到"+lockB+"=>想得到"+lockA);}}}
}

运行结果

Thread-0：拿到lockA=>想得到lockB
Thread-1：拿到lockB=>想得到lockA

如何排查死锁

先使用命令：jps -l查看到当前java进程的进程号

再使用命令：jstack 进程号查看当前线程的堆栈信息

如何解开死锁

方法：避免死锁产生的条件就可以了

得到这个答案的时候让我们想起了当初学红黑树的时，有人问怎么构建一个红黑树，只要满足红黑树的条件就是红黑树，为什么那，因为专家就是这样定义红黑树的，，，，

有些答案深入追究是没有意义的！！！！！

06、独占锁和共享锁

独享锁

是指锁一次只能被一个线程持有。
也叫X锁/排它锁/写锁/独享锁：该锁每一次只能被一个线程所持有，加锁后任何线程试图再次加锁的线程会被阻塞，直到当前线程解锁。例子：如果线程A 对 data1 加上排他锁后，则其他线程不能再对 data1 加任何类型的锁，获得独享锁的线程即能读数据又能修改数据！

共享锁

是指锁一次可以被多个线程持有。
也叫S锁/读锁，能查看数据，但无法修改和删除数据的一种锁，加锁后其它用户可以并发读取、查询数据，但不能修改，增加，删除数据，该锁可被多个线程所持有，用于资源数据共享！
ReentrantLock和synchronized都是独享锁，ReadWriteLock的读锁是共享锁，写锁是独享锁。

07、互斥锁和读写锁

与独享锁和共享锁的概念差不多，是独享锁和共享锁的具体实现。
ReentrantLock和synchronized都是互斥锁，ReadWriteLock是读写锁