八锁问题

Phone 有两个方法：发送邮件和发送短信，每个方法都打印一句话，现在通过不同的方式对方法进行操作，回答出打印的先后顺序

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

class Phone1 {
    public synchronized void sendEmail() {
        System.out.println("sendEmail");
    }

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

public class Lock01 {
    public static void main(String[] args) throws InterruptedException {
        Phone1 phone1 = new Phone1();
        new Thread(phone1::sendEmail, "A").start();
        Thread.sleep(200);//没有这里的延迟就不一定了。这里基本保证线程A先执行。
        new Thread(phone1::sendSms, "B").start();
    }
}

查看答案

sendEmail

sendSms

🧐 问题一分析

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

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

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

class Phone2 {
    public synchronized void sendEmail() {

        try {
            TimeUnit.SECONDS.sleep(4);	//停4秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

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

查看答案

sendEmail

sendSms

🧐 问题二分析

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

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

class Phone3 {
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }
    public void hello() {
        System.out.println("hello");
    }
}
public class Lock03 {
    public static void main(String[] args) throws InterruptedException {
        Phone3 phone3 = new Phone3();
        new Thread(phone3::sendEmail, "A").start();
        Thread.sleep(200);
        new Thread(phone3::hello, "B").start();
    }
}

查看答案

hello

sendEmail

🧐 问题三分析

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

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

class Phone4 {
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

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

查看答案

sendSms

sendEmail

🧐 问题四分析

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

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

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

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

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

查看答案

sendEmail

sendSms

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

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

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

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

查看答案

sendEmail

sendSms

🧐 问题五、问题六分析

synchronized 实现同步的基础：Java 中的每一个对象都可以作为锁

具体表现为以下三种形式：

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

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

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

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

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

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

查看答案

sendSms

sendEmail

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

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

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

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

查看答案

sendSms

sendEmail

🧐 问题七、问题八分析

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

总结

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

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

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