• 编译型语言——一次编译，到处运行
  编译型语言在运行前，需要通过编译器将源码翻译为机器码（二进制指令码），进而生成可执行文件。可执行文件的运行无需源码与编译器，也就是说代码只要编译完了就可以脱离开发环境运行。
  
• 解释型语言——一次编写，到处运行
  解释型语言可以直接运行源码，在运行源码时，解释器逐行将源码翻译为机器码，但不生成可执行文件，也就是说再次运行源码时需要再次解释，所以解释型语言无法脱离开发环境运行，而且运行效率低于编译型语言。
  

        虽然，Java 和 C++ 都是面向对象的语言，都支持封装、继承和多态，但是它们还是有挺多不相同的地方：

• Java 不提供指针来直接访问内存，程序内存更加安全；
• Java 类只能单继承，而C++ 支持多继承；虽然 Java 的类不可以多继承，但是接口可以多继承。
• Java 有 GC 垃圾回收机制，不需要手动释放内存。
• C ++同时支持方法重载和操作符重载，但是 Java 只支持方法重载（操作符重载增加了复杂性，这与 Java 最初的设计思想不符）。

二、基本语法

• 被final修饰的类不能被继承；
• 被final修饰的对象的引用地址不能改变，对象的属性可以修改；
  
  
• 被final修饰的方法不能被重写；
• 被final修饰的变量会变成常量，值不能被更改。

• <<：左移运算符，向左移若干位，高位丢弃，低位补零。x << 1，相当于 x 乘以 2(不溢出的情况下)。
• >>：带符号右移，向右移若干位，高位补符号位，低位丢弃。正数高位补 0，负数高位补 1。x >> 1，相当于 x 除以 2。
• >>>：无符号右移，忽略符号位，空位都以 0 补齐。

如果移位的位数超过数值所占有的位数会怎样？

3.变量

（1）成员变量与局部变量的区别？

• 语法形式 ：成员变量定义在类里，而局部变量定义在代码块或方法中，或是方法的参数；成员变量可以被public,private,static等修饰符修饰，而局部变量不能被访问控制修饰符(private、protected、public)及static修饰；二者都能被final修饰。
• 存储方式 ：静态成员变量是属于类的，如果没有使用static修饰，这个成员变量是属于实例的。而实例对象存在于堆内存，局部变量则存在于栈内存。
• 生存时间 ：成员变量随着对象的创建而存在，而局部变量随着方法的调用自动生成，随着方法的调用结束而消亡。
• 默认值 ：成员变量如果没有被赋初始值，则会自动以类型的默认值而赋值（一种情况例外：被final修饰的成员变量也必须显式地赋值），而局部变量不会自动赋值。

（2）静态变量有什么作用？

• 1）调用方式不同
  可以用类名直接调用静态方法，也可以用对象调用静态方法；而实例方法能通过对象调用。
  【tips】一般不建议使用 对象.方法名 的方式来调用静态方法。这种方式非常容易造成混淆，静态方法不属于类的某个对象而是属于这个类。
  
  
• 2）能访问的东西不同
  静态方法只允许访问静态成员，不允许访问实例成员，而实例方法二者都能访问。
  

• 方法重载
  定义在同一个类中的多个方法，方法名必须相同，参数类型不同、个数不同、顺序不同（三者满足其一就是重载），返回值类型和修饰符可以不同，也就是说两个方法是否是方法重载，只与参数(类型、个数、顺序)有关，与返回值类型和修饰符无关。
  
• 方法重写
  方法重写就是对父类方法的内部逻辑进行重写，而不改变方法名和参数列表。方法的重写要遵循“两同两小一大”：
  • “两小”：指的是子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；
    ★如果方法的返回类型是 void 和基本数据类型，则重写时不可修改。但是如果方法的返回值是引用类型，重写时可以返回该引用类型的子类。
    
  • “一大”：指的是子类方法的访问权限应比父类方法的访问权限更大或相等。

• 6 种数字类型：
  • 4 种整数型：byte、short、int、long
  • 2 种浮点型：float、double
• 1 种字符类型：char
• 1 种布尔型：boolean

（1）默认值以及所占空间的大小

• 包装类型的默认值都是null；而基本类型有各自对应的默认值。
• 包装类型可用于泛型，而基本类型不可以。
• 包装类存放在堆内存；基本数据类型作为局部变量时，存放在栈内存；作为成员变量存放在堆内存。
          当对象new出来，是存在于堆的，对象的成员变量已经在堆上分配空间，但对象里面的方法是没有出现的，只有方法的声明，此时方法里面的局部变量并没有创建。等到对象调用此方法时，方法中的局部变量才会在栈中创建。所以，成员变量在堆内存，方法中的局部变量在栈内存。
  
• 相比于包装类， 基本数据类型占用的空间更小。

（3）★包装类的缓存机制了解么？

• 装箱：将基本类型用对应的引用类型(包装类)包装起来；
• 拆箱：将包装类型转换为基本数据类型。

  Integer i = 10;  //装箱
  int n = i;   //拆箱

为什么使用整型包装类时，推荐使用valueOf()方法，少使用parseXXX()方法？

• 子类可以继承父类所有的属性和方法，包括私有属性和私有方法，但是子类无法访问父类中的私有属性和方法（除了自己，谁都无法访问）。
• 子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。

• 对象类型和引用类型之间具有继承/实现的关系：Cat继承Animal；
• 引用类型变量发出的方法调用的到底是哪个类中的方法，必须在程序运行期间才能确定；
• 多态不能调用“只在子类存在但在父类不存在”的方法；
• 如果子类重写了父类的方法，真正执行的是子类覆盖的方法，如果子类没有覆盖父类的方法，执行的是父类的方法。

3.接口和抽象类

• 有一个父类Animal：
  
• Cat和Dog继承了Animal并重写了cry()，改写Animal的cry方法为抽象方法：
  
  

• 抽象类不能被实例化，要用多态的形式创建对象；
• 有抽象方法的类一定是抽象类，但是抽象类可以没有抽象方法；
• 子类必须重写抽象父类中所有的抽象方法（因为不重写就继承了，继承过来自己又成抽象类了）
  所以抽象类可以用抽象方法来限定子类必须做哪些事情。
  

• 共同点：
  • 都不能被实例化。
  • 都可以包含抽象方法。
  • Java 8之后，都可以有默认实现的方法（Java 8 可以用 default 关键字在接口中定义默认方法）。
• 区别：
  • 接口主要用于对类的行为进行约束，你实现了某个接口就具有了对应的行为。抽象类主要用于代码复用，强调的是所属关系。
  • 一个类只能继承一个抽象类，但是可以实现多个接口。
  • 接口中的成员变量只能是public static final类型的，不能被修改且必须有初始值，而抽象类的成员变量默认 default，可在子类中被重新定义，也可被重新赋值。

• 浅拷贝只会复制指向某个对象的指针，而不是复制对象本身，所以拷贝后的新对象实际上还是原来的旧对象（内存地址没变），因此对新对象的操作会影响旧对象。
• 深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会影响旧对象。

/**
 * native 方法，用于返回当前运行时对象的 Class 对象，使用了 final 关键字修饰，故不允许子类重写。
 */
public final native Class<?> getClass()
/**
 * native 方法，用于返回对象的哈希码，主要使用在哈希表中，比如 JDK 中的HashMap。
 */
public native int hashCode()
/**
 * 用于比较 2 个对象的内存地址是否相等，String 类对该方法进行了重写以用于比较字符串的值是否相等。
 */
public boolean equals(Object obj)
/**
 * naitive 方法，用于创建并返回当前对象的一份拷贝。
 */
protected native Object clone() throws CloneNotSupportedException
/**
 * 返回类的名字实例的哈希码的 16 进制的字符串。建议 Object 所有的子类都重写这个方法。
 */
public String toString()
/**
 * native 方法，并且不能重写。唤醒一个在此对象监视器上等待的线程(监视器相当于就是锁的概念)。如果有多个线程在等待只会任意唤醒一个。
 */
public final native void notify()
/**
 * native 方法，并且不能重写。跟 notify 一样，唯一的区别就是会唤醒在此对象监视器上等待的所有线程，而不是一个线程。
 */
public final native void notifyAll()
/**
 * native方法，并且不能重写。暂停线程的执行。注意：sleep 方法没有释放锁，而 wait 方法释放了锁 ，timeout 是等待时间。
 */
public final native void wait(long timeout) throws InterruptedException
/**
 * 多了 nanos 参数，这个参数表示额外时间（以毫微秒为单位，范围是 0-999999）。 所以超时的时间还需要加上 nanos 毫秒。。
 */
public final void wait(long timeout, int nanos) throws InterruptedException
/**
 * 跟之前的2个wait方法一样，只不过该方法一直等待，没有超时时间这个概念
 */
public final void wait() throws InterruptedException
/**
 * 实例被垃圾回收器回收的时候触发的操作
 */
protected void finalize() throws Throwable { }

（2）== 和 equals() 的区别？

• == 对于基本类型和引用类型的作用效果是不同的：
  • 对于基本数据类型来说，== 比较的是值；
  • 对于引用数据类型来说，== 比较的是对象的内存地址。
• equals() 不能用于判断基本数据类型的变量，只能用来判断两个对象是否相等。
  • 如果类没有重写equals()方法，使用就是Object的equals()方法。此时通过equals()比较该类的两个对象时，等价于 ==，比较的是内存地址。
  • 还可以重写equals()方法，比如重写equals()方法来比较两个对象中的属性是否相等。比如String中的equals()就是被重写过的，它用来比较字符串的值是否相等，即使二者是两个不同的对象，只要值相等，就会返回true。
    
    

（3）hashCode()有什么用？为什么要有hashCode()?

（4）为什么重写 equals() 时必须重写 hashCode() 方法？

• 可变性
  • String 是不可变的。
  • StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，它提供了很多修改字符串的方法，比如 append()。
• 线程安全性
  • String对象是不可变的，就可以理解为常量，是线程安全的。
  • StringBuffer 对 AbstractStringBuilder 中的方法加了同步锁，所以是线程安全的。
  • StringBuilder 并没有对方法加同步锁，所以是非线程安全的。
• 性能
  • 每次对 String 进行改变时，都会生成一个新的 String 对象。
  • StringBuffer 和 StringBuilder 每次都会对对象本身进行操作，而不是生成新的对象。StringBuilder 比 StringBuffer 性能要好一点，但有多线程不安全的风险。

• 数组被final和private修饰；
• 没有提供修改数组的方法；
• String被final修饰。

• 如果字符串常量池中不存在“abc”的引用，那么会在堆中创建 2 个字符串对象“abc”；
• 如果字符串常量池中已存在“abc”的引用，则只会在堆中创建 1 个字符串对象“abc”。
  

• 字符串变量使用+进行拼接时，实际上是调用了StringBuilder的append()和toSting()方法，最终会得到一个新的String对象(堆中)。所以String str4=str1+str2;等价于：

  String str4 = new StringBuilder().append(str1).append(str2).toString();

  
  
• 字符串常量(加了final)会被编译器当成常量处理，对其进行常量折叠优化，会将拼接结果放在常量池。
  常量折叠就是会把String c = "str" + "ing"优化成String c = "string"。
  
  

• Exception 是程序本身可以处理的异常，可以通过catch来捕获。Exception又可以分为 Checked Exception (受检查异常，必须处理) 和 Unchecked Exception (不受检查异常，可以不处理)。
• Error 属于程序无法处理的错误 ，不建议通过catch捕获 。例如 jvm运行错误（Virtual MachineError）、OOM、类定义错误（NoClassDefFoundError）等 。Error异常发生时，JVM一般会选择线程终止。

2.Checked Exception 和 Unchecked Exception 有什么区别？

• Checked Exception又叫受检查异常，在编译过程中，必须对受检查异常进行处理，不然不能通过编译。除了RuntimeException及其子类以外，其他的Exception类及其子类都属于受检查异常。常见的有IO 相关的异常、ClassNotFoundException、SQLException等。
• Unchecked Exception又叫不受检查异常 ，这些异常在写代码时不会报错，编译时也不会检查，只有在运行时才会报错。RuntimeException及其子类都统称为非受检查异常，所以非受检查异常又叫运行时异常，常见的有：
  • NullPointerException(空指针错误)
  • IllegalArgumentException(参数错误比如方法入参类型错误)
  • NumberFormatException（字符串转换为数字格式错误，IllegalArgumentException的子类）
  • ArrayIndexOutOfBoundsException（数组越界错误）
  • ClassCastException（类型转换错误）
  • ArithmeticException（算术错误）
  • SecurityException（安全错误比如权限不够）
  • UnsupportedOperationException(不支持的操作错误比如重复创建同一用户)

• String getMessage()：返回异常发生时的简要描述；
• String toString()：返回异常发生时的详细信息；
• String getLocalizedMessage()：可以用Throwable的子类重写这个方法来生成本地化信息。在没有重写时，该方法返回的信息与getMessage()相同。
• void printStackTrace()：在控制台上打印Throwable对象封装的异常信息。

4.try-catch-finally 如何使用？

• try用于捕获异常。可接零个或多个catch，如果没有catch，则必须跟一个finally。
• catch用于处理 try 捕获到的异常。
• finally：无论是否捕获或处理异常，finally块里的语句都会被执行。★当在try或catch中遇到return时，finally语句块将在方法返回前被执行。
          ★不要在 finally 语句块中使用 return。当 try 语句和 finally 语句中都有 return 时，try 语句块中的 return 语句会被忽略。这是因为 try 语句中的 return 返回值会先被暂存在一个本地变量中，当执行到 finally 语句中的 return 之后，这个本地变量的值就变为了 finally 语句中的 return 返回值。（其实还是上面的try遇到return就先执行finally）

5.finally 中的代码一定会执行吗？

七、泛型

2.泛型有哪些使用方式？

• 自定义接口的通用返回结果CommonResult<T>时，通过参数T可根据具体的返回类型动态指定结果的数据类型。
• 构建集合工具类（参考Collections中的sort,binarySearch方法）。

八、反射与注解 Annotation

• 在JDBC连接数据库时，先通过Class.forName()加载数据库驱动，这一步就是通过反射来完成的。
• 框架中的注解、xml文件的解析，解析出来的是字节码字符串，因此必须通过反射将字符串实例化成对象。

3.什么是注解？

• 编译期直接扫描：编译器在代码编译时会扫描注解并处理，比如某个方法使用@Override 注解，编译器在编译时就会检测是否进行了方法重写。
• 运行期通过反射处理：框架中自带的注解，比如 Spring 框架的 @Value 、@Component，都是通过反射来进行处理的。这些注解解析出来的是字节码字符串，必须通过反射将字符串实例化成对象。

2.SPI和API的区别？

• 当服务提供者实现了一个功能，并且定义了对应的接口，那么服务调用者就可以通过该接口来使用这个功能。这就是API，接口和实现都在服务提供方。
• 当接口放在服务调用者，由调用者定义接口的规则，然后不同的服务提供者根据接口规则对接口进行实现，从而提供服务，这就是SPI。

• 需要遍历加载所有的实现类，不能做到按需加载，效率相对较低。
• 当多个 ServiceLoader 同时 load 时，会有并发问题。

十、序列化与反序列化

• 序列化： 将对象转换成二进制字节流的过程。
• 反序列化：将在序列化过程中所生成的二进制字节流转换成对象的过程。

• 对象在进行网络传输（比如远程调用 RPC 的时候）之前，需要先被序列化，接收到序列化的对象后，还需要再进行反序列化；
• 将对象存储到文件之前需要进行序列化，将对象从文件中读取出来需要进行反序列化；
• 将对象存储到数据库（如 Redis）之前需要用到序列化，将对象从缓存数据库中读取出来需要反序列化；
• 将对象存储到内存之前需要进行序列化，从内存中读取出来之后需要进行反序列化。

3.序列化协议对应于 TCP/IP 4 层模型的哪一层？

4.★常见序列化协议有哪些？

• JDK 自带的序列化方式
  一般不推荐，序列化效率低并且存在安全问题。JDK 自带的序列化，只需实现 java.io.Serializable接口即可。
  
  serialVersionUID 是什么？有什么作用？
  ——serialVersionUID 是序列化号，是用来做版本控制的。反序列化时，会检查serialVersionUID是否和当前类的serialVersionUID一致。如果不一致，则会抛出 InvalidClassException 异常。
  【tips】强烈推荐每个序列化类都手动指定其serialVersionUID，如果不手动指定，那么编译器会动态生成默认的serialVersionUID。
  如果有些字段不想进行序列化怎么办？
  ——对于不想进行序列化的变量，可以用 transient 修饰。当然在反序列化时，被transient修饰的变量也不会被持久化和恢复。
  关于transient还有几点注意：
  • 只能修饰变量，不能修饰类和方法。
  • transient修饰的变量，在反序列化后变量值将会被置成类型的默认值。例如，如果是修饰int类型，那么反序列后结果就是0。
  • static变量因为属于类而不属于任何对象，所以无论有没有被transient修饰，都不会被序列化。

• JSON 和 XML 序列化方式
          这种属于文本类序列化方式。虽然可读性比较好，但是性能较差。
  

十一、IO流

• 内核等待 I/O 设备准备好数据；
• 内核将数据从内核空间拷贝到用户空间。

• InputStream/OutputStream：字节输入/输出流的超类；
• Reader/Writer：字符输入/输出流。

• FileInputStream 是 InputStream 的子类，可以直接指定文件路径，用来从文件中读取字节数据。
  【tips】一般不会单独使用 FileInputStream ，通常会配合 BufferedInputStream 字节缓冲输入流来使用。
  
  
• DataInputStream 用于读取指定类型数据，不能单独使用，必须结合 FileInputStream 。
  
• ObjectInputStream 用于从输入流中读取 Java 对象，是反序列化的过程。
  
  

• FileOutputStream 是最常用的字节输出流对象，可直接指定文件路径。
• DataOutputStream 用于写入指定类型数据，不能单独使用，必须结合 FileOutputStream。
• ObjectOutputStream 用于将对象写入到输出流，是序列化的过程。
  

• FileReader：可以直接操作字符文件。InputStreamReader 是字节流转换为字符流的桥梁，FileReader 就是它的子类。
  

• FileWriter

6.打印流

7.★Java IO中涉及到哪些设计模式？

8.Java IO模型

（1）有哪些常见的 IO 模型?

• BIO (Blocking I/O)
  BIO 属于同步阻塞 IO 模型，应用程序发起 read 调用后，会一直阻塞，直到内核把数据拷贝到用户空间。显然这种IO模型在面对高并发时并不适用。
  
  
• NIO (Non-blocking/New I/O)
  NIO 中的 N 可以理解为 Non-blocking，属于同步非阻塞IO模型，它是支持面向缓冲、基于通道的 I/O，适用于高负载、高并发的（网络）应用。
  在这种模型中，应用程序会反复发起 read 调用，但是等待数据从内核空间拷贝到用户空间的这段时间里，线程依然是阻塞的。通过反复调用read，避免了一直阻塞(没有完全避免阻塞)。
  但是不断进行read调用是十分消耗 CPU 资源的。这就用到了IO多路复用模型。
  
  IO 多路复用模型中，线程会先发起 select 调用，询问内核数据是否准备就绪，准备就绪后线程再发起 read 调用。不过数据从内核空间拷贝到用户空间还是阻塞的。IO 多路复用模型通过减少无效的系统调用，减少了对 CPU 资源的消耗。
• AIO (Asynchronous I/O)
  AIO属于异步IO模型，基于事件和回调机制，也就是说在调用read后会直接返回，不会一直阻塞在那里，当后台处理完成后，操作系统会通知相应的线程继续进行后续的操作。
  
  

9.★什么是IO多路复用？select、poll、epoll之间的区别？

• 通过调用epoll_create()来创建一个fd对象；
• epoll_ctl()会在每新建一个连接的时候，更新fd的信息，并绑定一个回调函数；
• epoll_wait()会轮询所有的回调函数集合，根据事件触发io操作。

• 如果泛型没有限制，如<T>，那么就用Object替换；
• 如果泛型有限制，如<T extends Comparable>，那么就用Comparable替换。

• 自动装箱是基本数据类型转成对应的包装类，通过调用 valueOf 方法实现：
  
• 自动拆箱是包装类转成基本数据类型，通过调用 xxxValue 方法实现：
  
  

• 创建一个枚举：
  
• 当我们使用enum来定义一个枚举类型的时候，编译器会自动帮我们创建一个final类型的类继承Enum类，所以枚举类型不能被继承。
  
  

• 所有实现了 java.lang.AutoCloseable 接口的都可以作为资源，把资源对象声明在try的()里，在try结束后，close方法会被自动调用，关闭资源；
• 在 try 语句中越是最后使用的资源，越是最早被关闭；
• 不管是否出现异常，资源都会被调用close方法。

• 在之前的try-catch-finally，假设try和finally中的close()都可能发生异常：
  • try 中没有发生异常时，直接调用finally块，这时如果 close 发生异常，就处理close的异常；
  • try 中发生了异常，就会被 catch 捕捉，进行异常处理，然后调用 finally 块，如果 close 发生异常，就进行close的异常处理。
• 在try-with-resource中，假设try和自动调用close()时都可能发生异常：
• try 没有发生异常时，然后自动调用 close 方法，如果调用close时发生异常，会被 catch 捕捉并处理该异常；
• try 发生了异常，然后自动调用 close 方法，如果 close 也发生异常，catch 只会捕捉 try 抛出的异常。
  【tips】无论是否发生异常，try完了都先调用close()。

• 当泛型遇到方法重载
  
  在上面的方法重载中，虽然二者参数类型不同，一个是List<String>，另一个是List<Integer>，但是这段代码是编译通不过的，因为在编译时会进行类型擦除，这两个参数的类型都会变成List，就不符合方法重载的条件了。
• 当泛型遇到catch
  泛型的类型参数不能用在 catch 中。因为异常处理是由 JVM 在运行时刻进行的，由于类型信息被擦除，JVM 会无法区分异常类型的。
• 当泛型内包含静态变量
  
  以上代码输出结果为：2！由于经过类型擦除，所有的泛型类实例都关联到同一份字节码上，因此泛型类的所有静态变量是共享的。
  

十三、Java 代理模式

（2）静态代理实现步骤

• 定义一个接口及其实现类；
• 创建一个代理类同样实现这个接口；
• 将目标对象注入代理类，然后在代理类的对应方法调用目标类中的对应方法。

• 定义一个发送短信的接口
  
  
• 实现该接口
  
• 创建代理类并同样实现该接口
  
  
• 将目标对象注入代理类，然后在代理类的对应方法调用目标类中的对应方法
  
  
• 使用代理对象来代理访问发送短信接口的实现类
  
  
• 执行结果
  
  

• Proxy类中使用频率最高的方法是：newProxyInstance()，这个方法主要用来生成一个代理对象。注意三个参数！
  
  
• 要实现动态代理的话，还必须实现InvocationHandler来自定义处理逻辑。当我们的动态代理对象调用一个方法时，这个方法的调用就会被转发到InvocationHandler接口的invoke()来调用。
  
  invoke() 方法有下面三个参数：
  
  • proxy :动态生成的代理类
  • method : 与代理类对象调用的方法相对应
  • args : 当前 method 方法的参数

（3）CGLIB 动态代理机制

        2）CGLIB 动态代理类使用步骤

• 引入依赖：不同于 JDK 动态代理不需要额外的依赖。CGLIB实际是属于一个开源项目，需要手动添加相关依赖。
  
  
• 定义一个类（不用其实现类！）；
• 自定义MethodInterceptor并重写intercept方法，intercept用于拦截增强被代理类的方法，和 JDK 动态代理中的invoke方法类似；
• 通过Enhancer类的create()创建代理类；

• 实现一个使用阿里云发送短信的类
  
• 自定义 MethodInterceptor
  
• 获取代理类
  
  
• 实际使用及执行结果
  
  

• JDK 动态代理只能代理实现了接口的类或者直接代理接口，而 CGLIB 可以代理未实现任何接口的类。 另外，CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。
• 就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。

3.静态代理和动态代理的对比

• 灵活性 ：动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类；静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，这是非常麻烦的！
• JVM 层面 ：静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件；而动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。

十四、★Java 集合

1.Java 集合概述

（1）集合体系结构

        

（2）List, Set, Queue, Map 四者的区别？

• List存储的元素是有序的、可重复的，这里的有序指的是存进去和取出来的顺序是一致的，不是说list里面一定是升序或者降序排列。
• Set存储的元素是无序的、不可重复的。
• Queue存储的元素是有序的、可重复的，遵循先进先出的原则。
• Map使用键值对存储元素，key 是唯一的，value 是无序的、可重复的，每个键最多映射到一个值。

2.集合框架底层数据结构总结

（1）List

• ArrayList：Object[]数组
• Vector：Object[]数组
• LinkedList：双向链表(JDK1.6 之前为循环链表，JDK1.7 取消了循环)

（2）Set

• HashSet(无序，唯一)：基于HashMap实现的，底层采用HashMap来保存元素
• LinkedHashSet：LinkedHashSet是HashSet的子类，并且其内部是通过LinkedHashMap来实现的。有点类似于我们之前说的LinkedHashMap其内部是基于HashMap实现一样，不过还是有一点点区别的
• TreeSet(有序，唯一)：红黑树(自平衡的排序二叉树)

（3）Queue

• PriorityQueue(优先级队列)：Object[]数组来实现二叉堆
• ArrayQueue：Object[]数组 + 双指针

（4）Map

• HashMap：
          JDK1.8 之前HashMap由数组+链表组成的，数组是HashMap的主体，链表主要是为了解决哈希冲突。
          JDK1.8 以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）时，会将链表转化为红黑树，转换前会判断，如果当前数组的长度小于 64，那么会选择先进行数组扩容，而不是转换为红黑树，以减少搜索时间。
• LinkedHashMap：LinkedHashMap继承自HashMap，所以它的底层仍然是基于拉链式散列结构即由数组和链表或红黑树组成。另外，LinkedHashMap在上面结构的基础上，增加了一条双向链表，使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的操作，实现了访问顺序相关逻辑。
• Hashtable：数组+链表组成的，数组是Hashtable的主体，链表则是主要为了解决哈希冲突而存在的
• TreeMap：红黑树（自平衡的排序二叉树）

3.List集合

（2）ArrayList 与 LinkedList 区别?

• 线程安全： ArrayList和LinkedList都是不保证线程安全的；
• 底层数据结构： ArrayList使用的是数组；LinkedList使用的是 双向链表；
• 插入和删除、访问元素（数组和链表的区别）：
  • ArrayList采用数组存储，在插入和删除元素时需要移动元素，因此不适合频繁插入和删除元素，但是适合根据序号快速获取元素(get()方法)；
  • LinkedList采用链表存储，插入和删除元素比较方便，但是不支持随机访问元素。但是 LinkedList 仅仅在头尾插入或者删除元素的时候时间复杂度近似 O(1)，其他情况增删元素的时间复杂度都是 O(n) 。不要认为LinkedList就一定最适合元素增删的场景。
• 内存空间占用：ArrayList的空间浪费主要体现在在 list 列表的结尾会预留一定的容量空间，而 LinkedList 的每一个元素都需要消耗比 ArrayList 更多的空间，因为LinkedList底层实现是双向链表，要额外存放直接后继和直接前驱。

（3）RandomAccess 接口

• 通过无参构造用默认容量10初始化一个空列表。当真正向列表中添加第一个元素时，容量才会扩为 10。
  
  
• 通过带参构造传入一个指定容量：
  
  
• 通过带参构造传入一个集合：
  
  

• 我们以使用无参构造初始化的列表为例，它的默认容量大小为10。
• 当我们调用add()方法添加元素时，会先调用ensureCapacityInternal()方法得到最小扩容量(minCapacity)，它会先判断是不是空列表，如果是空列表，会比较minCapacity与默认容量10的大小，然后取大的作为minCapacity，然后再调用ensureExplicitCapacity()方法；如果不是空列表的话，会直接调用ensureExplicitCapacity()方法。
  
  
• 调用ensureExplicitCapacity()方法，通过比较minCapacity是否大于列表长度，来判断需不需要扩容，需要扩容的话就会调用grow()方法进行扩容。
  
  
• grow()方法的扩容机制是先扩容为原来列表长度的1.5倍，如果还是不能满足最小扩容量，就直接扩容到最小扩容量。如果扩容后的容量大于MAX_ARRAY_SIZE(最大数组容量)，就会调用hugeCapacity()方法。
  
  
• 在hugeCapacity()方法中，会判断 minCapacity 与 MAX_ARRAY_SIZE的大小，如果minCapacity大于最大数组容量，那么扩容后的容量则为Integer.MAX_VALUE；否则，扩容后的容量为 MAX_ARRAY_SIZE( 即为 Integer.MAX_VALUE - 8)。
  【tips】因为数组需要8bytes去存储它自己的大小。
  
  

• 使用Comparator比较器对arrayList进行降序排序：
  

（2）比较 HashSet、LinkedHashSet 和 TreeSet 三者的异同

• 三者都是Set的实现类，都能保证元素唯一，且都不是线程安全的；
• HashSet、LinkedHashSet和TreeSet的主要区别在于底层数据结构不同：
  • HashSet的底层数据结构是哈希表（基于HashMap实现）。
  • LinkedHashSet的底层数据结构是链表和哈希表，元素的插入和取出顺序满足 FIFO。
  • TreeSet底层数据结构是红黑树，元素是有序的，排序的方式有自然排序和定制排序。
• 底层数据结构不同又导致这三者的应用场景不同：
  • HashSet用于不需要保证元素插入和取出顺序的场景；
  • LinkedHashSet用于保证元素的插入和取出顺序满足 FIFO 的场景；
  • TreeSet用于支持对元素自定义排序规则的场景。

5.Queue

• Queue 是单向队列，继承了Collection接口，对失败的处理方式有两种，一种在操作失败后会抛出异常，另一种则会返回特殊值。
  

• Deque 是双向队列，在队列的两端均可以插入或删除元素。Deque 继承了 Queue 的接口, 增加了在队首和队尾进行插入和删除的方法，同样根据失败后处理方式的不同分为两类：
  
  Deque 还提供了 push() 和 pop() 等其他方法，可用于模拟栈。

• ArrayDeque是底层是用数组和双指针来实现的，而LinkedList是用链表来实现。

• ArrayDeque不支持存储NULL，但LinkedList支持。

• ArrayDeque插入时可能存在扩容过程（可变数组）, 不过均摊后的插入操作依然为 O(1)。虽然LinkedList不需要扩容，但是每次插入数据时均需要申请新的堆空间，均摊性能相比更慢。

• PriorityQueue利用了二叉堆的数据结构来实现的，底层使用可变长的数组来存储数据
• PriorityQueue通过堆元素的上浮和下沉，实现了在 O(logn) 的时间复杂度内插入元素和删除堆顶元素。
• PriorityQueue是非线程安全的，且不支持存储NULL。
• PriorityQueue默认是小顶堆，但可以接收一个Comparator作为构造参数，从而来自定义元素优先级的先后。

6.Map

• 线程是否安全： HashMap是非线程安全的，Hashtable是线程安全的，因为Hashtable内部的方法基本都经过synchronized修饰。（如果你要保证线程安全的话就使用ConcurrentHashMap）
• 效率： 因为线程安全的问题，HashMap要比Hashtable效率高一点。另外，Hashtable基本被淘汰，不要在代码中使用它；
• 对 Null key 和 Null value 的支持： HashMap可以存储 null 的 key 和 value，但 null 作为键只能有一个，null 作为值可以有多个；Hashtable 不允许有 null 键和 null 值，否则会抛出NullPointerException。
• 初始容量大小和每次扩充容量大小的不同 ：
  • 创建时不指定容量初始值，Hashtable默认大小为 11，之后每次扩充容量变为原来的 2n+1。HashMap默认大小为 16，之后每次扩充容量变为原来的 2 倍。
  • 创建时指定了容量初始值，Hashtable会直接用指定的大小，而HashMap会将其扩充为 2 的幂次方大小，也就是说HashMap总是使用 2 的幂作为哈希表的大小。
    下面这个方法保证了 HashMap 总是使用 2 的幂作为哈希表的大小：
    
    
• 底层数据结构：JDK1.8 以后的HashMap在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8）时，将链表转化为红黑树，同时转化前会判断，如果当前数组的长度小于 64，那么会先扩容数组。Hashtable没有这样的机制。

（2）HashMap 和 TreeMap 区别

• 在 JDK1.8 之前，HashMap底层用的是 数组+链表。通过哈希计算得到key的hash值从而确定元素的位置，如果当前位置已经有元素了，也就是说发生了哈希冲突，就判断两个元素的 hash 值以及 key 是否相同，如果相同的话，直接覆盖，不相同就通过拉链法解决冲突。
  
• 在 JDK1.8 之后，在解决哈希冲突时有了一点变化。当链表长度大于阈值（默认为 8）时，需要对链表进行转换：如果当前数组的长度小于 64，会先扩容数组；反之会将链表转化为红黑树。
  
  

（4）HashMap 的长度为什么是 2 的幂次方？

• 使用迭代器进行遍历：对HashMap来说，可以分别获取EntrySet(所有的键值对集合)和KeySet(所有的key集合)进行遍历。
  
  • 使用 EntrySet 遍历：
    
  • 使用 KeySet 遍历：
    
• 使用 for each 进行遍历，也是通过EntrySet和KeySet进行遍历：
  • for each+EntrySet：
    
    
  • for each+KeySet：
    
    
• 直接使用map.forEach()进行遍历：
  
  
• 使用Stream流进行遍历，可分为单线程遍历和多线程遍历：
  • Stream单线程遍历：
    
  • Stream多线程遍历：
    
    

• 性能上：用 EntrySet 遍历比用 KeySet 的性能高。因为 KeySet 在循环时需要用 map.get(key) 来获取key，相当于再遍历一次Map集合，而EntrySet把key放到了对象里，可以直接从对象中获取key，因此KeySet相当于比 EntrySet 多遍历了一遍 Map 集合。
• 安全性上：不能在遍历中使用 map.remove() 来删除数据，这是非安全的操作方式，但我们可以使用迭代器的 iterator.remove() 的方法来删除数据，这才是安全的删除集合的方式。同样的我们也可以使用 Lambda 中的 removeIf 来提前删除数据，或者是使用 Stream 中的 filter 过滤掉要删除的数据进行循环，这样都是安全的，当然我们也可以在 for 循环前删除数据在遍历也是线程安全的。
  综上所述，推荐使用 迭代器+EntrySet 来进行HashMap的遍历。

• 底层数据结构：
  • ConcurrentHashMap：
    • JDK1.8 以前，ConcurrentHashMap底层用 Segment数组和HashEntry数组 来实现，Segment 的个数一但初始化就不能改变，Segment数组中的每个元素包含一个HashEntry数组，每个HashEntry数组属于链表结构。
      
    • JDK1.8 采用的是 数组+链表/红黑树，当链表达到一定长度时，会转成红黑树。
      
  • Hashtable和 JDK1.8 之前的HashMap一样，都是采用 数组+链表 的形式。
            
• ★实现线程安全的方式：
  • ConcurrentHashMap：
    • JDK1.8 以前，ConcurrentHashMap 对数组进行了分段（Segment数组），然后给每一段数据上一把锁（可重入锁），这样当一个线程占用锁访问其中一段数据时，其他段的数据也能被其他线程访问，提高并发访问率。
    • JDK1.8 以后，ConcurrentHashMap 采用 Node + CAS + synchronized 来实现线程安全，并发控制使用synchronized和 CAS 来操作，synchronized 只锁定当前链表或红黑树的首节点，这样锁的粒度更细，只要 hash 不冲突，就不会产生并发，就不会影响其他 Node 的读写，效率大幅提升。
  • Hashtable(同一把锁) ：使用 synchronized 来保证线程安全，当一个线程访问同步方法时，其他线程再访问该方法，就会阻塞，因此效率比较低。比如使用 put 添加元素时，另一个线程既不能put，也不能get，竞争会越来越激烈。

（9）JDK 1.7 和 JDK 1.8 的 ConcurrentHashMap 实现有什么不同？

• 底层数据结构：
          JDK1.7的ConcurrentHashMap底层用 Segment数组和HashEntry数组 来实现，Segment 的个数一但初始化就不能改变，Segment数组中的每个元素包含一个HashEntry数组，每个HashEntry数组属于链表结构。
          JDK1.8的ConcurrentHashMap采用的是 数组+链表/红黑树，当链表达到一定长度时，会转成红黑树。
  
• 线程安全的实现方式 ：
          JDK1.7 采用分段锁来保证安全，Segment是继承自ReentrantLock(自旋锁)。
          JDK1.8 采用Node + CAS + synchronized来保证线程安全，synchronized只锁定当前链表或红黑二叉树的首节点，锁粒度更细。
• 哈希冲突的解决：
          JDK 1.7 采用拉链法
          JDK1.8 采用拉链法+红黑树，即链表长度超过一定阈值时，将链表转换为红黑树。
• ★并发度：
          JDK 1.7 最大并发度是 Segment 的个数，默认是 16。
          JDK 1.8 最大并发度是 Node 数组的大小，并发度更大。

（10）HashMap的扩容机制？

        在jdk1.8以后，HashMap底层是由数组+链表和红黑树来实现的，当添加元素后，数组长度超过了一个临界值，也就是原数组长度(默认16)×负载因子(默认0.75)，就会扩容为原数组的两倍。还有一种扩容情况就是当某个链表长度大于8了，并且数组长度没有超过64，数组也会扩容为原来的两倍；如果链表超过8数组也超过64，那么这个链表就会转换成红黑树。

十五、★Java并发

1.线程相关知识

（1）线程的生命周期/6大状态

• NEW：初始状态，线程刚被创建出来但没有被start()；
• RUNNABLE：运行状态，线程被调用了start()等待运行的状态。
      线程创建后将处于 NEW状态，调用start()方法后处于 READY状态，此时线程需要获得 CPU 时间片才能真正RUNNING。
• BLOCKED：阻塞状态，需要等待锁的释放。
• WAITING：等待状态，线程需要等待其他线程的通知或中断。
• TIME_WAITING：超时等待状态，可以在指超时时间后自行返回而不是像 WAITING 那样一直等待。
• TERMINATED：终止状态，线程已经运行完毕。

（2）★sleep() 方法和 wait() 方法的比较

• 共同点 ：二者都可以暂停线程的执行。
• 区别 ：
  • sleep()是Thread类的静态本地方法，wait()是Object类的本地方法；
    
    
    
  • sleep()方法没有释放锁，而wait()方法释放了锁；
  • 如果不指定超时时间(timeout)，wait()方法被调用后，线程不会自动苏醒，需要其他线程调用notify()或者notifyAll()方法，所以一般用来实现线程交互；sleep()方法执行完成后，线程会自动苏醒，一般用来暂停线程的执行。

（3）为什么 wait() 方法不定义在 Thread 中而在 Object 中？

（4）可以直接调用 Thread 类的 run 方法吗？

• 规范线程与内存的关系：JMM给每个线程都抽象了线程私有的本地内存，线程之间的共享数据必须存储在主存中，线程将共享数据拷贝到本地内存进行操作，而不是直接读写主存。
• 定义并发编程时的规范：提供了并发相关的一些关键字和类，比如 volatile、synchronized、各种 Lock等。
  

• JVM的内存区域定义了JVM在运行时如何分区保存数据，比如在堆中存放实例对象；
• JMM与Java的并发编程有关，抽象了线程和主存之间的关系，规定了从 Java 源代码到 CPU 可执行指令的过程要遵守的并发规范，其主要目的是为了简化多线程编程。

（3）并发编程的三个重要特性

• 原子性：一组操作要么全执行，要么全不执行。可以借助synchronized 、各种 Lock 以及各种原子类实现原子性。
• 可见性：当一个线程对共享变量进行了修改，那么其他线程应该立即能看到修改后的最新值。可以借助synchronized 、volatile 以及各种 Lock 实现可见性。
• 有序性：由于指令重排序问题，代码的执行顺序未必就是编写代码时候的顺序。指令重排序可以保证串行语义一致，但是在多线程下，指令重排序可能会导致一些问题。volatile 可以禁止指令进行重排序优化。

（3）★双重检验锁方式实现单例模式

1. 为uniqueInstance分配内存空间
2. 初始化uniqueInstance
3. 将uniqueInstance指向分配的内存地址

• 乐观锁是认为每次访问共享资源不会出现问题，无需加锁也无需等待，只在提交时才验证共享资源是否被其他线程修改了（版本号机制或CAS算法）。
  乐观锁适用于读多写少，可以避免频繁加锁带来的性能损耗。
• 悲观锁是认为只要访问共享资源就会出现问题，因此在每次访问共享资源时都会加锁，一旦某个线程加了锁正在访问该资源，其他线程想要访问该资源就会阻塞，直到该线程释放锁。像synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。
  悲观锁适用于写多读少，避免频繁失败和重试影响性能。
  

• 版本号机制：一般是在数据表中加上一个版本号字段version。当数据更新成功时，version会加一。当线程 A 要更新数据值时，会拿到更新前的version，更新完提交时，先检查此时的version跟刚才拿到的相不相等，相等时才更新，然后把version+1，否则重试更新操作，直到更新成功。
• CAS算法：CAS 的全称是 Compare And Swap(比较与交换)，就是用一个预期值和要更新的变量值进行比较，两值相等才会进行更新。CAS 是一个原子操作，涉及到三个操作数：
  • V ：要更新的变量值(Var)
  • E ：预期值(Expected)
  • N ：拟写入的新值(New)
  只有当 V == E(比较) 时(说明没有其他线程更新 V)，才能通过原子方式用 N 来更新 V(更新)；如果不等，说明已经有其它线程更新了 V，则当前线程放弃更新。当多个线程同时使用 CAS 操作一个变量时，只有一个会更新成功，其余均会失败，失败的线程不会被挂起，既可以再次尝试更新(自旋重试)，也可以放弃更新操作。

• ABA问题
  ABA问题就是一个线程在开始读到变量值是A，然后在修改后发现变量还是A，就认为该变量一定没有被修改，但其实可能是这期间被其他线程修改了，然后又改回了A。
  ABA问题的解决思路就是在变量前加上一个标志，一般是版本号或者时间戳。比如AtomicStampedReference类就是用来解决 ABA 问题的，其中的compareAndSet()方法就是检查当前引用是否等于预期引用，并且判断当前标志是否等于预期标志，如果都相等，才认为这期间没有被其他线程修改，再进行更新操作。
  
  
• 循环时间长、开销大
  CAS 经常会用到自旋操作来进行重试，直到成功为止。如果长时间不成功，就会给 CPU 带来比较大的开销。
  
• 只能保证一个共享资源的原子性
  CAS 只对单个共享变量有效。
  Java 提供了 AtomicReference 类来保证引用对象间的原子性，可以用锁或者AtomicReference类把多个共享变量合并成一个共享变量来操作，就可以解决这个问题了。
  

• 修饰实例方法，锁的是当前实例对象
  
  
• 修饰静态方法，锁的是当前类
  给当前类加锁，会作用于该类所有的实例对象 ，进入同步代码前要获得 当前 class 的锁。
  
  【静态 synchronized 方法和非静态 synchronized 方法之间的调用互斥么？】
  ——不互斥。如果线程A调用了一个实例的非静态同步方法，而线程B想要调用该实例所在类的静态同步方法，这是允许的，不会发生互斥，因为访问静态同步方法占用的是当前类的锁，访问非静态同步方法占用的是当前实例对象的锁。
• 修饰代码块，锁的是指定对象或类
  修饰代码块是对括号里的对象或类加锁：
  • synchronized(object) 表示进入同步代码库前要获得 给定对象的锁
  • synchronized(类.class) 表示进入同步代码前要获得 给定 Class 的锁
    
    

• volatile是一种轻量级的线程同步实现方式，所以在性能上，volatile要比synchronized好。但是volatile只能修饰变量，而synchronized可以修饰方法以及代码块；
• volatile能保证数据的可见性，但不能保证原子性，因此volatile主要用于解决变量在多线程间的可见性；而synchronized两者都能保证，解决的是多线程之间访问共享资源的同步性。

6.ReentrantLock

• 公平锁：公平锁是先申请的线程可以先得到锁。
          性能较差一些，因为公平锁为了保证时间上的绝对顺序，上下文切换更频繁。
• 非公平锁：非公平锁是后申请的线程可能会先获取到锁，是随机或者按照其他优先级排序的。
          性能更好，但可能会导致某些线程永远无法获取到锁。

（3）★synchronized 和 ReentrantLock 有什么区别？

• synchronized 是 JVM 层面的，而 ReentrantLock 是 API 层面的。
      synchronized在同步代码块时是通过jvm的两个指令——monitorenter和monitorexit实现的，在同步方法时是通过acc_synchronized标识实现的；
      ReentrantLock是API 层面的，是基于AQS实现的，需要 lock() 和 unlock() 方法配合 try-finally 语句块来完成。
• ★ReentrantLock 比 synchronized 增加了一些功能，主要来说主要有三点：
  • 等待可中断：ReentrantLock可以通过调用lockInterruptibly()来中断等待锁的线程，让正在等待锁的线程放弃等待，改为处理其他事情；而synchronized获取不到锁会一直阻塞等待直到获取到锁；
    
  • 可实现公平锁：ReentrantLock可以指定是公平锁还是非公平锁；而synchronized只能是非公平锁；
  • ★可实现选择性通知：synchronized与wait()和notify()/notifyAll()方法相结合，可以实现等待/通知机制，但是只要调用notifyAll()会通知所有等待中的线程。ReentrantLock类借助Condition接口，可以创建多个Condition，可以有选择地将线程注册到指定的Condition中，实现选择性通知，在调用signalAll()时，只会唤醒注册在该Condition中的等待线程。
• 在资源竞争不是很激烈的情况下，synchronized的性能要优于ReetrantLock，但是在资源竞争很激烈的情况下，synchronized的性能会下降几十倍，而ReetrantLock的性能能维持常态。

【AQS的资源共享方式】

【★信号量Semaphore 的原理是什么？】

        Semaphore是一种共享锁，它是基于AQS实现的。它默认的 AQS 的state值为permits，当调用acquire()方法获取信号量时，如果state >= 0的话，就表示可以获取成功，然后用 CAS 操作(保证原子性)去对stat-1；如果state<0的话，则表示信号量数量不足，此时会创建一个 Node 节点加入CLH阻塞队列，挂起当前线程。在调用release()释放信号量时，会用 CAS 操作去给state+1，同时会唤醒队列中的一个线程，被唤醒的线程会重新尝试去获取信号量。
        

（5）★CountDownLatch和CyclicBarrier的区别？

7.★ThreadLocal

（1）ThreadLocal 有什么用？

• 强引用
  我们平时声明变量使用的就是强引用，比如String s=＂Hello World＂。强引用可以直接访问目标对象，所指向的对象在任何时候都不会被系统回收，JVM宁愿抛出OOM也不会回收强引用所指向的对象，因此强引用可能导致内存泄漏。
  
• 弱引用
  java中使用WeakReference来表示弱引用。如果某个对象与弱引用关联，那么当JVM在进行垃圾回收时，无论内存是否充足，都会回收弱引用对象。
  
• 软引用
  java中使用SoftRefence来表示软引用。软引用是除了强引用外最强的引用类型。一个持有软引用的对象，它不会被JVM很快回收，JVM会根据当前堆的使用情况来判断何时回收。
  
• 虚引用
  java中使用PhantomReference来表示虚引用。JVM不负责清理虚引用，但是会把虚引用放到引用队列里面。虚引用的主要目的是在一个对象所占的内存被实际回收之前得到通知，从而可以进行一些相关的清理工作。

• 降低资源消耗。通过重用已创建的线程降低线程创建和销毁造成的消耗。
• 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
• 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

（2）如何创建线程池？

• 方法一：通过ThreadPoolExecutor构造函数来创建（推荐）。
  
  
• 方法二：通过 Executor 框架的工具类 Executors 来创建。
  使用Executors可以创建多种类型的ThreadPoolExecutor，比如FixedThreadPool、SingleThreadExecutor、CachedThreadPool、ScheduledThreadPool。

• corePoolSize：核心线程数。核心线程是指任务队列不满时，可以同时运行的最大线程数量。
• maximumPoolSize：最大线程数。最大线程数指的是当任务队列满了，可以同时运行的最大线程数量。
• workQueue：任务队列。如果新任务到来时没有核心线程了，新任务就会被放进任务队列。
• keepAliveTime：空闲线程最大存活时间。非核心线程空闲时不会立即销毁，而是会等待，直到等待的时间超过了keepAliveTime才会被回收销毁。
• unit：最大存活时间的时间单位。
• threadFactory：线程工厂。创建新线程的时候会用到。
• handler：拒绝策略。当新任务不能被线程及时处理时，可以通过不同的拒绝策略来处理这些任务。

（5）线程池有哪些拒绝策略？

• 方法一：利用 guava 的 ThreadFactoryBuilder 命名：

  //通过ThreadFactoryBuilder创建一个线程工厂，并给线程池命名
  ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat(threadNamePrefix + "-%d").setDaemon(true).build();
  //使用创建的线程工厂自定义线程池
  ExecutorService threadPool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.MINUTES, workQueue, threadFactory);

• 方法二：自己实现一个 ThreadFactor：
  
  

• 对于 CPU 密集型任务，消耗的主要是 CPU 资源，可以将线程数设置为 CPU 核心数+1。+1是如果任务由于各种原因暂停了，CPU 就会处于空闲状态，这时多出来这一个线程就可以充分利用 CPU 的空闲时间了。
• 对于 I/O 密集型任务(网络读取，文件读取)，系统大部分时间都会来处理 I/O 交互，而线程在处理 I/O 这段时间不会占用 CPU ，这时就可以将 CPU 让给其它线程。因此在 I/O 密集型任务的应用中，我们可以相对多配置一些线程，一般来说可以配置为2倍的CPU核数。

（10）线程池被创建后里面有线程吗？如果没有的话，你知道有什么方法对线程池进行预热吗？

• 启动全部coreThread——prestartAllCoreThread()
  
• 只启动一个coreThread——prestartCoreThread()