八锁就是关于锁的八个问题，只是为了深刻理解锁。

• 对象锁

• 类锁

1、标准情况下，先打印发短信还是打电话？

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

// 发短信 
// 打电话。

因为持有的是同一个对象锁

2、sendSms 延迟4秒，先打印发短信还是打电话？

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() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }
}

// 发短信 
// 打电话。

因为持有的是同一个对象锁

3、增加一个普通方法，先打印发短信还是 hello？

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.hello();
    }, "B").start();
}

class Phone {

    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");
    }
}

// hello
// 发短信

hello() 方法没有锁，不是同步方法，不受锁的影响

4、两个对象，两个同步方法，先打印发短信还是打电话？

public static void main(String[] args) {
    Phone phone1 = new Phone();
    Phone phone2 = new Phone();

    new Thread(() -> {
        phone1.sendSms();
    }, "A").start();

    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    new Thread(() -> {
        phone2.call();
    }, "B").start();
}

class Phone {

    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }
}

// 打电话
// 发短信

锁的是对象，两个锁

5、增加两个静态的同步方法，先打印发短信还是打电话？

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 {

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

// 发短信
// 打电话

锁的是 class 对象，Phone 这个 Class 类对象是唯一的

6、两个对象，两个静态的同步方法，先打印发短信还是打电话？

public static void main(String[] args) {
    Phone phone1 = new Phone();
    Phone phone2 = new Phone();

    new Thread(() -> {
        phone1.sendSms();
    }, "A").start();

    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    new Thread(() -> {
        phone2.call();
    }, "B").start();
}

class Phone {

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

// 发短信
// 打电话

锁的是 class，Phone 这个 Class 类对象是唯一的

7、一个静态的同步方法，一个普通的同步方法，一个对象，先打印发短信还是打电话？

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 {

    // 静态的同步方法，锁的是 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("打电话");
    }
}

// 打电话
// 发短信

静态的同步方法锁的是类，普通的同步方法锁的是类对象。不是同一个锁

8、一个静态的同步方法，一个普通的同步方法，二个对象，先打印发短信还是打电话？

public static void main(String[] args) {
    Phone phone1 = new Phone();
    Phone phone2 = new Phone();

    new Thread(() -> {
        phone1.sendSms();
    }, "A").start();

    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    new Thread(() -> {
        phone2.call();
    }, "B").start();
}

class Phone {

    // 静态的同步方法
    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 唯一的一个模板