问题

1、标准访问，两线程中间睡眠 2 毫秒，先打印邮件还是短信？

class Phone {
    public synchronized void sendEmail() {
        System.out.println("send email");
    }
    public synchronized void sendSms() {
        System.out.println("send sms");
    }
}

public class Lock01 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> phone.sendEmail(), "A").start();
        Thread.sleep(200);
        new Thread(() -> phone.sendSms(), "B").start();
    }
}

2、在 sendEmail() 方法中睡眠 4 秒，先打印邮件还是短信？

class Phone {
    public synchronized void sendEmail() {
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("send email");
    }
    public synchronized void sendSms() {
        System.out.println("send sms");
    }
}

public class Lock02 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> phone.sendEmail(), "A").start();
        Thread.sleep(200);
        new Thread(() -> phone.sendSms(), "B").start();
    }
}

3、添加普通的 hello() 方法，先打印邮件还是 hello？

class Phone {
    public synchronized void sendEmail() {
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("send email");
    }
    public void hello() {
        System.out.println("hello");
    }
}
public class Lock03 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> phone.sendEmail(), "A").start();
        Thread.sleep(200);
        new Thread(() -> phone.hello(), "B").start();
    }
}

4、2 个手机，先打印邮件还是短信？

class Phone {
    public synchronized void sendEmail() {
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("send email");
    }

    public synchronized void sendSms() {
        System.out.println("send sms");
    }
}

public class Lock04 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> phone1.sendEmail(), "A").start();
        Thread.sleep(200);
        new Thread(() -> phone2.sendSms(), "B").start();
    }
}

5、2个静态同步方法，1部手机，先打印邮件还是短信？

class Phone {
    public static synchronized void sendEmail() {
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("send email");
    }

    public static synchronized void sendSms() {
        System.out.println("send sms");
    }
}

public class Lock05 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> phone.sendEmail(), "A").start();
        Thread.sleep(200);
        new Thread(() -> phone.sendSms(), "B").start();
    }
}

**6、2个静态同步方法，2部手机，先打印邮件还是短信？**

class Phone {
    public static synchronized void sendEmail() {
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("send email");
    }

    public static synchronized void sendSms() {
        System.out.println("send sms");
    }
}

public class Lock06 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> phone1.sendEmail(), "A").start();
        Thread.sleep(200);
        new Thread(() -> phone2.sendSms(), "B").start();
    }
}

**7、1个静态同步方法，1个普通同步方法，1部手机，先打印邮件还是短信？**

class Phone {
    public static synchronized void sendEmail() {
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("send email");
    }

    public synchronized void sendSms() {
        System.out.println("send sms");
    }
}

public class Lock07 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> phone.sendEmail(), "A").start();
        Thread.sleep(200);
        new Thread(() -> phone.sendSms(), "B").start();
    }
}

8、1个静态同步方法，1个普通同步方法，2部手机，先打印邮件还是短信？

class Phone {
    public static synchronized void sendEmail() {
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("send email");
    }

    public synchronized void sendSms() {
        System.out.println("send sms");
    }
}

public class Lock08 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> phone1.sendEmail(), "A").start();
        Thread.sleep(200);
        new Thread(() -> phone2.sendSms(), "B").start();
    }
}

分析

🎨 问题一

当一个对象里有多个同步（synchronized）方法，有一个线程访问了其中一个同步方法，其它线程只能等待其访问完成后才能访问，因为此时锁的是当前对象 this，其它的线程都不能进入到当前对象的其它的同步方法。

如果没有添加 Thread.sleep(200); 则打印的顺序是不一定的，因为线程的调度和操作系统有关。添加 Thread.sleep(200); 则保证了线程 A 比 B 先执行。

🎨 问题二

由于线程 A 先执行，会先调用 sendEmail() 方法，Phone 实例就会被锁住，线程 B 只能等待 A 执行完在执行。

🎨 问题三

hello() 方法并不是同步方法，因此不受锁的影响。

🎨 问题四

现在有两个实例，前面我们说过，synchronized 锁的是 this，所以会产生两把锁，它们之间互不干扰，谁先执行完谁就先打印。

🎨 问题五、问题六

synchronized 实现同步的基础：Java 中的每一个对象都可以作为锁，具体表现为以下三种形式：

对于普通同步方法，锁的是当前实例对象 this
对于静态同步方法，锁的是当前类的 Class 对象
对于同步方法块，锁是Synchonized括号里配置的对象

所以，无论是 1 个对象还是 2 个对象，静态同步方法锁的都是 Class，只能按照线程执行的顺序打印。

🎨 问题七、问题八

这两种情况都是 1 个静态同步方法，1 个非静态同步方法，它们的锁都不是同一个对象，因此相互不受影响

总结

1、当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。

2、Java 中的每一个对象都可以作为锁；普通同步方法锁 this，静态同步方法锁 Class，同步方法块锁括号；

3、只要锁的对象不是同一个，就直接按照线程执行的快慢来决定；锁的对象是同一个，就按照线程进入的先后顺序决定。

只要掌握了锁的对象是什么，无论是 8 锁还是 100 锁都不在话下！

外观模式详解

多线程之8锁问题

问题

分析

总结