八锁现象（八锁就是关于锁的八个问题）

锁（只会锁两个东西=》(对象（普通同步方法），class模板（静态同步方法）)）

package com.ji.lock8;

import java.util.concurrent.TimeUnit;

/*
 * 八锁就是关于锁的八个问题
 * 1. 标准情况下，两个线程先打印 发短信还是打电话（并不是先调用就先执行，是因为有锁的存在）
 *   * synchronized 锁的对象是方法的调用者
 * 两个方法用的是同一个锁，谁先拿到谁执行
 * 2. 标准情况下，两个线程先打印 发短信还是hello
 *   * hello方法没有锁，不是同步方法不受锁的影响
 * 3. 标准情况下，两个对象各自一个线程运行，先打印 发短信还是打电话
 *  * synchronized 锁的对象是方法的调用者（有两个调用者两把锁）
 * 4. 增加两个静态的同步方法，先打印 发短信还是打电话
 *  * static静态类，只要类一加载就有了！锁的是Class模板（Phone3.class（一个类只有一个class对象）全局唯一）
 * 5. 两个对象，增加两个静态的同步方法，先打印 发短信还是打电话
 *  * 还是先打印发短信，因为无论多少个对象都只有一个class模板（两个对象，只有一个class类模板）
 * 6. 一个普通的同步方法，一个静态的同步方法 一个对象 先打印 发短信还是打电话
 *  * 锁的东西不是一个普通的同步方法锁的是调用者，静态的同步方法锁的是类模板
 * 7. 一个普通的同步方法，一个静态的同步方法 两个对象 先打印 发短信还是打电话*/

public class test4 {
    public static void main(String[] args) throws InterruptedException {
        //两个对象，只有一个class类模板
        Phone4 phone44=new Phone4();
        new Thread(()->{
            try {
                phone44.sendSms();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone44.call();
        },"B").start();
    }
}
class Phone4{
    //synchronized 锁的对象是方法的调用者
    //两个方法用的是同一个锁，谁先拿到谁执行
    //static静态类，只要类一加载就有了！锁的是Class模板（Phone3.class（一个类只有一个class对象）全局唯一）
    public static synchronized void sendSms() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
    //hello方法没有锁，不是同步方法不受锁的影响
    public void hello(){
        System.out.println("hello");
    }
}

小结

• new（普通的同步方法 锁的是对象） this对象
• static（静态的同步方法 锁的是类模板） class模板