【并发编程篇】详细讲解八种锁现象，彻底理解锁

你的名字 2024-04-17 06:38 16阅读 0赞

#### 文章目录 ####

*  ?1.标准情况下，两个线程先打印，先发短信还是先打电话
 *  ?2.我们加上延时，看看有什么效果
 *  ?3.我们创建一个新方法，新方法没有使用synchronized
 *  ?4.两个对象的情况
 *  ?5.一个对象，两个静态同步方法
 *  ?6.两个对象，两个静态同步方法
 *  ?7.一个对象，1个静态同步方法，1个普通同步方法
 *  ?8.两个对象，1个静态同步方法，1个普通同步方法

![在这里插入图片描述][dd26086292b54cf0921d8975b14627ca.png]

在并发编程中，锁现象通常指的是多线程情况下可能出现的一些特定问题或现象。以下是八种常见的并发编程中的锁现象：

## ?1.标准情况下，两个线程先打印，先发短信还是先打电话 ##

package org.example.lock8;
    
    import java.util.concurrent.TimeUnit;
    
    public class Test1 {
        
        public static void main(String[] args) {
        
            Phone phone = new Phone();
            new Thread(()->{
        
                phone.sendSms();
            },"A").start();
    
            try {
        
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
    
            new Thread(()->{
        
                phone.call();
            },"B").start();
        }
    }
    
    class Phone{
        
        public synchronized void sendSms() {
        
            System.out.println("发短信");
        }
        public synchronized void call() {
        
            System.out.println("打电话");
        }
    }

![在这里插入图片描述][0ab5fa1ebd354825b7b479041c541873.png]

> `结果`  
> 发短信  
> 打电话

## ?2.我们加上延时，看看有什么效果 ##

![在这里插入图片描述][3ad47c57dc034940aa1689b65ef6364e.png]  
这种情况，等待4秒后，先输出发短信，后输出打电话，而不是先输出打电话

为什么是先发短信，而不是先打电话呢  
原因是因为先调用发短信的方法吗。不对，原因是因为synchronized锁的对象是方法的调用者(发短信和打电话这两个方法，都使用了synchronized)，而且这两个方法都被phone所调用，由于`这两个方法使用的是同一把锁，所以谁先拿到锁，谁先执行`

## ?3.我们创建一个新方法，新方法没有使用synchronized ##

看看先打印什么出来

package org.example.lock8;
    
    import java.util.concurrent.TimeUnit;
    
    public class Test2 {
        
        public static void main(String[] args) {
        
            Phone2 phone = new Phone2();
    
            new Thread(()->{
        
                phone.sendSms();
            },"A").start();
    
            try {
        
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
    
            new Thread(()->{
        
                phone.hello();
            },"B").start();
        }
    }
    
    class Phone2{
        
        public synchronized void sendSms() {
        
            System.out.println("发短信");
        }
        public synchronized void call() {
        
            System.out.println("打电话");
        }
    
        public void hello() {
        
            System.out.println("hello");
        }
    }

![在这里插入图片描述][b28e7c9627954ece9ca0113d57eb167c.png]

> `结果`  
> hello  
> 发短信

因为这种情况下hello方法 没有加锁，不是同步方法，不受锁的影响

## ?4.两个对象的情况 ##

package org.example.lock8;
    
    
    import java.util.concurrent.TimeUnit;
    
    public class Test2 {
        
        public static void main(String[] args) {
        
            Phone2 phone1 = new Phone2();
            Phone2 phone2 = new Phone2();
    
            new Thread(()->{
        
                phone1.sendSms();
            },"A").start();
    
            try {
        
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
    
            new Thread(()->{
        
                phone2.call();
            },"B").start();
        }
    }
    
    class Phone2{
        
        public synchronized void sendSms() {
        
            try {
        
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
        public synchronized void call() {
        
            System.out.println("打电话");
        }
    }

![在这里插入图片描述][7507ff1d25c5466b92ced0811f386947.png]

> `结果`  
> 打电话  
> 发短信

原因：现在有两个对象，两个调用者，即有两把锁，由于发短信方法 延迟了4秒钟(TimeUnit.SECONDS.sleep(4)?，所以phone2先拿到锁，所以先执行 打电话

## ?5.一个对象，两个静态同步方法 ##

其实就是在方法上加上static，变为静态方法

package org.example.lock8;
    
    import java.util.concurrent.TimeUnit;
    
    public class Test3 {
        
        public static void main(String[] args) {
        
            Phone3 phone = new Phone3();
    
    
            new Thread(()->{
        
                phone.sendSms();
            },"A").start();
    
            try {
        
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
    
            new Thread(()->{
        
                phone.call();
            },"B").start();
        }
    }
    
    class Phone3{
        
        public static synchronized void sendSms() {
        
            try {
        
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
        public static synchronized void call() {
        
            System.out.println("打电话");
        }
    }

![在这里插入图片描述][7a387059f8fb402685998076b145cef2.png]

> `结果`  
> 发短信  
> 打电话

为什么是先发短息，这个static有什么影响吗  
static是静态方法，类一加载就有了，那么锁的是class，是一个模板，发短信和打电话这两个方法的本质都是phone3，phone3只有唯一的class对象，这个class全局唯一，`这两个方法都被static修饰了，所以这两个方法使用的是同一个锁`

## ?6.两个对象，两个静态同步方法 ##

package org.example.lock8;
    
    import java.util.concurrent.TimeUnit;
    
    public class Test3 {
        
        public static void main(String[] args) {
        
            Phone3 phone1 = new Phone3();
            Phone3 phone2 = new Phone3();
    
            new Thread(()->{
        
                phone1.sendSms();
            },"A").start();
    
            try {
        
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
    
            new Thread(()->{
        
                phone2.call();
            },"B").start();
        }
    }
    
    class Phone3{
        
        public static synchronized void sendSms() {
        
            try {
        
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
        public static synchronized void call() {
        
            System.out.println("打电话");
        }
    }

![在这里插入图片描述][26d92a3acfce4af982c3c9dd5d3a2cf3.png]

> `结果`  
> 发短信  
> 打电话

如果它是一个普通的synchronized方法，它是由调用者对象来操作它  
但是现在加上了static  
这个锁 锁的的class对象  
这个phone3的两个对象的class类模板只有一个，锁的是class，`这个class全局唯一，这两个方法都被static修饰了，所以这两个方法使用的是同一个锁`

## ?7.一个对象，1个静态同步方法，1个普通同步方法 ##

package org.example.lock8;
    
    
    import java.util.concurrent.TimeUnit;
    
    public class Test4 {
        
        public static void main(String[] args) {
        
            Phone4 phone = new Phone4();
    
    
            new Thread(()->{
        
                phone.sendSms();
            },"A").start();
    
            try {
        
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
    
            new Thread(()->{
        
                phone.call();
            },"B").start();
        }
    }
    
    class Phone4{
        
        public static synchronized void sendSms() {
        
            try {
        
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
        public synchronized void call() {
        
            System.out.println("打电话");
        }
    }

![在这里插入图片描述][cb8e84a79fb74f7ba310274c184dcab6.png]

> `结果`  
> 打电话  
> 发短信

原因：静态同步方法锁的是class类模板  
普通同步方法锁的是调用者  
这里有两把锁，这两个方法用的不是同一把锁，所以先执行打电话，后执行发短信，发短信要延后4秒(TimeUnit.SECONDS.sleep(4)?

## ?8.两个对象，1个静态同步方法，1个普通同步方法 ##

package org.example.lock8;
    
    
    import java.util.concurrent.TimeUnit;
    
    public class Test4 {
        
        public static void main(String[] args) {
        
            Phone4 phone1 = new Phone4();
            Phone4 phone2 = new Phone4();
    
    
            new Thread(()->{
        
                phone1.sendSms();
            },"A").start();
    
            try {
        
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
    
            new Thread(()->{
        
                phone2.call();
            },"B").start();
        }
    }
    
    class Phone4{
        
        public static synchronized void sendSms() {
        
            try {
        
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
        public synchronized void call() {
        
            System.out.println("打电话");
        }
    }

![在这里插入图片描述][56ef21bce79342329365768394246687.png]

> `结果`  
> 打电话  
> 发短信

同理，这里有2个锁，和第七个的情况一样

> 在技术的道路上，我们不断探索、不断前行，不断面对挑战、不断突破自我。科技的发展改变着世界，而我们作为技术人员，也在这个过程中书写着自己的篇章。让我们携手并进，共同努力，开创美好的未来！愿我们在科技的征途上不断奋进，创造出更加美好、更加智能的明天！

![在这里插入图片描述][c9a79814460b471bb4c97716490f6d6f.png_pic_center]

[dd26086292b54cf0921d8975b14627ca.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/15b9df2ac4a94b11ae7a97c3ce4f767c.png
[0ab5fa1ebd354825b7b479041c541873.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/f78e1aa5b3c94ee6baf1231a240b2a3a.png
[3ad47c57dc034940aa1689b65ef6364e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/52096ce95f254b5ba78edd9cf5ec3caf.png
[b28e7c9627954ece9ca0113d57eb167c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/31d6b6bee23b4bd29d1e0eee5b7df060.png
[7507ff1d25c5466b92ced0811f386947.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/fb07a0fa3e51499eb3aa9db2b63deaa2.png
[7a387059f8fb402685998076b145cef2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/7862239da70f49b4936c16bb8fed7200.png
[26d92a3acfce4af982c3c9dd5d3a2cf3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/da53b660903d489280e37380427bb8d5.png
[cb8e84a79fb74f7ba310274c184dcab6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/d3dd63d868014884847ee31f109506bb.png
[56ef21bce79342329365768394246687.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/90a1ec85adc148ddb8cc327b5851e7f9.png
[c9a79814460b471bb4c97716490f6d6f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/31a1e4ebe64e45f499ca24291e93df9d.png