1. 对java多态的理解

多态变现了事物的多种状态。

多态存在的三个必要条件 一、要有继承； 二、要有重写； 三、父类引用指向子类对象。

多态的好处：

1.可替换性（substitutability）。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。

2.可扩充性（extensibility）。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。

3.接口性（interface-ability）。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法，computeArea()以及computeVolume()。子类，如Circle和Sphere为了实现多态，完善或者覆盖这两个接口方法。

4.灵活性（flexibility）。它在应用中体现了灵活多样的操作，提高了使用效率。

5.简化性（simplicity）。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

1.2动态绑定（dynamic binding），

是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

2字符串String、数组、数据类型转换

1) Java中String的了解

String对象一旦被创建就是固定不变的了，对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象

字符串常量池。

每当我们创建字符串常量时，JVM会首先检查字符串常量池，如果该字符串已经存在常量池中，那么就直接返回常量池中的实例引用。如果字符串不存在常量池中，就会实例化该字符串并且将其放到常量池中。由于String字符串的不可变性我们可以十分肯定常量池中一定不存在两个相同的字符串

2) String，Stringbuffer，Stringbuilder三者的区别

String是不可变的对象, 因此在每次对String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，性能就会降低。

使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。StringBuffer是线程安全的，StringBuilder是不考虑线程安全的。所以StringBuilder要比StringBuffer块。

基本原则：如果要操作少量的数据，用String ；单线程操作大量数据，用StringBuilder ；多线程操作大量数据，用StringBuffer。

3) 8种基本类型和所占字节

[图片上传失败...(image-c5f736-1548214098394)]

4) int与integer的区别

Ingeter是int的包装类，int的初值为0，Ingeter的初值为null。

①无论如何，Integer与new Integer不会相等。不会经历拆箱过程，i3的引用指向堆，而i4指向专门存放他的内存（常量池），他们的内存地址不一样，所以为false
②两个都是非new出来的Integer，如果数在-128到127之间，则是true,否则为false
java在编译Integer i2 = 128的时候,被翻译成-> Integer i2 = Integer.valueOf(128);而valueOf()函数会对-128到127之间的数进行缓存 ③两个都是new出来的,都为false
④int和integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比

3 java中==和equals和hashCode的区别

1) ==比较

基本类型byte,short,char,int,long,float,double,boolean 比较的是他们的值。

引用类型（类、接口、数组）比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。

对象是放在堆中的，栈中存放的是对象的引用（地址）。由此可见'=='是对栈中的值进行比较的。如果要比较堆中对象的内容是否相同，那么就要重写equals方法了。

2) equals

下面是Object类中equals方法：

public boolean equals(Object obj) {

return (this == obj);

}

所以如果没有重写equals方法，equals与==是等效的

要是类中覆盖了equals方法，那么就要根据具体的代码来确定equals方法的作用了，覆盖后一般都是通过对象的内容是否相等来判断对象是否相等。

重写 equals 需要重写 hashCode。

3) hashCode

hashCode()方法返回的就是一个hash码， hash码的主要用途就是在对对象进行散列的时候作为key输入。hashcode方法只有在集合中用到，先判断hashCode是否相等，再判断equals是否相同，再确定是否放入集合。

1、如果两个对象equals，Java运行时环境会认为他们的hashcode一定相等。

2、如果两个对象不equals，他们的hashcode有可能相等。

3、如果两个对象hashcode相等，他们不一定equals。

4、如果两个对象hashcode不相等，他们一定不equals。

4 线程sleep和wait有什么区别

sleep()可以将一个线程睡眠，参数可以指定一个时间。

而wait()可以将一个线程挂起，直到超时或者该线程被唤醒。

wait有两种形式wait()和wait(milliseconds).

sleep和wait的区别有：

1，这两个方法来自不同的类分别是Thread和Object

2，最大本质的区别是:sleep()不释放同步锁,wait()释放同步缩.

还有用法的上的不同是:sleep(milliseconds)可以用时间指定来使他自动醒过来,如果时间不到你只能调用interreput()来强行打断;wait()可以用notify()直接唤起.

5 闭包和局部内部类的区别

· 内部类可以很好的实现隐藏。 一般的非内部类，是不允许有 private 与protected权限的，但内部类可以

· 内部类拥有外围类的所有元素的访问权限

· 可以实现多重继承

· 可以避免修改接口而实现同一个类中两种同名方法的调用。

闭包简单理解：闭包能够将一个方法作为一个变量去存储，这个方法有能力去访问所在类的自由变量。

6 进程和线程的区别

线程是进程中执行运算的最小单位，是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。

（1） 一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。 （2）资源分配给进程，同一进程的所有线程共享该进程的所有资源。 （3）处理机分给线程，即真正在处理机上运行的是线程。 （4）线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。线程是指进程内的一个执行单元,也是进程内的可调度实体.

7 Serializable和Parcelable序列化

序列化目的：

（1）.永久的保存对象数据

（2）.通过序列化操作将对象数据在网络上进行传输

（3）进行Android开发的时候，无法将对象的引用传给Activities或者Fragments，我们需要将这些对象放到一个Intent或者Bundle里面，然后再传递。

Java应用程序中有Serializable来实现序列化操作,Android中有Parcelable来实现序列化操作,在Android中除了对数据持久化的时候（保存在磁盘）需要使用到Serializable来实现序列化操作,其他的时候我们使用Parcelable,因为Parcelable比 Serializable占用内存小，效率高。后者在序列化操作的时候会产生大量的临时变量,(原因是使用了反射机制)

8 静态属性和静态方法

对于静态的属性，子类可以继承父类的静态属性。但是和非静态的属性一样，会被隐藏。

对于静态的方法，子类可以继承父类的静态方法。但是子类不可重写覆盖父类的静态方法，子类的同名静态方法会隐藏父类的静态方法。

(隐藏的意思就是不会被覆盖，都存在)

9 final，finally，finalize的区别

他们之间没有关系。

1、 final 修饰符（关键字）

final用于控制成员、方法或者是一个类是否可以被重写或者继承等功能

2、 finally(用于异常处理)

finally在try,catch中可以有，可以没有。如果trycatch中有finally则必须执行finally快中的操作。一般情况下，用于关闭文件的读写操作，或者是关闭数据库的连接等等。

3、 finalize（用于垃圾回收）

finalize这个object提供的一个是方法。在java中，允许使用finalize()方法在垃圾收集器将对象从内存中清理出去之前做必要的清理工作。

10 反射

获取到Class对象：

1. 通过实例变量方式

new Dog().getClass();

2. 通过类名方式

Dog.class

3. 通过Class.forName(String classname)方式

然后再获取类的字段、方法、父类和接口等信息。再使用这些属性和方法。

11 代理

1.静态代理

在程序运行之前，代理类的.class文件已经存在了。

静态代理类通常只代理一个接口方法。如果代理任务过多就会有很多代理类。

静态代理事先知道要代理的是什么。

2. 动态代理

主要使用Proxy类和InvocationHandler接口实现代理工作。

在程序运行时，通过反射机制动态生成。

动态代理类可以代理所有接口和方法。

动态代理事先不知道要代理的是什么，只有在运行的时候才能确定。

动态代理的调用处理程序必须事先InvocationHandler接口，及使用Proxy类中的newProxyInstance方法动态的创建代理类。

12数据结构

image.png

从上面的集合框架图可以看到，Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等

Collection
List 子接口 (有序可重复)
LinkedList（链表存储，插入删除效率高）
ArrayList （数组存储，查询效率高）
Vector
Stack

image.png

Set子接口 (无序不可重复)

image.png

Map

image.png

如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。
如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。
要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。

13 栈内存与堆内存

栈内存

在函数中定义的基本类型的变量和对象的引用变量都是在函数的栈内存中分配。
当在一段代码块中声明了一个变量时，java就会在栈内存中为这个变量分配内存空间，当超过变量的作用域之后，java也会自动释放为该变量分配的空间，而这个回收的空间可以即刻用作他用。

堆内存

堆内存用于存放由new创建的对象和数组。
在堆内存中分配的内存空间，由java虚拟机自动垃圾回收器来管理。在堆中产生了一个数组或者对象后，还可以在栈中定义一个特殊的变量，变量的值就等于数组或对象在堆内存中的首地址，而这个栈中的特殊变量，也就成为数组或对象的引用变量。以后可以在程序中使用栈内存中的引用变量访问堆内存中的数组或对象了。引用变量相当于是为数组或对象起的一个别名，或者是代号。
数组和对象在没有引用变量指向它的时候，才变成垃圾，不能被继续使用，但是仍然会占用堆内存空间，而后在一个不确定的时间内，由java虚拟机自动垃圾回收器回收，这也是java程序为什么会占用很大内存的原因。

14 重载与重写

重载

对于同一个类，如果这个类里面有两个或者多个重名的方法，但是方法的参数个数、类型、顺序至少有一个不一样，这时候就构成方法重载 。
方法重载就是对不同数据类型的的数据实现相似的操作。

重写

1.概念：

当一个子类继承一父类，而子类中的方法与父类中的方法的名称，参数个数、类型都完全一致时，就称子类中的这个方法重写了父类中的方法。

重写也是覆盖 override

2.前提：

必须要有继承关系

三，重载和重写的不同

重载(overload)：
1：前提： 所有的重载函数必须在同一个类中
2：特点：
函数名相同，参数列表不同，与其他的无关(访问控制符、返回值类型)
3：不同：
个数不同 、 顺序不同、 类型不同

2：重写(override)：
1：前提： 继承
2：特点：
函数名必须相同、参数列表必须相同。
子类的返回值类型要等于或者小于父类的返回值

15 单例模式

单例模式特点：

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

单例模式保证了全局对象的唯一性，比如系统启动读取配置文件就需要单例保证配置的一致性。

实现单例模式的方式

饿汉式

public class Singleton{
//私有化构造函数
private Singleton (){
}
private static Singleton singleton=new Singleton();
public static Singleton getInstance(){
return singleton;
}
}

懒汉式单例（延迟加载方式）

public class Singleton3 {
// 私有构造
private Singleton3() {}

private static Singleton3 single = null;

public static Singleton3 getInstance() {
    
    // 等同于 synchronized public static Singleton3 getInstance()
    synchronized(Singleton3.class){
      // 注意：里面的判断是一定要加的，否则出现线程安全问题
        if(single == null){
            single = new Singleton3();
        }
    }
    return single;
}

}
在方法上加synchronized同步锁或是用同步代码块对类加同步锁，此种方式虽然解决了多个实例对象问题，但是该方式运行效率却很低下，下一个线程想要获取对象，就必须等待上一个线程释放锁之后，才可以继续运行。

public class Singleton4 {
// 私有构造
private Singleton4() {}

private static Singleton4 single = null;

// 双重检查
public static Singleton4 getInstance() {
    if (single == null) {
        synchronized (Singleton4.class) {
            if (single == null) {
                single = new Singleton4();
            }
        }
    }
    return single;
}

}
使用双重检查进一步做了优化，可以避免整个方法被锁，只对需要锁的代码部分加锁，可以提高执行效率。

16 设计模式

Android较常用到的设计模式？

适配器模式：GridView、ListView的Adapter;
建造者模式：AlertDialog.Builder;
观察者模式：ListView的adapter.notifyDataSetChanged;
责任链模式：View的事件分发；

回调函数和观察者模式的区别？

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。观察者模式完美的将观察者和被观察的对象分离开，一个对象的状态发生变化时，所有依赖于它的对象都得到通知并自动刷新。
回调函数其实也算是一种观察者模式的实现方式，回调函数实现的观察者和被观察者往往是一对一的依赖关系。
所以最明显的区别是观察者模式是一种设计思路，而回调函数式一种具体的实现方式；另一明显区别是一对多还是多对多的依赖关系方面。

17 TCP建立连接三次握手和释放连接四次握手

TCP建立连接三次握手

（1）、三次握手的过程

1 主机A通过向主机B 发送一个含有同步序列号的标志位的数据段给主机B ,向主机B 请求建立连接,通过这个数据段,
主机A告诉主机B 两件事:我想要和你通信;你可以用哪个序列号作为起始数据段来回应我.
2 主机B 收到主机A的请求后,用一个带有确认应答(ACK)和同步序列号(SYN)标志位的数据段响应主机A,也告诉主机A两件事:
我已经收到你的请求了,你可以传输数据了;你要用哪佧序列号作为起始数据段来回应我
3 主机A收到这个数据段后,再发送一个确认应答,确认已收到主机B 的数据段:"我已收到回复,我现在要开始传输实际数据了

这样3次握手就完成了,主机A和主机B 就可以传输数据了.

image.png

（2）、为什么需要第三次握手?

 简而言之：第三次握手，主机A发送一次确认是为了防止：如果客户端迟迟没有收到服务器返回的确认报文，这时他会放弃连接，重新启动一条连接请求；但问题是：服务器不知客户端没收到，所以他会收到两个连接请求，白白浪费了一条连接开销。

TCP释放连接四次握手

（1）、四次握手的过程

假设主机A为客户端，主机B为服务器，其释放TCP连接的过程如下：
1） 关闭客户端到服务器的连接：首先客户端A发送一个FIN，用来关闭客户到服务器的数据传送，然后等待服务器的确认。其中终止标志位FIN=1，序列号seq=u
　 2） 服务器收到这个FIN，它发回一个ACK，确认号ack为收到的序号加1。
　3） 关闭服务器到客户端的连接：也是发送一个FIN给客户端。
　 4） 客户段收到FIN后，并发回一个ACK报文确认，并将确认序号seq设置为收到序号加1。

image.png

（2）为什么TCP释放连接需要四次？

  TCP建立连接要进行三次握手，而断开连接要进行四次。这是由于TCP的半关闭造成的。因为TCP连接是全双工的(即数据可在两个方向上同时传递)所以进行关闭时每个方向上都要单独进行关闭。这个单方向的关闭就叫半关闭。当一方完成它的数据发送任务，就发送一个FIN来向另一方通告将要终止这个方向的连接。

18 什么是TCP协议？UDP协议？区别？

TCP

TCP（Transmission Control Protocol，传输控制协议）是面向连接的协议，也就是说，在收发数据前，必须和对方建立可靠的连接。一个TCP连接必须要经过三次“对话”才能建立起来，其中的过程非常复杂。

UDP

UDP（User Data Protocol，用户数据报协议）

（1） UDP是一个非连接的协议，传输数据之前源端和终端不建立连接，当它想传送时就简单地去抓取来自应用程序的数据，并尽可能快地把它扔到网络上。在发送端，UDP传送数据的速度仅仅是受应用程序生成数据的速度、计算机的能力和传输带宽的限制；在接收端，UDP把每个消息段放在队列中，应用程序每次从队列中读一个消息段。

（2） 由于传输数据不建立连接，因此也就不需要维护连接状态，包括收发状态等，因此一台服务机可同时向多个客户机传输相同的消息。

（3） UDP信息包的标题很短，只有8个字节，相对于TCP的20个字节信息包的额外开销很小。

（4） 吞吐量不受拥挤控制算法的调节，只受应用软件生成数据的速率、传输带宽、源端和终端主机性能的限制。

（5）UDP使用尽最大努力交付，即不保证可靠交付，因此主机不需要维持复杂的链接状态表（这里面有许多参数）。

（6）UDP是面向报文的。发送方的UDP对应用程序交下来的报文，在添加首部后就向下交付给IP层。既不拆分，也不合并，而是保留这些报文的边界，因此，应用程序需要选择合适的报文大小。

小结TCP与UDP的区别：

1.TCP建立连接与UDP不建立连接；
2.对系统资源的要求，TCP较多，UDP少；
3.UDP程序结构较简单；
4.TCP的数据传输是流模式，UDP是数据报模式 ；
5.TCP保证数据正确性，UDP可能丢包，TCP保证数据顺序，UDP不保证。

19 Java NIO和IO的主要区别

image.png

面向流与面向缓冲
Java NIO和IO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区。 Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所有您需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。

阻塞与非阻塞IO
Java IO的各种流是阻塞的。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。 Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。

选择器（Selectors）
Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道。

20 多线程

关于多线程请先过一遍这篇文章：

Java中的多线程你只要看这一篇就够了

创建线程的三种方式及其对比

一、继承Thread类创建线程类
（Thread其实也是实现了Runnable接口）
class mytread extends Thread{
@Override
public void run() {
super.run();
}
}
二、实现Runnable接口创建线程类

class myrunable implements Runnable{

    @Override
    public void run() {

    }
}

三、实现Callable接口创建线程类
Callable 和 Runnable相似，但是Runnable没有返回值和抛出异常

class mycallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        return null;
    }
}

创建线程的三种方式的对比

采用实现Runnable、Callable接口的方式创见多线程时，优势是：

线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。

在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

劣势是：

编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。

使用继承Thread类的方式创建多线程时优势是：

编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。

劣势是：

线程类已经继承了Thread类，所以不能再继承其他父类。

21 volatile

1.volatile保证可见性

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

2）禁止进行指令重排序。

2.volatile不能确保原子性

比如对被volatile修饰的变量进行赋值操作，就包括读取变量的原始值、进行赋值操作、写入工作内存三步。在多线程情况下可能会被打断，不具备确保原子性（类似于事务全部完成）。
解决方案：可以通过synchronized或lock，进行加锁，来保证操作的原子性。也可以通过AtomicInteger。

3.volatile保证有序性

在前面提到volatile关键字能禁止指令重排序，所以volatile能在一定程度上保证有序性。
volatile关键字禁止指令重排序有两层意思：
1）当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；
2）在进行指令优化时，不能将在对volatile变量的读操作或者写操作的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。

22 volatile和synchronized的区别

1.volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
2.volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的
3.volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性
4.volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
5.volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化

23 死锁产生的原因及四个必要条件

所谓死锁是指多个线程因竞争资源而造成的一种僵局（互相等待），若无外力作用，这些进程都将无法向前推进。

（1） 互斥条件：一个资源每次只能被一个进程使用。
（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

在有些情况下死锁是可以避免的。三种用于避免死锁的技术：

加锁顺序（线程按照一定的顺序加锁）
加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁）
死锁检测

当检测到死锁后，可选择全部释放锁，过一段时间再重试，治标不治本。
一个更好的方案是给这些线程设置优先级，让一个（或几个）线程回退，剩下的线程就像没发生死锁一样继续保持着它们需要的锁。如果赋予这些线程的优先级是固定不变的，同一批线程总是会拥有更高的优先级。为避免这个问题，可以在死锁发生的时候设置随机的优先级。

24 线程池

在Java中，线程池的概念是Executor这个接口，具体实现为ThreadPoolExecutor类
对线程池的配置，就是对ThreadPoolExecutor构造函数的参数的配置
int corePoolSize 该线程池中核心线程数最大值。 如果超过corePoolSize，则
新建的是非核心线程
int maximumPoolSize 该线程池中线程总数最大值 (核心线程数 + 非核心线程数)
long keepAliveTime 非核心线程闲置超时时长
TimeUnit unit keepAliveTime的单位
BlockingQueue<Runnable> workQueue 该线程池中的任务队列：维护着等待执
行的Runnable对象
ThreadFactory threadFactory 创建线程的方式
RejectedExecutionHandler handler 抛出异常专用的

ThreadPoolExecutor的策略
线程数量未达到corePoolSize，则新建一个线程(核心线程)执行任务
线程数量达到了corePoolSize，则将任务移入队列等待
队列已满，新建线程(非核心线程)执行任务
队列已满，总线程数又达到了maximumPoolSize，就会由上面那位星期天(RejectedExecutionHandler)抛出异常

常见四种线程池
Java通过Executors提供了四种线程池，这四种线程池都是直接或间接配置ThreadPoolExecutor的参数实现的。

CachedThreadPool()

可缓存线程池：

线程数无限制
有空闲线程则复用空闲线程，若无空闲线程则新建线程
一定程序减少频繁创建/销毁线程，减少系统开销

创建方法：
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

FixedThreadPool()

定长线程池：

可控制线程最大并发数（同时执行的线程数）
超出的线程会在队列中等待

ScheduledThreadPool()

定长线程池：

支持定时及周期性任务执行。

SingleThreadExecutor()

单线程化的线程池：

有且仅有一个工作线程执行任务
所有任务按照指定顺序执行，即遵循队列的入队出队规则

创建方法：
ExecutorService singleThreadPool = Executors.newSingleThreadPool();