八锁问题详解

“八锁”有什么含义？

很好理解，就是：有关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("打电话");
    }
}

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

答案：
(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秒，所以发短信肯定在她后面。）

打电话
(4秒后，显示)
发短信

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("打电话");
    }
}

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

答案：（先打电话，因为是两把锁，互不影响，然后发短信睡4秒）
打电话
(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("打电话");
    }
}

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

答案：（因为用的是同一个锁，类锁，谁先抢到谁先执行，所以发短信先抢到。
(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秒后，显示)
发短信
打电话

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秒后，显示)
发短信

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("打电话");
    }
}

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

答案：（因为用的都不是一个锁，一个是类锁，一个是锁的调用者。)
打电话
(4秒后，显示)
发短信

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("打电话");
    }
}