锁是什么？如何判断锁？

• 关于锁的8个问题

/*
    1、标准情况下，两个线程先打印 发短信还是 打电话？  1/发短信  2/打电话
    2、sendSms延迟4秒，两个线程先打印 发短信还是 打电话？ 1/发短信  2/打电话
    // synchronized 锁的对象是方法的调用者！
    // 两个方法用的是同一个锁，谁先拿到谁执行！
 */
public class Test02 {
    public static void main(String[] args) throws Exception {
        phone phone = new phone();
        new Thread(() -> {
            try {
                phone.sendSms();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "A").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(() -> {
            phone.call();
        }, "B").start();
    }
}
class phone {
    // synchronized 锁的对象是方法的调用者！
    // 两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("发信息");
    }

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

/*
    3、 增加了一个普通方法后！先执行发短信还是关机？ --> 先执行普通方法
    4、 两个对象，两个同步方法， 发短信还是 打电话？ --> 打电话
 */
public class Test02 {
    public static void main(String[] args) throws Exception {
        //两个不同的对象 两把锁
        phone phone = new phone();
        phone phone1 = new phone();
        new Thread(() -> {
            try {
                phone.sendSms();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "A").start();

        TimeUnit.SECONDS.sleep(1);

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

class phone {
    // synchronized 锁的对象是方法的调用者！
    // 两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("发信息");
    }

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

    //这里没有锁 ，不是同步方法，不受锁的影响
    public void shitDown() {
        System.out.println("关机");
    }
}

/*
    5、 增加了两个静态方法后！先执行发短信还是打电话？ --> 先发短信
    6.  两个对象增加了两个静态方法后！先执行发短信还是打电话？ --> 先发短信
 */
public class Test02 {
    public static void main(String[] args) throws Exception {
        //static 类一加载就有了  所以锁定的是class
        //两个不同的对象 两把锁
        phone phone = new phone();
        phone phone1 = new phone();
        new Thread(() -> {
            try {
                phone.sendSms();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "A").start();

        TimeUnit.SECONDS.sleep(1);

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

class phone {
    // synchronized 锁的对象是方法的调用者！
    // 两个方法用的是同一个锁，谁先拿到谁执行！
    //static方法在类一加载就有了  所以锁定的是class
    public static synchronized void sendSms() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("发信息");
    }

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

/*
    7、 1个静态方法、1个普通同步方法，1个对象！先执行发短信还是打电话？ --> 先打电话
    8.  1个静态方法、1个普通同步方法，2个对象！先执行发短信还是打电话？ --> 先打电话
 */
public class Test02 {
    public static void main(String[] args) throws Exception {
        //static 类一加载就有了  所以锁定的是class
        //两个不同的对象 两把锁
        phone phone = new phone();
        phone phone1 = new phone();
        new Thread(() -> {
            try {
                phone.sendSms();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "A").start();

        TimeUnit.SECONDS.sleep(1);

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

class phone {
    // synchronized 锁的对象是方法的调用者！
    // 两个方法用的是同一个锁，谁先拿到谁执行！
    //static方法在类一加载就有了  所以锁定的是class
    public static synchronized void sendSms() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("发信息");
    }
    //普通同步方法
    public synchronized void call() {
        System.out.println("打电话");
    }
}

synchronized 方法和普通方法，普通方法无需等待锁的释放
synchronized 锁的是方法，一个对象同一个资源中按代码先后顺序执行
synchronized 锁的是方法，两个对象同一个资源中代码无需等待锁的释放
synchronized 锁加static静态方法，锁的是class类，同一个资源中按照代码先后顺序执行