1
标准访问，先打印邮件还是先发送短信
解释 ：这个是不能确定的，线程的调度与cpu有关，所以不能确定。但是在代码中添加了sleep().是为了让A线程一定在B线程之前执行，这只是为了更好的解释锁。
class Phone//Phone.java ---> Phone.class Class.forName() { public synchronized void sendEmail() throws Exception{ //TimeUnit.SECONDS.sleep(3);//新的写法 //Thread.sleep(4000);//暂停4秒钟 System.out.println("发邮件"); } public synchronized void sendMessage() throws Exception{ System.out.println("发短信"); } } public static void main(String[] args) { Phone phone = new Phone(); new Thread( ()->{ try { phone.sendEmail(); } catch (Exception e) { e.printStackTrace(); } },"A").start(); Thread.sleep( 100 );//这是故意让A在B前面执行 new Thread( ()->{ try { phone.sendMessage(); } catch (Exception e) { e.printStackTrace(); } },"B").start(); } 标准访问，请问先打印邮件还是短信(线程调度，不一定) 邮件 一个对象里面如果有多个synchronized方法，某一个时刻内，只要有一个线程去调用其中的一个synchronized方法了， 其他的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized方法
2
在邮件方法暂停3秒钟，请问先打印邮件还是短信 答案： 邮件
解释：锁的对象是当前对象this，被锁定后，其他的线程都不能进入到当前对象的其它synchronized方法
class Phone//Phone.java ---> Phone.class Class.forName() { public synchronized void sendEmail() throws Exception{ TimeUnit.SECONDS.sleep(3);//新的写法 //Thread.sleep(4000);//暂停4秒钟 System.out.println("发邮件"); } public synchronized void sendMessage() throws Exception{ System.out.println("发短信"); } } public static void main(String[] args) throws InterruptedException { Phone phone = new Phone(); new Thread( ()->{ try { phone.sendEmail(); } catch (Exception e) { e.printStackTrace(); } },"A").start(); Thread.sleep( 100 );//这是故意让A在B前面执行 new Thread( ()->{ try { phone.sendMessage(); } catch (Exception e) { e.printStackTrace(); } },"B").start(); } //注意，在发邮件代码中，让其暂停3秒是为了验证，看其他线程能否访问当前被synchronize锁定的对象 在邮件方法暂停4秒钟，请问先打印邮件还是短信 邮件 锁的对象是当前对象this，被锁定后，其他的线程都不能进入到当前对象的其它synchronized方法
3
新增普通的sayHello方法，请问先打印邮件还是sayHello 答案：sayHello（因为先打印邮件，在里面等待了3秒。）
解释：加一个普通方法和同步锁无关
public synchronized void sendEmail() throws Exception{ TimeUnit.SECONDS.sleep(3);//新的写法 //Thread.sleep(4000);//暂停4秒钟 System.out.println("发邮件"); } public synchronized void sendMessage() throws Exception{ System.out.println("发短信"); } public synchronized void sayHello() throws Exception{ System.out.println("Hello"); } public static void main(String[] args) throws InterruptedException { Phone phone = new Phone(); new Thread( ()->{ try { phone.sendEmail(); } catch (Exception e) { e.printStackTrace(); } },"A").start(); Thread.sleep( 100 );//这是故意让A在B前面执行 new Thread( ()->{ try { phone.sayHello(); } catch (Exception e) { e.printStackTrace(); } },"B").start(); }
4
两部手机，请问先打印邮件还是短信 答案：短信。（只是因为打印邮件等待了3秒）
解释：换成两个对象后，不是同一把锁了，情况立刻变化
class Phone//Phone.java ---> Phone.class Class.forName() { public synchronized void sendEmail() throws Exception{ TimeUnit.SECONDS.sleep(3);//新的写法 //Thread.sleep(4000);//暂停4秒钟 System.out.println("发邮件"); } public synchronized void sendMessage() throws Exception{ System.out.println("发短信"); } } public static void main(String[] args) throws InterruptedException { Phone phone = new Phone(); Phone phone2 = new Phone(); new Thread( ()->{ try { phone.sendEmail(); } catch (Exception e) { e.printStackTrace(); } },"A").start(); Thread.sleep( 100 );//这是故意让A在B前面执行 new Thread( ()->{ try { phone2.sendMessage(); } catch (Exception e) { e.printStackTrace(); } },"B").start(); }
5
两个静态同步方法，同一部手机，请问先打印邮件还是短信 答案 ：邮件
解释 ：
static 锁的是全局锁
//Phone.java ---> Phone.class Class.forName() static 锁的是Class（字节码文件），但是不影响实例对象，
class Phone//Phone.java ---> Phone.class Class.forName() { public static synchronized void sendEmail() throws Exception{ TimeUnit.SECONDS.sleep(3);//新的写法 //Thread.sleep(4000);//暂停3秒钟 System.out.println("发邮件"); } public static synchronized void sendMessage() throws Exception{ System.out.println("发短信"); } } public static void main(String[] args) throws InterruptedException { Phone phone = new Phone(); new Thread( ()->{ try { phone.sendEmail(); } catch (Exception e) { e.printStackTrace(); } },"A").start(); Thread.sleep( 100 );//这是故意让A在B前面执行 new Thread( ()->{ try { phone.sendMessage(); } catch (Exception e) { e.printStackTrace(); } },"B").start(); } /* * 5 两个静态同步方法，同一部手机，请问先打印邮件还是短信 邮件 * static 锁的是全局锁 * //Phone.java ---> Phone.class Class.forName() static 锁的是Class * synchronized实现同步的基础：Java中的每一个对象都可以作为锁 * 具体表现为以下3中形式。 * 对于普通不同方法，锁的是当前实例对象。 * 对于同步方法块，锁是Synchronized括号里面配置的对象this * 对于静态同步方法，锁是当前类的Class对象（模板 不管多少个对象，都是来源于这个锁 ） */
6
两个静态同步方法，两部手机看，请问先打印邮件还是短信 答案：邮件
解释：和第五点几乎一样。
因为第一步手机对象，已经锁住字节码，第二个对象必须等着。所以还是第一个手机对象先。。
class Phone//Phone.java ---> Phone.class Class.forName() { public static synchronized void sendEmail() throws Exception{ TimeUnit.SECONDS.sleep(3);//新的写法 //Thread.sleep(4000);//暂停3秒钟 System.out.println("发邮件"); } public static synchronized void sendMessage() throws Exception{ System.out.println("发短信"); } } public static void main(String[] args) throws InterruptedException { Phone phone = new Phone(); Phone phone2 = new Phone(); new Thread( ()->{ try { phone.sendEmail(); } catch (Exception e) { e.printStackTrace(); } },"A").start(); Thread.sleep( 100 );//这是故意让A在B前面执行 new Thread( ()->{ try { phone2.sendMessage(); } catch (Exception e) { e.printStackTrace(); } },"B").start(); }
7
一个静态同步方法，一个普通同步方法，同一部手机，先打印邮件还是短信(普通同步方法) 答案: 短信 当一个线程视图访问同步代码块时，它首先必须得到锁，推出或抛出异常时必须释放锁。 也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法后才能获取锁， 可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的时不同的锁，
所有的静态同步方法用的也是一把锁-类对象本身 这两把锁时两个不同的对象，所以静态同步方法与非静态同步方法之间时不会有静态条件的 但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁 还是不同的实例对象的静态同步方法之间，只要他们同一个类的实例对象
通俗的说法：
static锁的是大门（字节码文件），普通synchronize锁的是大门里面的一扇门，它的关闭不影响大门，也与大门无关（锁对象）
class Phone//Phone.java ---> Phone.class Class.forName() { public static synchronized void sendEmail() throws Exception{ TimeUnit.SECONDS.sleep(3);//新的写法 //Thread.sleep(4000);//暂停3秒钟 System.out.println("发邮件"); } public synchronized void sendMessage() throws Exception{ System.out.println("发短信"); } } public static void main(String[] args) throws InterruptedException { Phone phone = new Phone(); new Thread( ()->{ try { phone.sendEmail(); } catch (Exception e) { e.printStackTrace(); } },"A").start(); Thread.sleep( 100 );//这是故意让A在B前面执行 new Thread( ()->{ try { phone.sendMessage(); } catch (Exception e) { e.printStackTrace(); } },"B").start(); }
8
一个静态同步方法，一个普通同步方法，两部手机，请问先打印邮件还是短信 答案：短信
一个锁类对象，一个锁对象，互不影响。
public static synchronized void sendEmail() throws Exception{ TimeUnit.SECONDS.sleep(3);//新的写法 //Thread.sleep(4000);//暂停3秒钟 System.out.println("发邮件"); } public synchronized void sendMessage() throws Exception{ System.out.println("发短信"); } public static void main(String[] args) throws InterruptedException { Phone phone = new Phone(); Phone phone2 = new Phone(); new Thread( ()->{ try { phone.sendEmail(); } catch (Exception e) { e.printStackTrace(); } },"A").start(); Thread.sleep( 100 );//这是故意让A在B前面执行 new Thread( ()->{ try { phone2.sendMessage(); } catch (Exception e) { e.printStackTrace(); } },"B").start(); }
