首页 > 其他分享> 文章详细

2022.8.21 各种锁理解

2022-08-22 00:04:42 阅读：158 来源： 互联网

标签：lockA 21 Thread lock 理解线程 2022.8 new public

21、各种锁理解

1、公平锁和非公平锁：

公平锁:非常公平，不能够插队，必须先来后到!FIFO

非公平锁:非常不公平，可以插队（默认都是非公平)

2、可重入锁

递归锁

可重入锁synchronized 版本

 package com.xing.lock;
 
 //Synchorized
 public class Demo01 {
     public static void main(String[] args) {
         Phone phone = new Phone();
         new Thread(()->{
             phone.sms();
         },"a").start();
         new Thread(()->{
             phone.sms();
         },"b").start();
 
     }
 }
 class Phone{
     public synchronized void sms(){
         System.out.println(Thread.currentThread().getName() + "sms");
         call(); //这里也有锁(sms锁 里面的call锁)
     }
     public synchronized void call(){
         System.out.println(Thread.currentThread().getName() + "call");
     }
 }

可重入锁Lock版本（递归锁）

 package com.xing.lock;
 
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 
 public class Demo02 {
     public static void main(String[] args) {
         Phone2 phone = new Phone2();
         new Thread(()->{
             phone.sms();
         },"a").start();
         new Thread(()->{
             phone.sms();
         },"b").start();
 
     }
 }
 class Phone2{
     Lock lock = new ReentrantLock();
     public void sms(){
         lock.lock();//细节问题 第一把锁
         //lock锁必须配对否则就会死在里面
         try {
             System.out.println(Thread.currentThread().getName() + "sms");
             call(); //这里也有锁(sms锁 里面的call锁)
         } catch (Exception e) {
             e.printStackTrace();
         }finally {
             lock.unlock();
         }
 
     }
     public synchronized void call(){
         lock.lock();//第二把锁
         try {
             System.out.println(Thread.currentThread().getName() + "call");
         } catch (Exception e) {
             e.printStackTrace();
         }finally {
             lock.unlock();
         }
 
 
     }
 }

总结：两个锁只要获得外面的锁之后，就能够拿到里面的锁，Lock和synchronized 的区别在需要手动释放锁，并且枷锁的次数和释放的次数要一样

3、自旋锁( spinlock )

不断尝试直到成功为止

自己创建一个自己的锁用CAS完成

 package com.xing.lock;
 
 import java.util.concurrent.atomic.AtomicReference;
 
 //自己写的自旋锁
 public class SpinlockDemo {
     //Thread null
     AtomicReference<Thread> atomicReference = new AtomicReference();
 
     // 加锁
     public void myLock() {
         Thread thread = Thread.currentThread();
         System.out.println(Thread.currentThread().getName() + "==>mylock");
         //自旋锁
         while (!atomicReference.compareAndSet(null, thread)) {
 
         }
     }
     // 解锁
     public void myUnLock() {
         Thread thread = Thread.currentThread();
         System.out.println(Thread.currentThread().getName() + "==>myunlock");
         atomicReference.compareAndSet(thread, null);
     }
 }

然后去用线程调用

 package com.xing.lock;
 
 import java.util.concurrent.TimeUnit;
 
 public class TestSpinlock {
     public static void main(String[] args) {
         /*ReentrantLock reentrantLock = new ReentrantLock();
         reentrantLock.lock();
         reentrantLock.unlock();*/
         
         //底层的是自旋锁CAS实现的
         SpinlockDemo spinlockDemo = new SpinlockDemo();
 
         new Thread(()->{
             spinlockDemo.myLock();
             try {
                 TimeUnit.SECONDS.sleep(3);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }finally {
                 spinlockDemo.myUnLock();
             }
         },"T1").start();
 
         //T1获得锁，T2一直在自旋。T1解锁后，T2才获得锁结束自旋
         new Thread(()->{
             spinlockDemo.myLock();
             try {
                 TimeUnit.SECONDS.sleep(1);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }finally {
                 spinlockDemo.myUnLock();
             }
         },"T2").start();
 
 
     }
 }

总结：B线程这里一定会等待T1完成比较交换这个时候自旋锁里已经被A占着了（自旋锁条件：线程不为空及自转）所以B线程会一直自旋到A线程完成CAS的比较交换完成才不在进行自旋操作再进入到myunlock里完成解锁操作

优点：

自旋锁不会使线程状态发生切换，一直处于用户态，即线程一直都是active的；不会使线程进入阻塞状态，减少了不必要的上下文切换，执行速度快。

缺点：

如果某个线程持有锁的时间过长，就会导致其它等待获取锁的线程进入循环等待，消耗CPU。使用不当会造成CPU使用率极高。

上面Java实现的自旋锁不是公平的，即无法满足等待时间最长的线程优先获取锁。不公平的锁就会存在“线程饥饿”问题。

4、死锁

死锁测试，怎么排除死锁

 package com.xing.lock;
 
 import single.LazyMan;
 
 import java.util.concurrent.TimeUnit;
 
 public class DeadlockDemo {
     public static void main(String[] args) {
         String lockA = "lockA";
         String lockB = "lockB";
         // A想拿B
         new Thread(new MyThread(lockA,lockB),"T1").start();
         // B想拿A
         new Thread(new MyThread(lockB,lockA),"T2").start();
 
 
     }
 }
 class MyThread implements Runnable{
     // 两个资源
     private String lockA;
     private String lockB;
 
     public MyThread(String lockA, String lockB) {
         this.lockA = lockA;
         this.lockB = lockB;
     }
 
     @Override
     public void run() {
         synchronized (lockA){
             //lockA想拿B
             System.out.println(Thread.currentThread().getName() + "lock"+ lockA + "=> get" + lockB);
             try {
                 TimeUnit.SECONDS.sleep(3);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             synchronized (lockB){
                 //B想拿A
                 System.out.println(Thread.currentThread().getName() + "lock" + lockB + "=> get" + lockA);
             }
         }
     }
 }

死锁排查

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

例如：在终端输入jps -l

2、使用jstack 进程号找到死锁问题

例如：jstack 11444

标签：lockA,21,Thread,lock,理解,线程,2022.8,new,public
来源： https://www.cnblogs.com/shanzha/p/16611427.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。