2017Android面试题解析 --（一）

每篇章10道题解析

1. 简述synchronized?Object；

synchronized确保每次只有一个线程能持有对象锁并对同步代码块进行访问，并在访问结束之前，不会被其它线程访问。也就说，即使同步代码块在执行过程中遭遇线程调度，其它线程也无法访问该同步代码块，直到该线程被重新调度并完成同步代码块的访问并释放对象锁。这样就保证了线程对同步代码块访问的连续性不受线程调度而中断。

synchronized关键字的使用方法有两种：
1、直接在方法前面进行声明，这种方式的声明，整个方法都是同步代码块，至于其对象锁则是访问该方法时所使用的对象也就是this，示例：
class C{
  public synchronized void syncMethod(...){
 ...
  }
}
注：在这种方式的声明中，如果方法前面有static关键字，那么该方法是一个类方法，由于类在Java中其实也是一个class对象，所以类方法的对象锁不是该类的实例化对象，而是该类的class对象。

发生死锁必须同时满足四个条件:

1.互斥条件

2.不剥夺条件

3.请求和保持条件

4.循环等待条件

2、在方法中声明一个同步代码块，这种方式的声明，关键字后{}内的代码块是同步代码块，而其对象锁则是关键字后()内的对象object，示例：

class C{
  public void syncMethod(...){
 ...
 synchronized(object){
    ....
 }
 ...
  }
}

————————————————————

对与ovject类的理解

 Java把现实中的任何事物都当做一个对象(Object), Java是面向对象的，就是Object Orentied 简称OO 。此处的Object在Java中被定义为一个顶级父类，它是任何类父类，我们可以显示的继承它，也可以隐式继承，如以下实例：

 

public class Dog extends Object{

 

}

与

public class Dog{

 

}

重点掌握equals()和==的区别，重写equals（），同时要注意对hashcode（）的重写

1.equals()和==的区别

==：对于基本类型（int,short,byte,long,float……），比较的是他们的值。对于复合类型（比如string，比如新建一个类

Employee e1,e2;
e1=new Employee("王劲",26,6300);
e2=new Employee("张山",30,3800);
这里 e1 e2 都是复合数据了）比较的是它们在内存中的地址。（JVM的栈、堆、方法区），理解下JVM内存地址分配

equals()：Object类中equals的默认实现是return（this=obj），即默认是比较对象的内存地址，一般会重写equals（）。

2.Monitor机制；

 Monitor其实是一种同步工具，也可以说是一种同步机制，它通常被描述为一个对象，主要特点是：

• 对象的所有方法都被“互斥”的执行。好比一个Monitor只有一个运行“许可”，任一个线程进入任何一个方法都需要获得这个“许可”，离开时把许可归还。（用synchronized上锁）
• 通常提供singal机制：允许正持有“许可”的线程暂时放弃“许可”，等待某个谓词成真（条件变量），而条件成立后，当前进程可以“通知”正在等待这个条件变量的线程，让他可以重新去获得运行许可。
• 
  

3.简述happen-before规则；

我们编写的程序都要经过优化后（编译器和处理器会对我们的程序进行优化以提高运行效率）才会被运行，优化分为很多种，其中有一种优化叫做重排序，重排序需要遵守happens-before规则，不能说你想怎么排就怎么排，如果那样岂不是乱了套。

happen-before原则是什么？

happens-before 口诀:如果两个操作之间具有happens-before 关系，那么前一个操作的结果就会对后面一个操作可见。

常见的happens-before规则：

1.程序顺序规则：一个线程中的每个操作，happens- before 于该线程中的任意后续操作。
（注解：如果只有一个线程的操作，那么前一个操作的结果肯定会对后续的操作可见。)

2.监视器锁规则：对一个监视器锁的解锁，happens- before 于随后对这个监视器锁的加锁。
（注解：这个最常见的就是syncronized 方法 和 syncronized块) 

3.volatile变量规则：对一个volatile域的写，happens- before 于任意后续对这个volatile域的读。

[java] view plain copy

1.  int a =0;  
2.  volatile int b = 0;  
3. 线程1{  
4.  操作1：a = 1;  
5. //插入一个StoreStore屏障 禁止上面的普通写与下面的volatile 写重排序  
6.  操作2：b =2;  
7. }  
8. 线程2{  
9.  if (b==2)  
10. //LoadLoad屏障。 禁止上面的volatile 与下面的普通读重排序  
11.   System.out.println(a);//a的值为多少呢？  
12. }  

因为存在屏障，JVM就不会重排序上述代码。

4.传递性：如果A happens- before B，且B happens- before C，那么A happens- before C

4.JUC（Lock）和Object，Monitor机制（synchronized）区别是什么；

了解Lock和synchronized的区别

5.简述AQS原理；简述DCL失效原因，解决方法；

（一）AQS原理：AQS核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制，这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中。

它维护了一个volatile int state（代表共享资源）和一个FIFO线程等待队列（多线程争用资源被阻塞时会进入此队列）。这里volatile是核心关键词，

——————————————————————————————————

DCL失效

DCL单例模式（1、单例类只能有一个实例。2、单例类必须自己创建自己的唯一实例。3、单例类必须给所有其他对象提供这一实例。）

针对延迟加载法的同步实现所产生的性能低的问题，我们可以采用DCL，即双重检查加锁（Double Check Lock）的方法来避免每次调用getInstance（）方法时都同步。实现方式如下：

public class LazySingleton {    private int someField;    private static LazySingleton instance;    private LazySingleton() {        this.someField = new Random().nextInt(200)+1;         // (1)    }    public static LazySingleton getInstance() {        if (instance == null) {                               // (2)            synchronized(LazySingleton.class) {               // (3)                if (instance == null) {                       // (4)                    instance = new LazySingleton();           // (5)                }            }        }        return instance;                                      // (6)    }    public int getSomeField() {        return this.someField;                                // (7)    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

优点：资源利用率高,不执行getInstance就不会被实例，多线程下效率高。

缺点：第一次加载时反应不快，由于Java 内存模型一些原因偶尔会失败，在高并发环境下也有一定的缺陷，虽然发生概率很小。

DCL对instance进行了两次null判断，第一层判断主要是为了避免不必要的同步，第二层的判断则是为了在null的情况下创建实例。