JUC-八锁现象

概念

由锁引发的8个问题

1. 同一对象，两个同步方法，哪个先行？
2. 同一对象，两个同步方法，先被调用的执行前锁住2s，哪个先行？

---

3. 一个对象，一个同步，一个普通方法，哪个先行?
4. 两个对象，分别调用两个同步方法，先被调用的执行前锁住2s，哪个先行？

---

5. 增加两个静态同步方法，哪个先行?
6. 两个对象，分别调用两个静态同步方法，哪个先行?

---

7. 一个对象，一个普通同步方法，一个静态同步方法，哪个先行？
8. 两个对象，一个普通同步方法，一个静态同步方法，哪个先行？

代码

调用区

Phone phone = new Phone();

new Thread(()->{
    phone.sendSms();
}).start();

//保证call在send之后
try{
    TimeUnit.SECONDS.sleep(1);
}catch(Exception e){
    e.printStackTrace();
}

new Thread(()->{
    phone.call();
}).start();

答案

1. 1、2

class Phone{
    //synchronized锁的是方法调用者
    //同个对象两个方法的锁是同一把，谁先拿到谁执行
    public synchronized void sendSms(){
        try{
            Thread.sleep(1000);
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println("sendSms");
    }

    public synchronized void call(){
        try{
            Thread.sleep(1000);
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println("call");
    }
}

2. 3、4

class Phone2{
    public synchronized void sendSms(){
        try{
            Thread.sleep(1000);
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println("sendSms");
    }

    public synchronized void call(){
        try{
            Thread.sleep(1000);
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println("call");
    }

    //这里没有锁
    public void hello(){
        System.out.println("hello");
    }
}

普通方法没有锁
两个对象普通方法用不同的锁

3. 5、6

//synchronized锁的是方法调用者
// static 静态方法，即锁的是Class
public static synchronized void sendSms(){
    try{
        Thread.sleep(1000);
    }catch(Exception e){
        e.printStackTrace();
    }
    System.out.println("sendSms");
}

public static synchronized void call(){
    try{
        Thread.sleep(1000);
    }catch(Exception e){
        e.printStackTrace();
    }
    System.out.println("call");
}

静态方法锁的是Class，所有静态同步方法共用一把锁

4. 7、8

//静态同步方法
public static synchronized void sendSms(){
    try{
        Thread.sleep(1000);
    }catch(Exception e){
        e.printStackTrace();
    }
    System.out.println("sendSms");
}

//普通同步方法
public synchronized void call(){
    try{
        Thread.sleep(1000);
    }catch(Exception e){
        e.printStackTrace();
    }
    System.out.println("call");
}

静态跟普通同步方法用的是不同的锁