外墙保温板施工规范|苏洋建材有限公司

外墙保温板施工规范

　　* 题目：

　　* 1.标准访问，请问是先打印邮件还是短信 Email

　　* 2.email方法新增暂停4秒钟，请问是先打印邮件还是短信 Email

　　* 3.新增普通的hello方法，请问先打印邮件还是hello hello

　　* 4.两部手机，请问先打印邮件还是短信 SMS

　　* 5.两个静态同步方法，1部手机，请问先打印邮件还是短信 Email

　　* 6.两个静态同步方法，2部手机，请问先打印邮件还是短信 Email

　　* 7.一个普通同步方法，一个静态同步方法，1部手机，请问先打印邮件还是短信 SMS

　　* 8.一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信 SMS

　　*

　　* lock1、2

　　* 一个对象里面如果有多个synchronized方法，某一时刻内，只要一个线程去调用其中的一个synchronized方法，

　　* 其他的线程都只能等待，换句话说，某一时刻内，只能有唯一一个线程去访问这些synchronized方法，

　　* 锁的是当前对象的this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法

　　*

　　* lock3、4

　　* 加个普通的方法后和同步锁无关

　　* 换成两个对象后，不是同一把锁了，情况立刻变化

　　*

　　* lock5、6

　　* 都换成静态同步方法后，情况又变化（静态锁的是Class类对象）

　　* 若是普通同步方法，new this，具体的一部一部手机，所有的普通同步方法用的都是同一把锁----示例对象本身

　　* 若是静态同步方法，static class，唯一的一个模板

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

　　* 具体表现为以下3种形式。

　　* 对于普通同步方法，锁是当前实例对象。它等同于 对于同步方法块，锁是synchronized括号里的配置的对象。

　　* 对于静态同步方法，锁是当前类的Class类元信息

　　*

　　* lock7、8

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

　　*

　　* 所有的同步方法用的都是同一把锁----实例对象本身，就是new出来的具体实例对象本身

　　* 也就是说如果一个实例对象的普通同步方法获取锁后，该实例对象的其他普通同步方法必须等待获取锁的方法释放锁后才能获得锁

　　* 可是别的实例对象的普通同步方法因为跟该实例对象的普通同步方法用到是不同锁，所以不用等待该实例对象已获取锁的普通

　　* 同步方法释放锁就可以获取它们自己的锁

　　*

　　* 所有的静态同步方法用的也是同一把锁----类对象本身，就是我们说过的唯一模板Class

　　* 具体实例对象this和唯一模板Class，这两把锁是两个不同的对象，所有静态同步方法与普通同步方法之间是不会有竞态条件的，

　　* 但是一旦一个静态同方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁。

　　1.标准访问，请问是先打印邮件还是短信？ 答案：Email

　　sendEmail与sendSms都是普通同步方法，都使用synchronized锁

　　这里按方法调用顺序，依次执行，当前synchronized锁住的是同一个实例对象

　　java

　　package day02_lam;

　　import java.util.concurrent.TimeUnit;

　　class Phone{

　　public synchronized void sendEmail throws InterruptedException{

　　System.out.println("sendEmail");

　　}

　　public synchronized void sendSms{

　　System.out.println("sendSMS");

　　}

　　}

　　public class Lock8{

　　public static void main(String args) throws InterruptedException{

　　Phone phone=new Phone;

　　//线程A发送Email

　　new Thread(->{

　　try{

　　phone.sendEmail;

　　}catch(InterruptedExceptione){

　　e.printStackTrace;

　　}

　　},"A").start;

　　Thread.sleep(300);

　　//线程B发送短信

　　newThread(->{

　　phone.sendSms;

　　},"B").start;

　　}

　　}

　　2.email方法新增暂停4秒钟，请问是先打印邮件还是短信？答案：Email

　　lock2是lock1的变形，其原理与lock1一致，synchronized锁住的是同一个对象，必须等到第一个方法把锁释放后，第二个方法才能够获得锁

　　java

　　package day02_lam;

　　import java.util.concurrent.TimeUnit;

　　class Phone{

　　public synchronized void sendEmailthrowsInterruptedException{

　　//睡眠4秒种

　　TimeUnit.SECONDS.sleep(4);

　　System.out.println("sendEmail");

　　}

　　public synchronized void sendSms{

　　System.out.println("sendSMS");

　　}

　　}

　　public class Lock8{

　　public static void main(String args)throws InterruptedException{

　　//资源类

　　Phone phone=new Phone;

　　//线程A sendEmail

　　newThread(->{

　　try{

　　phone.sendEmail;

　　}catch(InterruptedExceptione){

　　e.printStackTrace;

　　}

　　},"A").start;

　　//这里保证线程A能够执行完

　　Thread.sleep(300);

　　//线程B sendSms

　　newThread(->{

　　phone.sendSms;

　　},"B").start;

　　}

　　}

　　结果：等待4秒钟后出现sendEmail与sendSMS同时输出

　　3.新增普通的hello方法，请问先打印邮件还是hello? 答案：hello

　　只有添加synchronized关键字的方法才会被synchronized锁控制

　　java

　　package day02_lam;

　　import java.util.concurrent.TimeUnit;

　　class Phone{

　　public synchronized void sendEmailthrows InterruptedException{

　　TimeUnit.SECONDS.sleep(4);

　　System.out.println("sendEmail");

　　}

　　public 外墙保温板施工规范 synchronized void sendSms{

　　System.out.println("sendSMS");

　　}

　　public void hello{//未加synchronized

　　System.out.println("hello");

　　}

　　}

　　public class Lock8{

　　public static void main(String args)throws InterruptedException{

　　Phone phone=new Phone;

　　//线程A调用sendEmail

　　new Thread(->{

　　try{

　　phone.sendEmail;

　　}catch(InterruptedExceptione){

　　e.printStackTrace;

　　}

　　},"A").start;

　　Thread.sleep(300);

　　//线程B调用普通方法hello

　　new Thread(->{

　　//phone.sendSms;

　　phone.hello;

　　},"B").start;

　　}

　　}

　　结果：hello先输出，4s后sendEmail再输出

　　4.两部手机，请问先打印邮件还是短信 ？答案：SMS

　　不同实例对象，synchronized锁住的是对应的调用对象

　　java

　　package day02_lam;

　　import java.util.concurrent.TimeUnit;

　　class Phone{

　　public synchronized void sendEmailthrows InterruptedException{

　　//睡眠4秒种

　　TimeUnit.SECONDS.sleep(4);

　　System.out.println("sendEmail");

　　}

　　public synchronized void sendSms{

　　System.out.println("sendSMS");

　　}

　　public void hello{

　　System.out.println("hello");

　　}

　　}

　　public class Lock8{

　　public static void main(String args)throws InterruptedException{

　　Phone phone=new Phone;

　　Phone phone2=new Phone;

　　//sychronized锁定是当前对象对应的this，phone与phone2分别锁的是自己的this

　　//线程A使用实例phone调用sendEmail

　　newThread(->{

　　try{

　　//sendEmail方法中包含睡眠4秒种

　　phone.sendEmail;

　　}catch(InterruptedExceptione){

　　e.printStackTrace;

　　}

　　},"A").start;

　　Thread.sleep(300);

　　//线程B使用实例phone2调用sendSms

　　newThread(->{

　　phone2.sendSms;

　　//phone.hello;

　　},"B").start;

　　}

　　}

　　结果：sendSMS先输出，4s后sendEmail再输出

　　5.两个静态同步方法，1部手机，请问先打印邮件还是短信? 答案：Email

　　synchronized锁静态方法，实际是锁住的类元信息，因为静态方法是随类元信息的加载而保存到jvm的静态区，是所有实例创建的模板

　　java

　　package day02_lam;

　　import java.util.concurrent.TimeUnit;

　　class Phone{

　　public static synchronized void sendEmailthrows InterruptedException{

　　TimeUnit.SECONDS.sleep(4);

　　System.out.println("sendEmail");

　　}

　　public static synchronized void sendSms{

　　System.out.println("sendSMS");

　　}

　　public void hello{

　　System.out.println("hello");

　　}

　　}

　　public class Lock8{

　　public static void main(String args)throws InterruptedException{

　　Phone phone=new Phone;

　　new Thread(->{

　　try{

　　phone.sendEmail;

　　}catch(InterruptedException e){

　　e.printStackTrace;

　　}

　　},"A").start;

　　Thread.sleep(300);

　　newThread(->{

　　phone.sendSms;

　　},"B").start;

　　}

　　}

　　结果：4秒种后，sendEmail率先输出，sendSMS紧随其后

　　6.两个静态同步方法，2部手机，请问先打印邮件还是短信？答案：Email

　　与lock5的运行结果一致，当前synchronized锁住的是类元信息

　　java

　　package day02_lam;

　　import java.util.concurrent.TimeUnit;

　　class Phone{

　　public static synchronized void sendEmail throws InterruptedException{

　　TimeUnit.SECONDS.sleep(4);

　　System.out.println("sendEmail");

　　}

　　public static synchronized void sendSms{

　　System.out.println("sendSMS");

　　}

　　public void hello{

　　System.out.println("hello");

　　}

　　}

　　public class Lock8{

　　publicstaticvoidmain(Stringargs)throwsInterruptedException{

　　Phone phone=new Phone;

　　Phone phone2=new Phone;

　　new Thread(->{

　　try{

　　phone.sendEmail;

　　}catch(InterruptedException e){

　　e.printStackTrace;

　　}

　　},"A").start;

　　Thread.sleep(300);

　　new Thread(->{

　　//phone.sendSms;

　　phone2.sendSms;

　　//phone.hello;

　　},"B").start;

　　}

　　}

　　结果：与lock5的运行结果一致，sendEmail与sendSMS都是4s后进行输出，synchronized也是锁住的类元信息

　　7.一个普通同步方法，一个静态同步方法，1部手机，请问先打印Email还是SMS？答案：SMS

　　原理：普通同步方法，synchronized锁住的是当前实例对象，当前实例对象存在于jvm的堆内存区

　　静态同步方法，synchronized锁住的是当前类的类元信息，存在于jvm元空间的静态区中

　　java

　　package day02_lam;

　　import java.util.concurrent.TimeUnit;

　　class Phone{

　　//静态同步方法

　　public static synchronized void sendEmailthrows InterruptedException{

　　TimeUnit.SECONDS.sleep(4);

　　System.out.println("sendEmail");

　　}

　　//普通同步方法

　　public synchronized void sendSms{//无static

　　System.out.println("sendSMS");

　　}

　　public void hello{

　　System.out.println("hello");

　　}

　　}

　　public class Lock8{

　　public static void main(String args) throws InterruptedException{

　　Phonephone=newPhone;

　　Phonephone2=newPhone;

　　newThread(->{

　　try{

　　phone.sendEmail;

　　}catch(InterruptedExceptione){

　　e.printStackTrace;

　　}

　　},"A").start;

　　Thread.sleep(300);

　　newThread(->{

　　phone.sendSms;

　　//phone2.sendSms;

　　//phone.hello;

　　},"B").start;

　　}

　　}

　　8.一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信？答案：SMS

　　原理：与lock7一致

　　java

　　package day02_lam;

　　import java.util.concurrent.TimeUnit;

　　class Phone{

　　public static synchronized void sendEmailthrowsInterruptedException{

　　TimeUnit.SECONDS.sleep(3);

　　System.out.println("sendEmail");

　　}

　　public synchronized void sendSms{

　　System.out.println("sendSMS");

　　}

　　public void hello{

　　System.out.println("hello");

　　}

　　}

　　public class Lock8{

　　publicstaticvoidmain(Stringargs)throwsInterruptedException{

　　Phone phone=new Phone;

　　Phone phone2=new Phone;

　　new Thread(->{

　　try{

　　phone.sendEmail;

　　}catch(InterruptedExceptione){

　　e.printStackTrace;

　　}

　　},"A").start;

　　Thread.sleep(300);

　　new Thread(->{

　　//phone.sendSms;

　　phone2.sendSms;

　　//phone.hello;

　　},"B").start;

　　}

　　}

　　结果：运行结果与lock7一致，sendSMS先输出，4s后sendEmail再输出

外墙保温板施工规范