JUC个人学习笔记3---八锁现象

根据b站UP主狂神说JUC课程所写的个人学习笔记

视频地址：https://www.bilibili.com/video/BV1B7411L7tE?from=search&seid=14761503393031794075

---

 

//关于锁的8个问题
//1.标准情况下，两个线程先打印 发短信 还是打电话？
//2.发短信延迟4s 两个线程先打印 发短信还是打电话

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

}

---

//3.增加了一个普通方法是先执行发短信还是hello
//4.两个对象，两个同步方法
public class Test2 {
    public static void main(String[] args) {
        //两个调用者，两把锁
        Phone2 phone2 = new Phone2();
        Phone2 phone1 = 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("打电话");
    }

    public void hello(){
        System.out.println("hello");
    }

}

---

//5.增加两个静态的同步方法，只有一个对象，是发短信还是打电话
//6.2个对象两个同步方法
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();
    }
}
//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("打电话");
    }


}

---

//7.一个静态，一个普通,两个对象
//8.一个静态，一个普通，一个对象

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();
    }
}
//phone3只有唯一的一个class对象
class Phone4{
    // synchronized 锁的对象是方法的调用者
    //static是静态方法，锁的是class
    //两个方法用的是同一个锁，谁先拿到谁执行
    //静态同步方法
    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("打电话");
    }


}

---

小结

new this 具体的一个手机

static class 唯一的模板