JUC并发编程（终章）各种锁的理解

各种锁的理解

公平锁、非公平锁

公平锁：先到先得（不可插队）
非公平锁：达者为先（可插队）---------->默认

1. public ReentrantLock() {
2.     //默认非公平锁
3.     sync = new NonfairSync();
4. }

复制代码

1. //重载的构造方法，通过fair控制是否公平
2. public ReentrantLock(boolean fair) {
3.     sync = fair ? new FairSync() : new NonfairSync();
4. }

复制代码

可重入锁（递归锁）

所有的锁都是可重入锁

Synchronized版

1. package org.example.lock;
4. public class Demo01 {
5.     public static void main(String[] args) {
6.         phone1 p1 = new phone1();
7.         new Thread(()->{
8.             p1.ems();
9.         },"A").start();
10.         new Thread(()->{
11.             p1.ems();
12.         },"B").start();
13.     }
14. }
15. class phone1{
16.     public synchronized void ems(){
17.         System.out.println(Thread.currentThread().getName()+"---------->ems");
18.         call();
19.     }
20.     public synchronized void call(){
21.         System.out.println(Thread.currentThread().getName()+"---------->call");
22.     }
23. }

复制代码

ems方法中包含了call方法，所以当我们调用ems方法获取到锁时，也把call方法的synchronized锁获取到了。
错误理论

• 当线程A运行ems方法后运行call方法时ems锁释放，线程B可以获取到ems方法
  

正确理论

• 当线程A运行ems方法后运行call方法时ems方法的锁还未释放时就拿到了call方法中的锁，当call方法的锁释放后ems方法的锁才会释放。线程B此时就可以运行ems方法了
  

Lock版

1. package org.example.lock;
3. import java.util.concurrent.locks.Lock;
4. import java.util.concurrent.locks.ReentrantLock;
6. public class Demo02 {
7.     public static void main(String[] args) {
8.         phone2 p2 = new phone2();
9.         new Thread(()->{
10.             p2.ems();
11.         },"A").start();
12.         new Thread(()->{
13.             p2.ems();
14.         },"B").start();
15.     }
16. }
17. class phone2{
18.     Lock lock = new ReentrantLock();
19.     public  void ems(){
20.         lock.lock();
21.         try {
22.             System.out.println(Thread.currentThread().getName()+"---------->ems");
23.             call();
24.         } catch (Exception e) {
25.             e.printStackTrace();
26.         } finally {
27.             //等待call方法锁解锁后再解锁
28.             lock.unlock();
29.         }
31.     }
32.     public void call(){
33.         lock.lock();
34.         try {
35.             System.out.println(Thread.currentThread().getName()+"---------->call");
36.         } catch (Exception e) {
37.             e.printStackTrace();
38.         } finally {
39.             lock.unlock();
40.         }
42.     }
43. }

复制代码

自旋锁

spinlock(不断尝试直至成功)
已经见过了，就是unsafe中的自增getAndAddInt方法中的do-while循环就是一把自旋锁

自己写一把锁

1. package org.example.lock;
3. import java.util.concurrent.TimeUnit;
4. import java.util.concurrent.atomic.AtomicReference;
6. public class SpinLockDemo {
7.     //int 0
8.     //Thread null
9.     public static AtomicReference<Thread> atomic = new AtomicReference<>();
11.     public static void lock(){
12.         Thread thread = Thread.currentThread();
13.         System.out.println("===============>"+thread.getName()+"===========>lock");
14.         //自旋锁,若线程等于null，则compareAndSet为true，加！就为false，就会一直循环
15.         while (!atomic.compareAndSet(null,thread)){
17.         }
18.     }
19.     public static void unlock(){
20.         Thread thread = Thread.currentThread();
21.         System.out.println("===============>"+thread.getName()+"===========>unlock");
22.         //自旋锁
23.         atomic.compareAndSet(thread,null);
24.     }
26.     public static void main(String[] args) throws InterruptedException {
27.         new Thread(()->{
28.             try {
29.                 lock();
30.                 TimeUnit.SECONDS.sleep(10);
31.             } catch (Exception e) {
32.                 e.printStackTrace();
33.             } finally {
34.                 unlock();
35.             }
36.         },"A").start();
37.         TimeUnit.SECONDS.sleep(1);
38.         new Thread(()->{
39.             try {
40.                 lock();
41.                 TimeUnit.SECONDS.sleep(2);
42.             } catch (Exception e) {
43.                 e.printStackTrace();
44.             } finally {
45.                 unlock();
46.             }
47.         },"B").start();
48.     }
49. }

复制代码

死锁

死锁是什么

死锁测试

1. package org.example.lock;
3. import java.util.concurrent.TimeUnit;
5. public class DeadLockDemo {
6.     public static void main(String[] args) {
7.         String a = "A";
8.         String b = "B";
9.         new Thread(()->{new MyThread(a, b).run();},"A").start();
10.         new Thread(()->{new MyThread(b, a).run();},"B").start();
11.     }
12. }
13. class MyThread implements Runnable{
14.     private String lockA;
15.     private String lockB;
17.     public MyThread(String lockA, String lockB) {
18.         this.lockA = lockA;
19.         this.lockB = lockB;
20.     }
22.     @Override
23.     public void run() {
24.         synchronized (lockA){
25.             System.out.println(Thread.currentThread().getName()+"lock:"+lockA+"=>get"+lockB);
26.             try {
27.                 TimeUnit.SECONDS.sleep(2);
28.             } catch (InterruptedException e) {
29.                 throw new RuntimeException(e);
30.             }
31.             synchronized (lockB){
32.                 System.out.println(Thread.currentThread().getName()+"lock:"+lockB+"=>get"+lockA);
33.             }
34.         }
35.     }
36. }

复制代码

程序突然卡住死锁如何排查？

1、使用jps-l定位进程号

查看当前java活着的进程
2、使用jstack 进程号查看死锁问题


查找到一个死锁问题！
面试或者工作中排查问题：
1、查看异常
2、查看日志
3、查看堆栈信息

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！