JUC_8锁问题

悠悠 2023-09-27 10:32 144阅读 0赞

## 8锁问题示例与探究（问题后附讲解） ##

#### “八锁”的含义：就是八个关于锁的问题 ####

### 问题一：标准情况下，两个线程先打印发短信 还是打电话？ ###

public class Demo1 {
        
        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{
        
        //synchronized 锁的对象是方法的调用者！
        //两个方法用的是同一个锁，谁先拿到谁执行！
        public synchronized void sendSms(){
        
            System.out.println("发短信");
        }
        public synchronized void call(){
        
            System.out.println("打电话");
        }
    }

#### 答案：1、发短信 2、打电话 ####

这个问题的本质是给 phone 这个对象加了 synchronized 锁 两个方法用的是同一个对象锁，A先执行，拿到了锁，只有A执行完，A解锁了（synchronized是自动释放锁），B才能拿到锁，从而去操作phone这个对象

### 问题二：sendSms延迟4秒，两个线程先打印 发短信 还是打电话？ ###

public class Demo1 {
        
        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{
        
        //synchronized 锁的对象是方法的调用者！
        //两个方法用的是同一个锁，谁先拿到谁执行！
        public synchronized void sendSms(){
        
            try {
        
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
        public synchronized void call(){
        
            System.out.println("打电话");
        }
    }

#### 答案：（4秒后，显示结果）1、发短信 2、打电话 ####

和问题一一样，同样是A拿到了锁，只有等A执行完，释放了锁（synchronized是自动释放锁），B才能拿到锁，从而操作hone对象

### 问题三：一个同步方法，一个普通方法， 先执行发短信 还是打电话？ ###

public class Demo2 {
        
        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.call();
    
            }, "B").start();
    
    
        }
    }
    class Phone2 {
        
        //synchronized 锁的对象是方法的调用者！
        //两个方法用的是同一个锁，谁先拿到谁执行！
        public synchronized void sendSms() {
        
            try {
        
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
     //这里没有锁！不是同步方法，不受锁的影响！
        public void call() {
        
            System.out.println("打电话");
        }
    }

#### 答案：1、打电话 （4秒后，显示） 2、发短信 ####

先执行普通方法（不是同步方法，不受锁的影响），因为他不是同步方法不受锁的影响，并且发短信睡眠了4秒，所以发短信肯定在她后面。

### 问题四：两个对象，两个同步方法，先执行发短信 还是打电话？ ###

public class Demo2 {
        
        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 {
        
        //synchronized 锁的对象是方法的调用者！
        //两个方法用的是同一个锁，谁先拿到谁执行！
        public synchronized void sendSms() {
        
            try {
        
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
    
        public synchronized void call() {
        
            System.out.println("打电话");
        }
    }

#### 答案：1、打电话（4秒后，显示）2、发短信 ####

他们锁的是不同的两个对象，所以互不受影响，由于发短信睡了4秒中，使用发短信在打电话后面

### 问题五：增加两个静态的同步方法，只有一个对象，先打印发短信还是打电话？ ###

public class Demo3 {
        
        public static void main(String[] args) {
        
            //两个对象的Class类模板只有一个，static ,锁的是Class
            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();
        }
    }
    
    //Phone3 唯一的一个Class 对象
    class Phone3 {
        
        //synchronized 锁的对象是方法的调用者！
        //static 静态方法
        //类只要加载就有了！ Class 模板
        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("打电话");
        }
    }

#### 答案：（4秒后，显示）1、发短信 2、打电话 ####

因为静态代码块实在类加载的时候就有了，他锁的是类（Class，类锁）用的是同一个锁，谁先抢到谁先执行，所以发短信先抢到。

### 问题六：增加两个静态的同步方法，两个对象，先打印发短信还是打电话？ ###

public class Demo3 {
        
        public static void main(String[] args) {
        
            //两个对象的Class类模板只有一个，static ,锁的是Class
            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();
        }
    }
    //Phone3 唯一的一个Class 对象
    class Phone3 {
        
        //synchronized 锁的对象是方法的调用者！
        //static 静态方法
        //类只要加载就有了！ Class 模板
        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("打电话");
        }
    }

#### 答案：（4秒后，显示）1、发短信 2、打电话 ####

类锁锁的是class类，全局唯一，所以谁先抢到锁，谁先执行

### 问题七：一个静态的同步方法，一个普通的同步方法，一个对象；先打印发短信还是打电话呢？ ###

public class Demo4 {
        
        public static void main(String[] args) {
        
            //两个对象的Class类模板只有一个，static ,锁的是Class
            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();
        }
    }
    
    //Phone3 唯一的一个Class 对象
    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("打电话");
        }
    }

#### 答案：1、打电话（4秒后，显示）2、发短信 ####

因为用的都不是一个锁，一个是类锁，一个是锁的调用者（对象）。所以对象锁与类锁，是两把锁

### 问题八：一个静态的同步方法，一个普通的同步方法，两个对象；先打印发短信还是打电话呢？ ###

public class Demo4 {
        
        public static void main(String[] args) {
        
            //两个对象的Class类模板只有一个，static ,锁的是Class
            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();
        }
    }
    
    //Phone3 唯一的一个Class 对象
    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("打电话");
        }
    }

#### 答案：1、打电话（4秒后，显示）2、发短信 ####

因为用的都不是一个锁，一个是类锁，一个是锁的调用者（对象）。所以对象锁与类锁，是两把锁