1.前两个问题

package com.kuang.lock8;import java.util.concurrent.TimeUnit;/*** 8锁 ，就是关于锁的8个问题* 1、标准情况下，两个线程先打印  发短信还是打电话？ 1/发短信 2/打电话* 2、sendSms 延迟4秒，两个线程先打印  发短信还是 打电话 ？ 1/发短信 2/打电话*/
public class Test1 {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{//synchronized 锁的对象是方法的调用者！  phone//两个方法用的是同一个锁，谁先拿到谁执行!public synchronized void  sendSms(){try {TimeUnit.SECONDS.sleep(4);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("sendSms");}public synchronized void call(){System.out.println("call");}}

2.3-4问题

package com.kuang.lock8;import java.util.concurrent.TimeUnit;/*** 8锁 ，就是关于锁的8个问题** 3.增加了一个普通方法！ 发短信还是Hello？   是hello.* 4. 两个对象，两个同步方法！ 发短信还是打电话？   是打电话*/
public class Test2 {public static void main(String[] args) {//两个对象 ，两个调用者 ，两把锁！Phone2 phone1 = new Phone2();Phone2 phone2 = new Phone2();//锁的存在，才导致，它先执行。面试的适合，不能说是因为他先被调用，而是它先抢到了锁，所以它先打印！new Thread(()->{phone1.sendSms();},"A").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(()->{phone2.hello();},"B").start();}}
class Phone2{//synchronized 锁的对象是方法的调用者！  phone//两个方法用的是同一个锁，谁先拿到谁执行!public synchronized void  sendSms(){try {TimeUnit.SECONDS.sleep(4);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("sendSms");}public synchronized void call(){System.out.println("call");}//这里没有锁！不是同步方法，不受锁的影响!public void hello(){System.out.println("hello");}}

3.5-6

package com.kuang.lock8;import java.util.concurrent.TimeUnit;/*** 8锁 ，就是关于锁的8个问题** 5.增加两个静态同步方法,只有一个对象,先打印，发短信？打电话？ 打印发短信！！因为锁的都是同一个class对象* 6.增加两个对象,两个静态的同步方法,先打印，发短信？打电话？ 打印发短信！！  因为锁的都是同一个class对象，与对象本身无关*/
public class Test3 {public static void main(String[] args) {//两个对象的class 类模板只有一个，static，锁的是classPhone3 phone1 = new Phone3();Phone3 phone2 = new Phone3();//锁的存在，才导致，它先执行。面试的适合，不能说是因为他先被调用，而是它先抢到了锁，所以它先打印！new Thread(()->{phone1.sendSms();},"A").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(()->{phone2.call();},"B").start();}}
//Phone3唯一的一个Class对象
class Phone3{//synchronized 锁的对象是方法的调用者！  phone//两个方法用的是同一个锁，谁先拿到谁执行!//static  静态方法//类一加载就有了！锁的Class 锁的是模板public static synchronized void  sendSms(){try {TimeUnit.SECONDS.sleep(4);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("sendSms");}public static synchronized void call(){System.out.println("call");}}

4.第7个问题

package com.kuang.lock8;import java.util.concurrent.TimeUnit;/*** 8锁 ，就是关于锁的8个问题** 7. 1个静态的同步方法，1个普通的同步方法，1个对象 ，先打印发短信？还是打电话？ 打电话，因为锁的不是同一个东西，而打电话的睡眠时间少，所以打电话先打印**/
public class Test4 {public static void main(String[] args) {//两个对象的class 类模板只有一个，static，锁的是classPhone4 phone = new Phone4();//锁的存在，才导致，它先执行。面试的适合，不能说是因为他先被调用，而是它先抢到了锁，所以它先打印！new Thread(()->{phone.sendSms();},"A").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(()->{phone.call();},"B").start();}}
//Phone3唯一的一个Class对象
class Phone4{//静态的同步方法public static synchronized void  sendSms(){try {TimeUnit.SECONDS.sleep(4);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("sendSms");}//普通的同步方法public synchronized void call(){System.out.println("call");}}

5.8-9个问题

package com.kuang.lock8;import java.util.concurrent.TimeUnit;/*** 8锁 ，就是关于锁的8个问题** 8. 1个静态的同步方法，1个普通的同步方法，2个对象 ，先打印发短信？还是打电话？ 打电话，因为锁的不是同一个东西，而打电话的睡眠时间少，所以打电话先打印* 9. 如何让静态方法与 普通方法实现同步，用 synchronized 在普通方法里 锁住 字节码对象，就可以实现同步  然后就是发短信先打印了**/
public class Test5 {public static void main(String[] args) {//两个对象的class 类模板只有一个，static，锁的是classPhone5 phone1 = new Phone5();Phone5 phone2 = new Phone5();//锁的存在，才导致，它先执行。面试的时候，不能说是因为他先被调用，而是它先抢到了锁，所以它先打印！new Thread(()->{phone1.sendSms();},"A").start();try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}new Thread(()->{phone2.call();},"B").start();}}
//Phone3唯一的一个Class对象
class Phone5{//静态的同步方法public static synchronized void  sendSms(){try {TimeUnit.SECONDS.sleep(4);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("sendSms");}//普通的同步方法public  void call(){synchronized(Phone5.class){System.out.println("call");}}}