JAVA常见面试题

一、Java 基础

1.JDK 和 JRE 有什么区别？

JRE是Java的运行环境

JDK是Java开发工具包

区别：

JRE主要包含：java类库的class文件(都在lib目录下打包成了jar)和虚拟机(jvm.dll)；JDK主要包含：java类库的 class文件(都在lib目录下打包成了jar)并自带一个JRE。

2.== 和 equals 的区别是什么？

== 是java提供的等于比较运算符,用来比较两个变量指向的内存地址是否相同.而equals()是Object提供的一个方法.Object中equals()方法的默认实现就是返回两个对象==的比较结果.但是equals()可以被重写,所以我们在具体使用的时候需要关注equals()方法有没有被重写.

3.两个对象的 hashCode()相同，则 equals()也一定为 true，对吗？

两个对象的hashCode()相同，equals()不一定为true；

两个对象的equals为true，则两个对象的hashcode一定为true；

4.final 在 java 中有什么作用？

(1)修饰类：表示该类不能被继承；

(2)修饰方法：表示方法不能被重写；

(3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。

5.java 中的 Math.round(-1.5) 等于多少？

6.String 属于基础的数据类型吗？

不属于。

7.java 中操作字符串都有哪些类？它们之间有什么区别？

String,StringBuffer和StringBuilder.

8.String str="i"与 String str=new String(“i”)一样吗？

不一样，使用String str=“i”，java虚拟机会把它分配到常量池中，而 String str=new String(“i”)创建了一个对象，会被分到堆内存中。

9.如何将字符串反转？

1,利用字符串的拼接(charAt()方法),把后遍历出来的放在前面即可实现反转

2,利用字符串的拼接(toCharArray()处理成字符数组的方法),把后遍历出来的放在前面即可实现反转

3,利用StringBuffer的reverse()方法

4,利用递归的方法,类似与二分查找的折半思想

10.String 类的常用方法都有那些？

11.抽象类必须要有抽象方法吗？

12.普通类和抽象类有哪些区别？

1. 抽象类不能被实例化

2. 抽象类可以有抽象方法，抽象方法只需申明，无需实现

3. 含有抽象方法的类必须申明为抽象类

4. 抽象的子类必须实现抽象类中所有抽象方法，否则这个子类也是抽象类

5. 抽象方法不能被声明为静态

6. 抽象方法不能用private修饰

7. 抽象方法不能用final修饰

13.抽象类能使用 final 修饰吗？

不能，抽象类是被用于继承的，final修饰代表不可修改、不可继承的。

14.接口和抽象类有什么区别？

1.抽象类可以提供成员方法的实现细节，而接口中只能存在抽象方法（默认 public abstract）

2.抽象类中的成员变量可以是多种类型，而接口中的成员变量必须用public static final(常量)修饰

3.一个类只能继承一个抽象类（单继承），但可以实现多个接口（多继承）。 4.抽象类中允许含有静态代码块和静态方法，而接口类不能。

15.java 中 IO 流分为几种？

（1）按流向分类： 输入流 输出流 （2）按处理数据不同分类： 字节流：二进制，可以处理一切文件，包括：纯文本、doc、音频、视频等。 字符流：文本文件，只能处理纯文本。 （3）按功能不同分类： 节点流：包裹源头。 处理流：增强功能，提高性能。

16.BIO、NIO、AIO 有什么区别？

BIO是一个连接一个线程。

*NIO是一个请求一个线程。*

*AIO是一个有效请求一个线程。*

17.Files的常用方法都有哪些？

二、容器

18.java 容器都有哪些？

同步容器 Vector Stack HashTable Collections.synchronized方法生成 并发容器 ConcurrentHashMap：线程安全的HashMap的实现 CopyOnWriteArrayList：线程安全且在读操作时无锁的ArrayList CopyOnWriteArraySet：基于CopyOnWriteArrayList，不添加重复元素 ArrayBlockingQueue：基于数组、先进先出、线程安全，可实现指定时间的阻塞读写，并且容量可以限制 LinkedBlockingQueue：基于链表实现，读写各用一把锁，在高并发读写操作都多的情况下，性能优于ArrayBlockingQueue

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。JavaSDK不提供直接继承自Collection的类，JavaSDK提供的类都是继承自Collection的“子接口”如List和Set。

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。 　　 实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。 　　 注意:LinkedList是非同步的。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：

ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。 　　 和LinkedList一样，ArrayList也是非同步的（unsynchronized）。一般情况下使用这两个就可以了，因为非同步，所以效率比较高。 　　 如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。

Vector非常类似ArrayList，但是Vector是同步的。

（1）vector所谓的多线程安全，只是针对单纯地调用某个方法它是有同步机制的。

（2）vector的多线程安全，在组合操作时不是线程安全的。

Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有 peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。 　　Set容器类主要有HashSet和TreeSet等。

HashSet类

Java.util.HashSet类实现了Java.util.Set接口。

• 它不允许出现重复元素；

• 不保证集合中元素的顺序

• 允许包含值为null的元素，但最多只能有一个null元素。

TreeSet

TreeSet描述的是Set的一种变体——可以实现排序等功能的集合，它在讲对象元素添加到集合中时会自动按照某种比较规则将其插入到有序的对象序列中，并保证该集合元素组成的读优先序列时刻按照“升序”排列。

19.Collection和Collections的区别是什么？

 Collection是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。实现该接口的类主要有List和Set，该接口的设计目标是为了各种具体的集合提供最大化的统一的操作方式。   Collections是针对集合类的一个包裹类，它提供了一系列静态方法实现对各种集合的搜索、排序以及线程安全化等操作，其中的大多数方法都是用于处理线性表。Collections类不能实例化，如同一个工具类，服务于Collection框架。如果在使用Collections类的方法时，对应的Collection对象null，则这些方法都会抛出NullPointerException。

20.List、Set、Map 之间的区别是什么？

List：有序集合

Set：不重复集合，LinkedHashSet按照插入排序，SortedSet可排序，HashSet无序

Map：键值对集合

21.HashMap 和 Hashtable 有什么区别？

第一、继承不同。 　　public class Hashtable extends Dictionary implements Map 　　public class HashMap extends AbstractMap implements Map 第二、Hashtable 中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。在多线程并发的环境下，可以直接使用Hashtable，但是要使用HashMap的话就要自己增加同步处理了。 第三、Hashtable中，key和value都不允许出现null值。在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示 HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键， 而应该用containsKey()方法来判断。 第四、两个遍历方式的内部实现上不同。Hashtable、HashMap都使用了 Iterator。而由于历史原因，Hashtable还使用了Enumeration的方式 。 第五、哈希值的使用不同，HashTable直接使用对象的hashCode。而HashMap重新计算hash值。 第六、Hashtable和HashMap它们两个内部实现方式的数组的初始大小和扩容的方式。HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。

22.如何决定使用 HashMap 还是 TreeMap？

如果你需要得到一个有序的结果时就应该使用TreeMap（因为HashMap中元素的排列顺序是不固定的）。除此之外，由于HashMap有更好的性能，所以大多不需要排序的时候我们会使用HashMap。

23.说一下 HashMap 的实现原理？

HashMap 基于 Hash 算法实现，通过 put(key,value) 存储，get(key) 来获取 value 当传入 key 时，HashMap 会根据 key，调用 hash(Object key) 方法，计算出 hash 值，根据 hash 值将 value 保存在 Node 对象里，Node 对象保存在数组里 当计算出的 hash 值相同时，称之为 hash 冲突，HashMap 的做法是用链表和红黑树存储相同 hash 值的 value 当 hash 冲突的个数：小于等于 8 使用链表；大于 8 时，使用红黑树解决链表查询慢的问题

24.说一下 HashSet 的实现原理？

HashSet 是基于 HashMap 实现的，HashSet 底层使用 HashMap 来保存所有元素，因此 HashSet 的实现比较简单。相关 HashSet 的操作，基本上都是直接调用底层 HashMap 的相关方法来完成，HashSet 不允许重复的值。

25.ArrayList 和 LinkedList 的区别是什么？

1. ArrayList的实现是基于数组来实现的，LinkedList的基于双向链表来实现。这两个数据结构的逻辑关系是不一样，当然物理存储的方式也会是不一样。

2. LinkedList比ArrayList更占内存，因为LinkedList的节点除了存储数据，还存储了两个引用，一个指向前一个元素，一个指向后一个元素。

3. 对于随机访问，ArrayList要优于LinkedList。

1. 对于插入和删除操作，LinkedList优于ArrayList（理论上），实际并非如此（实际上ArrayList不论是插入还是删除效率，在元素数量趋多时，都是要优于LinkedList的），因这其中涉及数组与链表在元素操作方式、时间与空间上的复杂度计算问题，所以具体问题须具体分析和佐证。

26.如何实现数组和 List 之间的转换？

数组转 List ，使用 JDK 中 java.util.Arrays 工具类的 asList 方法

List 转数组，使用 List 的toArray方法。无参toArray方法返回Object数组，传入初始化长度的数组对象，返回该对象

27.ArrayList 和 Vector 的区别是什么？

ArrayList和Vector的区别，主要包括两个方面

同步性： Vector是线程安全的，也就是说它的方法直线是线程同步的，而ArrayList是线程不安全的，它的方法之间是线程不同步的

如果只有一个线程去访问集合那么使用ArrayList，他不考虑线程安全的问题，所以效率会高一些

如果是多个线程去访问集合，那么使用Vector

数据增长性：

ArrayList和Vector集合都有一个初始容量的大小，当元素的个数超过存储容量是，就需要增加ArrayList和Vector的存储空间，每次增加不是

增加一个而是增加多个，Vector是增加原来的两倍，ArrayList没有明文规定，但是从源码中可以看出增长原来的1.5倍

ArrayList和Vector可以设置初始的存储空间的大小，Vector还以设置增长空间大小，而ArrayList不可以。

28.Array 和 ArrayList 有何区别？

Array可以包含基本类型和对象类型，ArrayList只能包含对象类型。

Array大小是固定的，ArrayList的大小是动态变化的。

ArrayList提供了更多的方法和特性，比如：addAll()，removeAll()，iterator()等等。

对于基本类型数据，ArrayList 使用自动装箱来减少编码工作量；而当处理固定大小的基本数据类型的时候，这种方式相对比较慢，这时候应该使用Array。

29.在 Queue 中 poll()和 remove()有什么区别？

poll() 和 remove() 都是从队列中取出一个元素，但是 poll() 在获取元素失败的时候会返回空，但是 remove() 失败的时候会抛出异常。

30.哪些集合类是线程安全的？

Vector：只要是关键性的操作，方法前面都加了synchronized关键字，来保证线程的安全性 Hashtable：使用了synchronized关键字，所以相较于Hashmap是线程安全的。 ConcurrentHashMap:使用锁分段技术确保线性安全，是一种高效但是线程安全的集合。 Stack：栈，也是线程安全的，继承于Vector。

31.迭代器 Iterator 是什么？

首先说一下迭代器模式，它是 Java 中常用的设计模式之一。用于顺序访问集合对象的元素，无需知道集合对象的底层实现。

Iterator 是可以遍历集合的对象，为各种容器提供了公共的操作接口，隔离对容器的遍历操作和底层实现，从而解耦。

缺点是增加新的集合类需要对应增加新的迭代器类，迭代器类与集合类成对增加。

32.Iterator 怎么使用？有什么特点？

33.Iterator 和 ListIterator 有什么区别？

Iterator与ListIterator区别如下： 1、Iterator是ListIterator的父接口。 2、Iterator是单列集合(Collection)公共取出容器中元素的方式。 对于List，Set都通用。 而ListIterator是List集合的特有取出元素方式。 3、Iterator中具备的功能只有hashNext(),next()，remove(); ListIterator中具备着对被遍历的元素进行增删改查的方法，可以对元素进行逆向遍历。 之所以如此，是因为ListIterator遍历的元素所在的容器都有索引

34.怎么确保一个集合不能被修改？

可以使用 Collections. unmodifiableCollection(Collection c) 方法来创建一个只读集合，这样改变集合的任何操作都会抛出 Java. lang. UnsupportedOperationException 异常。

三、多线程

35.并行和并发有什么区别？

并发：一个处理器可以同时处理多个任务。这是逻辑上的同时发生。 并行：多个处理器同时处理多个不同的任务。这是物理上的同时发生。

36.线程和进程的区别？

进程

一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的xx.exe就是一个进程。

线程 进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。

与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

37.守护线程是什么？

守护线程，是指在程序运行时 在后台提供一种通用服务的线程，这种线程并不属于程序中不可或缺的部分。通俗点讲，任何一个守护线程都是整个JVM中所有非守护线程的"保姆"。

守护线程的一个典型的例子就是垃圾回收器。只要JVM启动，它始终在运行，实时监控和管理系统中可以被回收的资源

38.创建线程有哪几种方式？

一、继承Thread类创建线程类

二、通过Runnable接口创建线程类

三、覆写Callable接口实现多线程（JDK1.5）

四.通过线程池启动多线程

39.说一下 runnable 和 callable 有什么区别？

1.实现了runnable接口后无法返回结果信息，实现了callable接口后有返回值。

2.实现了runnable接口异常无法通过throws抛出异常，实现了callable接口后可以直接抛出Exception异常

40.线程有哪些状态？

1. 新建(NEW)：新创建了一个线程对象。

2. 可运行(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。

3. 运行(RUNNING)：可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。

   1. 阻塞(BLOCKED)：阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。阻塞的情况分三种：

(一). 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。 (二). 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。 (三). 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

1. 死亡(DEAD)：线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

41.sleep() 和 wait() 有什么区别？

1、每个对象都有一个锁来控制同步访问，Synchronized关键字可以和对象的锁交互，来实现同步方法或同步块。sleep()方法正在执行的线程主动让出CPU（然后CPU就可以去执行其他任务），在sleep指定时间后CPU再回到该线程继续往下执行(注意：sleep方法只让出了CPU，而并不会释放同步资源锁！！！)；wait()方法则是指当前线程让自己暂时退让出同步资源锁，以便其他正在等待该资源的线程得到该资源进而运行，只有调用了notify()方法，之前调用wait()的线程才会解除wait状态，可以去参与竞争同步资源锁，进而得到执行。（注意：notify的作用相当于叫醒睡着的人，而并不会给他分配任务，就是说notify只是让之前调用wait的线程有权利重新参与线程的调度）；

2、sleep()方法可以在任何地方使用；wait()方法则只能在同步方法或同步块中使用；

3、sleep()是线程线程类（Thread）的方法，调用会暂停此线程指定的时间，但监控依然保持，不会释放对象锁，到时间自动恢复；wait()是Object的方法，调用会放弃对象锁，进入等待队列，待调用notify()/notifyAll()唤醒指定的线程或者所有线程，才会进入锁池，不再次获得对象锁才会进入运行状态；

42.notify()和 notifyAll()有什么区别？

43.线程的 run()和 start()有什么区别？

44.创建线程池有哪几种方式？

1、newCachedThreadPool()

创建一个可缓存的线程池，如果线程池的规模超过了处理需求，将自动回收空闲线程，而当需求增加时，则可以自动添加新线程，线程池的规模不存在任何限制。

2、newFixedThreadPool(2)

创建一个固定长度的线程池，每当提交一个任务就创建一个线程，直到达到线程池的最大数量，超出的线程会在队列中等待。

3、newScheduledThreadPool(2)

创建了一个固定长度的线程池，而且以延迟或定时的方式来执行任务，类似于Timer。

4、newSingleThreadExecutor()

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

5、newSingleThreadScheduledExecutor()

创建一个单例线程池，定期或延时执行任务。

6、newWorkStealingPool(3)

创建一个带并行级别的线程池，并行级别决定了同一时刻最多有多少个线程在执行，如不穿如并行级别参数，将默认为当前系统的CPU个数。

45.线程池都有哪些状态？

1.RUNNING：这是最正常的状态，接受新的任务，处理等待队列中的任务。线程池的初始化状态是RUNNING。线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0。

2.SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务。调用线程池的shutdown()方法时，线程池由RUNNING -> SHUTDOWN。

3.STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程。调用线程池的shutdownNow()方法时，线程池由(RUNNING or SHUTDOWN ) -> STOP。

4.TIDYING：所有的任务都销毁了，workCount 为 0，线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()。因为terminated()在ThreadPoolExecutor类中是空的，所以用户想在线程池变为TIDYING时进行相应的处理；可以通过重载terminated()函数来实现。

当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。

当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING。

5.TERMINATED：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。

46.线程池中 submit()和 execute()方法有什么区别？

两个方法都可以向线程池提交任务，execute()方法的返回类型是void，它定义在Executor接口中，而submit()方法返回有计算结构的Future对象，它定义在ExecutorService接口中，它拓展了Executor接口，其他线程池类像ThreadPoolExecutor和ScheduledThreadPoolExecutor都有这些方法。

47.在 java 程序中怎么保证多线程的运行安全？

1、线程中安全性问题的体现： 线程的安全性问题体现在三个方面：

（1）线程切换导致的原子性问题： 一个或者多个操作在 CPU 执行的过程中不被中断的特性。 （2）缓存导致的可见性问题： 一个线程对共享变量的修改，另外一个线程能够立刻看到。 （3）编译优化导致的有序性问题： 程序执行的顺序按照代码的先后顺序执行。

2、线程安全问题的解决办法 （1）JDK Atomic开头的原子类、synchronized、LOCK，可以解决原子性问题。 （2）synchronized、volatile、LOCK，可以解决可见性问题。 （3）Happens-Before 规则可以解决有序性问题。

48.多线程锁的升级原理是什么？

锁的级别从低到高：

无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁

锁分级别原因：

没有优化以前，synchronized是重量级锁（悲观锁），使用 wait 和 notify、notifyAll 来切换线程状态非常消耗系统资源；线程的挂起和唤醒间隔很短暂，这样很浪费资源，影响性能。所以 JVM 对 synchronized 关键字进行了优化，把锁分为 无锁、偏向锁、轻量级锁、重量级锁 状态。

无锁：没有对资源进行锁定，所有的线程都能访问并修改同一个资源，但同时只有一个线程能修改成功，其他修改失败的线程会不断重试直到修改成功。

偏向锁：对象的代码一直被同一线程执行，不存在多个线程竞争，该线程在后续的执行中自动获取锁，降低获取锁带来的性能开销。偏向锁，指的就是偏向第一个加锁线程，该线程是不会主动释放偏向锁的，只有当其他线程尝试竞争偏向锁才会被释放。

偏向锁的撤销，需要在某个时间点上没有字节码正在执行时，先暂停拥有偏向锁的线程，然后判断锁对象是否处于被锁定状态。如果线程不处于活动状态，则将对象头设置成无锁状态，并撤销偏向锁；

如果线程处于活动状态，升级为轻量级锁的状态。

轻量级锁：轻量级锁是指当锁是偏向锁的时候，被第二个线程 B 所访问，此时偏向锁就会升级为轻量级锁，线程 B 会通过自旋的形式尝试获取锁，线程不会阻塞，从而提高性能。

当前只有一个等待线程，则该线程将通过自旋进行等待。但是当自旋超过一定的次数时，轻量级锁便会升级为重量级锁；当一个线程已持有锁，另一个线程在自旋，而此时又有第三个线程来访时，轻量级锁也会升级为重量级锁。

重量级锁：指当有一个线程获取锁之后，其余所有等待获取该锁的线程都会处于阻塞状态。

重量级锁通过对象内部的监视器（monitor）实现，而其中 monitor 的本质是依赖于底层操作系统的 Mutex Lock 实现，操作系统实现线程之间的切换需要从用户态切换到内核态，切换成本非常高。

49.什么是死锁？

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。产生死锁的原因，主要包括： 系统资源不足； 程序执行的顺序有问题； 资源分配不当等。 如果系统资源充足，进程的资源请求都能够得到满足，那么死锁出现的可能性就很低；否则， 就会因争夺有限的资源而陷入死锁。其次，程序执行的顺序与速度不同，也可能产生死锁。产生死锁的四个必要条件： 互斥条件：一个资源每次只能被一个进程使用。 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。 不剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。 这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。

理解了死锁的原因，尤其是产生死锁的四个必要条件，我们就可以最大可能地避免、预防和解除死锁。所以，在系统设计、进程调度等方面注意如何不让这四个必要条件成立，如何确定资源的合理分配算法，避免进程永久占据系统资源，这就是避免、预防和解决死锁的最佳实践。此外，也要防止进程在处于等待状态的情况下占用资源。

50.怎么防止死锁？

51.ThreadLocal 是什么？有哪些使用场景？

Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。

在同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。

而ThreadLocal则从另一个角度来解决多线程的并发访问。ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。 ThreadLocal在每个本地线程中创建了一个ThreadLocalMap对象，每个线程可以访问自己内部ThreadLocalMap对象里的value。通过这种方式，实现线程之间的数据隔离。

52.说一下 synchronized 底层实现原理？

1. 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁

2. 静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁

3. 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

53.synchronized 和 volatile 的区别是什么？

（1）volatile只能作用于变量，使用范围较小。synchronized可以用在变量、方法、类、同步代码块等，使用范围比较广。
 （2）volatile只能保证可见性和有序性，不能保证原子性。而可见性、有序性、原子性synchronized都可以包证。
 （3）volatile不会造成线程阻塞。synchronized可能会造成线程阻塞。

54.synchronized 和 Lock 有什么区别？

1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；

2）Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

区别： 1.用法不一样。synchronized既可以加在方法上，也可以加载特定的代码块上，括号中表示需要锁的对象。而Lock需要显示地指定起始位置和终止位置。synchronzied是托管给jvm执行的，Lock锁定是通过代码实现的。 2.在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。 3.锁的机制不一样。synchronized获得锁和释放的方式都是在块结构中，而且是自动释放锁。而Lock则需要开发人员手动去释放，并且必须在finally块中释放，否则会引起死锁问题的发生。 4.Lock是一个接口，而synchronized是Java中的关键字,synchronized是内置的语言实现； 5.synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁； 6.Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。Lock可以提高多个线程进行读操作的效率。

55.synchronized 和 ReentrantLock 区别是什么？

synchronized 竞争锁时会一直等待；ReentrantLock 可以尝试获取锁，并得到获取结果 synchronized 获取锁无法设置超时；ReentrantLock 可以设置获取锁的超时时间 synchronized 无法实现公平锁；ReentrantLock 可以满足公平锁，即先等待先获取到锁 synchronized 控制等待和唤醒需要结合加锁对象的 wait() 和 notify()、notifyAll()；ReentrantLock 控制等待和唤醒需要结合 Condition 的 await() 和 signal()、signalAll() 方法 synchronized 是 JVM 层面实现的；ReentrantLock 是 JDK 代码层面实现 synchronized 在加锁代码块执行完或者出现异常，自动释放锁；ReentrantLock 不会自动释放锁，需要在 finally{} 代码块显示释放

56.说一下 atomic 的原理？

atomic 通过CAS (Compare And Wwap)乐观锁机制-自旋锁（它的实现很简单，就是用一个预期的值和内存值进行比较，如果两个值相等，就用预期的值替换内存值，并返回 true。否则，返回 false。）保证原子性，【通过降低锁粒度（多段锁）增加并发性能。这一点是java8做出的改进】从而避免 synchronized 的高开销，执行效率大为提升。

四、反射

57.什么是反射？

Java 反射，就是在运行状态中。

获取任意类的名称、package信息、所有属性、方法、注解、类型、类加载器等 获取任意对象的属性，并且能改变对象的属性 调用任意对象的方法 判断任意一个对象所属的类 实例化任意一个类的对象 Java 的动态就体现在这。通过反射我们可以实现动态装配，降低代码的耦合度；动态代理等。反射的过度使用会严重消耗系统资源。

JDK 中 java.lang.Class 类，就是为了实现反射提供的核心类之一。

获取 Class 的方法 、一个 jvm 中一种 Class 只会被实例化一次

58.什么是 java 序列化？什么情况下需要序列化？

序列化：将 Java 对象转换成字节流的过程。

反序列化：将字节流转换成 Java 对象的过程。

当 Java 对象需要在网络上传输 或者 持久化存储到文件中时，就需要对 Java 对象进行序列化处理。

序列化的实现：类实现 Serializable 接口，这个接口没有需要实现的方法。实现 Serializable 接口是为了告诉 jvm 这个类的对象可以被序列化。

59.动态代理是什么？有哪些应用？

动态代理：当想要给实现了某个接口的类中的方法，加一些额外的处理。比如说加日志，加事务等。可以给这个类创建一个代理，故名思议就是创建一个新的类，这个类不仅包含原来类方法的功能，而且还在原来的基础上添加了额外处理的新类。这个代理类并不是定义好的，是动态生成的。具有解耦意义，灵活，扩展性强。

动态代理实现：首先必须定义一个接口，还要有一个InvocationHandler(将实现接口的类的对象传递给它)处理类。再有一个工具类Proxy(习惯性将其称为代理类，因为调用他的newInstance()可以产生代理对象,其实他只是一个产生代理对象的工具类）。利用到InvocationHandler，拼接代理类源码，将其编译生成代理类的二进制码，利用加载器加载，并将其实例化产生代理对象，最后返回。

动态代理的应用：Spring的AOP，加事务，加权限，加日志。

60.怎么实现动态代理？

1.原生JDK

必须借助接口才能产生代理对象，必须有接口

2.CGLIB

CGLIB实现动态代理，不需要接口！！！

五、对象拷贝

61.为什么要使用克隆？

想对一个对象进行处理，又想保留原有的数据进行接下来的操作，就需要克隆了，Java语言中克隆针对的是类的实例

62.如何实现对象克隆？

1.实现Clineable接口并重写Object类中的clone()方法

2.实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。

63.深拷贝和浅拷贝区别是什么？

浅拷贝只是复制了对象的引用地址，两个对象指向同一个内存地址，所以修改其中任意的值，另一个值都会随之变化，这就是浅拷贝

深拷贝是将对象及值复制过来，两个对象修改其中任意的值另一个值不会改变，这就是深拷贝

六、Java Web

64.jsp 和 servlet 有什么区别？

Servlet

一种服务器端的Java应用程序 由 Web 容器加载和管理 用于生成动态 Web 内容 负责处理客户端请求

Jsp

是 Servlet 的扩展，本质上还是 Servlet 每个 Jsp 页面就是一个 Servlet 实例 Jsp 页面会被 Web 容器编译成 Servlet，Servlet 再负责响应用户请求 区别

Servlet 适合动态输出 Web 数据和业务逻辑处理，对于 html 页面内容的修改非常不方便；Jsp 是在 Html 代码中嵌入 Java 代码，适合页面的显示 内置对象不同，获取内置对象的方式不同

65.jsp 有哪些内置对象？作用分别是什么？

jsp共有以下9个内置对象: 1.request 客户端请求,此请求会包含GET/POST请求的参数 2.response 网页传回客户端的回应 3.pageContext 网页的属性是在这里管理 4.session 请求有关的会话期 5.application servlet正在执行的内容 6.out 用来传送回应的输出 7.config servlet的架构部分 8.page jsp页面网页本身 9.exception 针对错误网页,未捕捉的例外

66.说一下 jsp 的 4 种作用域？

page 当前页面作用域：代表与一个页面相关的对象和属性。 request 请求作用域 ：代表与客户端发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多个 Web 组件；需要在页面显示的临时数据可以置于此作用域。 session 会话作用域 ：代表与某个用户与服务器建立的一次会话相关的对象和属性。跟某个用户相关的数据应该放在用户自己的 session 中。 application 全局作用域 ：代表与整个 Web 应用程序相关的对象和属性，它实质上是跨越整个 Web 应用程序，包括多个页面、请求和会话的一个全局作用域。

67.session 和 cookie 有什么区别？

①Cookie可以存储在浏览器或者本地，Session只能存在服务器 ②session 能够存储任意的 java 对象，cookie 只能存储 String 类型的对象 ③Session比Cookie更具有安全性（Cookie有安全隐患，通过拦截或本地文件找得到你的cookie后可以进行攻击） ④Session占用服务器性能，Session过多，增加服务器压力 ⑤单个Cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个Cookie，Session是没有大小限制和服务器的内存大小有关。

68.说一下 session 的工作原理？

session 的工作原理是客户端登录完成之后，服务器会创建对应的 session，session 创建完之后，会把 session 的 id 发送给客户端，客户端再存储到浏览器中。这样客户端每次访问服务器时，都会带着 sessionid，服务器拿到 sessionid 之后，在内存找到与之对应的 session 这样就可以正常工作了。

69.如果客户端禁止 cookie 能实现 session 还能用吗？

一般默认情况下，在会话中，服务器存储 session 的 sessionid 是通过 cookie 存到浏览器里。

如果浏览器禁用了 cookie，浏览器请求服务器无法携带 sessionid，服务器无法识别请求中的用户身份，session失效。

但是可以通过其他方法在禁用 cookie 的情况下，可以继续使用session。

通过url重写，把 sessionid 作为参数追加的原 url 中，后续的浏览器与服务器交互中携带 sessionid 参数。 服务器的返回数据中包含 sessionid，浏览器发送请求时，携带 sessionid 参数。 通过 Http 协议其他 header 字段，服务器每次返回时设置该 header 字段信息，浏览器中 js 读取该 header 字段，请求服务器时，js设置携带该 header 字段。

70.spring mvc 和 struts 的区别是什么？

1.Struts是类级别的拦截，SpringMVC是方法级别的拦截

2.SpringMVC更适合更容易实现REST风格

3.SpringMVC的方法之间基本上独立的，独享request和response数据，请求数据通过参数获取，处理结果通过ModelMap交回给框架，方法之间不共享变量。而Struts2虽然方法之间也是独立的，但其所有Action变量是共享的，这不会影响程序运行，却给我们编码读程序时带来麻烦。

71.如何避免 sql 注入？

严格限制 Web 应用的数据库的操作权限，给连接数据库的用户提供满足需要的最低权限，最大限度的减少注入攻击对数据库的危害 校验参数的数据格式是否合法（可以使用正则或特殊字符的判断） 对进入数据库的特殊字符进行转义处理，或编码转换 预编译 SQL（Java 中使用 PreparedStatement），参数化查询方式，避免 SQL 拼接 发布前，利用工具进行 SQL 注入检测 报错信息不要包含 SQL 信息输出到 Web 页面

72.什么是 XSS 攻击，如何避免？

XSS 攻击，即跨站脚本攻击（Cross Site Scripting），它是 web 程序中常见的漏洞。

原理

攻击者往 web 页面里插入恶意的 HTML 代码（Javascript、css、html 标签等），当用户浏览该页面时，嵌入其中的 HTML 代码会被执行，从而达到恶意攻击用户的目的。如盗取用户 cookie 执行一系列操作，破坏页面结构、重定向到其他网站等。

预防思路

• web 页面中可由用户输入的地方，如果对输入的数据转义、过滤处理

• 后台输出页面的时候，也需要对输出内容进行转义、过滤处理（因为攻击者可能通过其他方式把恶意脚本写入数据库）

• 前端对 html 标签属性、css 属性赋值的地方进行校验

73.什么是 CSRF 攻击，如何避免？

CSRF：Cross Site Request Forgery（跨站点请求伪造）。 CSRF 攻击者在用户已经登录目标网站之后，诱使用户访问一个攻击页面，利用目标网站对用户的信任，以用户身份在攻击页面对目标网站发起伪造用户操作的请求，达到攻击目的。

避免方法：

• CSRF 漏洞进行检测的工具，如 CSRFTester、CSRF Request Builder...

• 验证 HTTP Referer 字段

• 添加并验证 token

• 添加自定义 http 请求头

• 敏感操作添加验证码

• 使用 post 请求

七、异常

74.throw 和 throws 的区别？

Throw：

作用在方法内，表示抛出具体异常，由方法体内的语句处理。 具体向外抛出的动作，所以它抛出的是一个异常实体类。若执行了Throw一定是抛出了某种异常。 Throws：

作用在方法的声明上，表示如果抛出异常，则由该方法的调用者来进行异常处理。 主要的声明这个方法会抛出会抛出某种类型的异常，让它的使用者知道捕获异常的类型。 出现异常是一种可能性，但不一定会发生异常。

75.final、finally、finalize 有什么区别？

final可以用来修饰类、方法、变量，分别有不同的意义所在，final修饰的class代表不可继续扩展，final修饰的变量代表不可修改，final修饰的方法代表不可重写。

finally则是java保证某一段重点代码一定要被执行的修饰符，例如：我们需要用try块让JDBC保证连接，保证unlock锁等动作

finalize是基础类java.lang.Object的一个方法，它的设计目的是为了保证对象在垃圾回收之前完成特定资源的回收

76.try-catch-finally 中哪个部分可以省略？

catch 和 finally 语句块可以省略其中一个。

77.try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？

会。程序在执行到 return 时会首先将返回值存储在一个指定的位置，其次去执行 finally 块，最后再返回。因此，对基本数据类型，在 finally 块中改变 return 的值没有任何影响，直接覆盖掉；而对引用类型是有影响的，返回的是在 finally 对 前面 return 语句返回对象的修改值。

78.常见的异常类有哪些？

NullPointerException 空指针异常

ClassNotFoundException 指定类不存在

NumberFormatException 字符串转换为数字异常

IndexOutOfBoundsException 数组下标越界异常

ClassCastException 数据类型转换异常

FileNotFoundException 文件未找到异常

NoSuchMethodException 方法不存在异常

IOException IO 异常

SocketException Socket 异常

八、网络

79.http 响应码 301 和 302 代表的是什么？有什么区别？

301 Moved Permanently 被请求的资源已永久移动到新位置，并且将来任何对此资源的引用都应该使用本响应返回的若干个 URI 之一。如果可能，拥有链接编辑功能的客户端应当自动把请求的地址修改为从服务器反馈回来的地址。除非额外指定，否则这个响应也是可缓存的。

302 Found 请求的资源现在临时从不同的 URI 响应请求。由于这样的重定向是临时的，客户端应当继续向原有地址发送以后的请求。只有在Cache-Control或Expires中进行了指定的情况下，这个响应才是可缓存的。

80.forward 和 redirect 的区别？

转发是服务器行为，重定向是客户端行为。为什么这样说呢，这就要看两个动作的工作流程：

转发过程：客户浏览器发送http请求--->web服务器接受此请求--->调用内部的一个方法在容器内部完成请求处理和转发动作--->将目标资源 发送给客户；在这里，转发的路径必须是同一个web容器下的url，其不能转向到其他的web路径上去，中间传递的是自己的容器内的request。在客 户浏览器路径栏显示的仍然是其第一次访问的路径，也就是说客户是感觉不到服务器做了转发的。转发行为是浏览器只做了一次访问请求。

重定向过程：客户浏览器发送http请求--->web服务器接受后发送302状态码响应及对应新的location给客户浏览器--->客户浏览器发现 是302响应，则自动再发送一个新的http请求，请求url是新的location地址--->服务器根据此请求寻找资源并发送给客户。在这里 location可以重定向到任意URL，既然是浏览器重新发出了请求，则就没有什么request传递的概念了。在客户浏览器路径栏显示的是其重定向的 路径，客户可以观察到地址的变化的。重定向行为是浏览器做了至少两次的访问请求的。

重定向，其实是两次request:第一次，客户端request A,服务器响应，并response回来，告诉浏览器，你应该去B。这个时候IE可以看到地址变了，而且历史的回退按钮也亮了。重定向可以访问自己web应用以外的资源。在重定向的过程中，传输的信息会被丢失。

81.简述 tcp 和 udp的区别？

1、UDP UDP是面向无连接的通讯协议，UDP数据包括目的端口号和源端口号信息

优点： UDP速度快，操作简单，要求系统资源较少，由于通讯不需要连接 可实现广播发送 缺点： UDP传送数据前并不与对方建立连接，对接收到的数据也不发送确认信号，发送端不知道数据是否会正确接收，也不重复发送，不可靠

2、TCP

优点： TCP在传输数据是，有确认，窗口，重传，阻塞等控制机制，能保证 数据正确性，较为可靠 缺点： TCP相对于UDP速度慢，要求系统资源较多

82.tcp 为什么要三次握手，两次不行吗？为什么？

为了实现可靠数据传输， TCP 协议的通信双方， 都必须维护一个序列号， 以标识发送出去的数据包中， 哪些是已经被对方收到的。 三次握手的过程即是通信双方相互告知序列号起始值， 并确认对方已经收到了序列号起始值的必经步骤 如果只是两次握手， 至多只有连接发起方的起始序列号能被确认， 另一方选择的序列号则得不到确认

83.说一下 tcp 粘包是怎么产生的？

1、什么是 tcp 粘包？

发送方发送的多个数据包，到接收方缓冲区首尾相连，粘成一包，被接收。

2、原因

TCP 协议默认使用 Nagle 算法可能会把多个数据包一次发送到接收方。

应用程读取缓存中的数据包的速度小于接收数据包的速度，缓存中的多个数据包会被应用程序当成一个包一次读取。

3、处理方法

发送方使用 TCP_NODELAY 选项来关闭 Nagle 算法

数据包增加开始符和结束，应用程序读取、区分数据包。

在数据包的头部定义整个数据包的长度，应用程序先读取数据包的长度，然后读取整个长度的包字节数据，保证读取的是单个包且完整。

84.OSI 的七层模型都有哪些？

OSI模型分为七层，自下而上为 物理层（Physical Layer）、数据链路层（Data Link Layer）、网络层（Network Layer）、传输层（Transport Layer）、会话层（Session Layer）、表达层（Presentation Layer）、应用层（Application Layer）。

85.get 和 post 请求有哪些区别？

最直观的区别就是GET把参数包含在URL中，POST通过request body传递参数。

简单的说：GET产生一个TCP数据包；POST产生两个TCP数据包。

86.如何实现跨域？

1、jsonp 利用了 script 不受同源策略的限制 缺点：只能 get 方式，易受到 XSS攻击

2、CORS（Cross-Origin Resource Sharing）,跨域资源共享 当使用XMLHttpRequest发送请求时，如果浏览器发现违反了同源策略就会自动加上一个请求头 origin； 后端在接受到请求后确定响应后会在后端在接受到请求后确定响应后会在 Response Headers 中加入一个属性 Access-Control-Allow-Origin； 浏览器判断响应中的 Access-Control-Allow-Origin 值是否和当前的地址相同，匹配成功后才继续响应处理，否则报错 缺点：忽略 cookie，浏览器版本有一定要求

3、代理跨域请求 前端向发送请求，经过代理，请求需要的服务器资源 缺点：需要额外的代理服务器

4、Html5 postMessage 方法 允许来自不同源的脚本采用异步方式进行有限的通信，可以实现跨文本、多窗口、跨域消息传递 缺点：浏览器版本要求，部分浏览器要配置放开跨域限制

5、修改 document.domain 跨子域 相同主域名下的不同子域名资源，设置 document.domain 为 相同的一级域名 缺点：同一一级域名；相同协议；相同端口

6、基于 Html5 websocket 协议 websocket 是 Html5 一种新的协议，基于该协议可以做到浏览器与服务器全双工通信，允许跨域请求 缺点：浏览器一定版本要求，服务器需要支持 websocket 协议

7、document.xxx + iframe 通过 iframe 是浏览器非同源标签，加载内容中转，传到当前页面的属性中 缺点：页面的属性值有大小限制

87.说一下 JSONP 实现原理？

Jsonp原理： 首先在客户端注册一个callback, 然后把callback的名字传给服务器。 此时，服务器先生成 json 数据。 然后以 javascript 语法的方式，生成一个function , function 名字就是传递上来的参数 jsonp.

最后将 json 数据直接以入参的方式，放置到 function 中，这样就生成了一段 js 语法的文档，返回给客户端。

3.客户端浏览器，解析script标签，并执行返回的 javascript 文档，此时数据作为参数，传入到了客户端预先定义好的 callback 函数里.（动态执行回调函数）

九、设计模式

88.说一下你熟悉的设计模式？

89.简单工厂和抽象工厂有什么区别？

十、Spring/Spring MVC

90.为什么要使用 spring？

1.方便解耦，便于开发（Spring就是一个大工厂，可以将所有对象的创建和依赖关系维护都交给spring管理）

2.spring支持aop编程（spring提供面向切面编程，可以很方便的实现对程序进行权限拦截和运行监控等功能）

3.声明式事务的支持（通过配置就完成对事务的支持，不需要手动编程）

4.方便程序的测试，spring 对junit4支持，可以通过注解方便的测试spring 程序

5.方便集成各种优秀的框架（）

6.降低javaEE API的使用难度（Spring 对javaEE开发中非常难用的一些API 例如JDBC,javaMail,远程调用等，都提供了封装，是这些API应用难度大大降低）

91.解释一下什么是 aop？

这种在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。

AOP是Spring提供的关键特性之一。AOP即面向切面编程，是OOP编程的有效补充。

使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。

从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑——比如权限管理，事物管理，日志记录等等。

这些系统性的编程工作都可以独立编码实现，然后通过AOP技术切入进系统即可。从而达到了 将不同的关注点分离出来的效果。

92.解释一下什么是 ioc？

IOC （Inversion Of Control，控制反转），是spring的核心，贯穿始终，所谓IOC ，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。所有的类都会在spring容器中登记，告诉spring你是个什么，你需要什么，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。

93.spring 有哪些主要模块？

1.Spring Core：Spring框架的核心容器，他提供了Spring框架的基本功能。这个模块中最主要的一个组件为BeanFactory,它使用工厂模式来创建所需的对象。同时BeanFactory使用IOC思想，通过读取XML文件的方式来实例化对象，可以说BeanFactory提供了组件生命周期的管理，组件的创建，装配以及销毁等功能;

2.Spring AOP：采用了面向切面编程的思想，使Spring框架管理的对象支持AOP，同时这个模块也提供了事务管理，可以不依赖具体的EJB组件，就可以将事务管理集成到应用程序中; 3.Spring ORM：提供了对现有的ORM框架的支持，例如Hibernate等；

4.Spring DAO：提供了对DAO（Data Access Object,数据访问对象）模式和JDBC的支持。DAO可以实现将业务逻辑与数据库访问的代码分离，从而降低代码的耦合度。通过对JDBC的抽象，简化了开发工作，同时简化了对异常的处理(可以很好的处理不同数据库厂商抛出的异常);

5.Spring Web：提供了Servlet监听器的Context和Web应用的上下文。同时还集成了一些现有的Web框架，例如Struts;

6.Spring Context：扩展核心容器，提供了Spring上下文环境，给开发人员提供了很多非常有用的服务，例如国际化,Email和JNDI访问等；

7.Spring Web MVC：提供了一个构建Web应用程序的MVC的实现

94.spring 常用的注入方式有哪些？

Spring通过DI（依赖注入）实现IOC（控制反转），常用的注入方式主要有三种：构造方法注入，setter 注入，基于注解的注入。

95.spring 中的 bean 是线程安全的吗？

Spring 不保证 bean 的线程安全。 默认 spring 容器中的 bean 是单例的。当单例中存在竞态条件，即有线程安全问题

96.spring 支持几种 bean 的作用域？

• singleton：单例模式，在整个Spring IoC容器中，使用 singleton 定义的 bean 只有一个实例

• prototype：原型模式，每次通过容器的getbean方法获取 prototype 定义的 bean 时，都产生一个新的 bean 实例

97.spring 自动装配 bean 有哪些方式？

no：默认方式，手动装配方式，需要通过ref设定bean的依赖关系 byName：根据bean的名字进行装配，当一个bean的名称和其他bean的属性一致，则自动装配 byType：根据bean的类型进行装配，当一个bean的属性类型与其他bean的属性的数据类型一致，则自动装配 constructor：根据构造器进行装配，与 byType 类似，如果bean的构造器有与其他bean类型相同的属性，则进行自动装配 autodetect：如果有默认构造器，则以constructor方式进行装配，否则以byType方式进行装配

98.spring 事务实现方式有哪些？

（1）编程式事务管理对基于 POJO 的应用来说是唯一选择。我们需要在代码中调用beginTransaction()、commit()、rollback()等事务管理相关的方法，这就是编程式事务管理。 （2）基于 TransactionProxyFactoryBean的声明式事务管理 （3）基于 @Transactional 的声明式事务管理 （4）基于Aspectj AOP配置事务

99.说一下 spring 的事务隔离？

⑴ 原子性（Atomicity） 　　原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚，这和前面两篇博客介绍事务的功能是一样的概念，因此事务的操作如果成功就必须要完全应用到数据库，如果操作失败则不能对数据库有任何影响。 ⑵ 一致性（Consistency） 　　一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。 　　拿转账来说，假设用户A和用户B两者的钱加起来一共是5000，那么不管A和B之间如何转账，转几次账，事务结束后两个用户的钱相加起来应该还得是5000，这就是事务的一致性。 ⑶ 隔离性（Isolation） 　　隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。 　　即要达到这么一种效果：对于任意两个并发的事务T1和T2，在事务T1看来，T2要么在T1开始之前就已经结束，要么在T1结束之后才开始，这样每个事务都感觉不到有其他事务在并发地执行。 　　关于事务的隔离性数据库提供了多种隔离级别，稍后会介绍到。 ⑷ 持久性（Durability） 　　持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。 　　例如我们在使用JDBC操作数据库时，在提交事务方法后，提示用户事务操作完成，当我们程序执行完成直到看到提示后，就可以认定事务以及正确提交，即使这时候数据库出现了问题，也必须要将我们的事务完全执行完成，否则就会造成我们看到提示事务处理完毕，但是数据库因为故障而没有执行事务的重大错误。

100.说一下 spring mvc 运行流程？

执行流程:

1、 用户向服务器发送请求，请求被 Spring 前端控制 Servelt DispatcherServlet 捕获(捕获)

2、 DispatcherServlet对请求 URL进行解析，得到请求资源标识符（URI）。然后根据该 URI，调用 HandlerMapping获得该Handler配置的所有相关的对象（包括 Handler对象以及 Handler对象对应的拦截器），最后以 HandlerExecutionChain对象的形式返回；(查找 handler)

3、 DispatcherServlet 根据获得的 Handler，选择一个合适的 HandlerAdapter。 提取Request 中的模型数据，填充 Handler 入参，开始执行 Handler（Controller), Handler执行完成后，向 DispatcherServlet 返回一个 ModelAndView 对象(执行 handler)

4、DispatcherServlet 根据返回的 ModelAndView，选择一个适合的 ViewResolver（必须是已经注册到 Spring 容器中的 ViewResolver) (选择 ViewResolver)

5、通过 ViewResolver 结合 Model 和 View，来渲染视图,DispatcherServlet 将渲染结果返回给客户端。（渲染返回）

快速记忆技巧：

核心控制器捕获请求、查找Handler、执行Handler、选择ViewResolver,通过ViewResolver渲染视图并返回

101.spring mvc 有哪些组件？

\1. 前端控制器组件（DispatcherServlet） \2. 处理器组件（Controller） \3. 处理器映射器组件（HandlerMapping） \4. 处理器适配器组件（HandlerAdapter） \5. 拦截器组件（HandlerInterceptor） \6. 视图解析器组件（ViewResolver） \7. 视图组件（View） \8. 数据转换组件（DataBinder） \9. 消息转换器组件（HttpMessageConverter）

102.@RequestMapping 的作用是什么？

RequestMapping 是一个用来处理请求地址映射的注解，可用于类或方法上.用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径.

103.@Autowired 的作用是什么？

@Autowired 是一个注释，它可以对类成员变量、方法及构造函数进行标注，让 spring 完成 bean 自动装配的工作。

十一、Spring Boot/Spring Cloud

104.什么是 spring boot？

介绍：springboot是由Pivotal团队提供的全新框架。spring的出现是为了解决企业级开发应用的复杂性，spring的通过注册bean的方式来管理类，但是随着业务的增加，使用xml配置bean的方式也显得相当繁琐，所以springboot就是为了解决spring配置繁琐的问题而诞生的，并且近几年来非常流行

105.为什么要用 spring boot？

使用SpringBoot的最大好处就是简化配置，它实现了自动化配置

106.spring boot 核心配置文件是什么？

Spring Boot 有两种类型的配置文件，application 和 bootstrap 文件 Spring Boot会自动加载classpath目前下的这两个文件，文件格式为 properties 或 yml 格式

*.properties 文件是 key=value 的形式 *.yml 是 key: value 的形式 *.yml 加载的属性是有顺序的，但不支持 @PropertySource 注解来导入配置，一般推荐用yml文件，看下来更加形象

bootstrap 配置文件是系统级别的，用来加载外部配置，如配置中心的配置信息，也可以用来定义系统不会变化的属性.bootstatp 文件的加载先于application文件 application 配置文件是应用级别的，是当前应用的配置文件

107.spring boot 配置文件有哪几种类型？它们有什么区别？

108.spring boot 有哪些方式可以实现热部署？

热部署，就是在应用正在运行的时候升级软件，却不需要重新启动应用。SpringBoot热部署就是在项目正在运行的时候修改代码, 却不需要重新启动项目.

• Spring Loaded

• spring-boot-devtools

• JRebel插件

109.jpa 和 hibernate 有什么区别？

110.什么是 spring cloud？

SpringCloud 是一个微服务框架, 相比Dubbo等RPC框架, SpringCloud提供了全套分布式系统解决方案 SpringCloud对微服务基础框架Netflix的多个开源组件进行了封装, 同时又实现了云端平台以及和SpringBoot开发框架的集成 SpringCloud为开发者提供了快速构建分布式系统的工具, 开发者可以快速的启动服务或构建应用, 同时能够快速和云平台资源进行对接 SpringCloud为微服务架构开发涉及的配置管理, 服务治理, 熔断机制, 智能路由, 微代理, 控制总线, 一次性token, 全局一致性锁, leader选举, 分布式session, 集群状态管理等操作提供了一种简单地开发方式

111.spring cloud 断路器的作用是什么？

当一个服务调用另一个服务由于网络原因或者自身原因出现问题时 ，调用者就会等待被调者的响应，当更多的服务请求到这些资源时，导致更多的请求等待，这样就会发生连锁效应，断路器就是解决这一问题的。

断路器有完全打开状态： 一定时间内，达到一定的次数无法调用，并且多次检测没有恢复的迹象，断路器完全打开，那么下次的请求不会请求到该服务。

半开： 短时间内有回复迹象，断路器会将部分请求发送给服务，当能正常调用时，断路器关闭。

关闭： 当服务一直处于正常状态，能正常调用，断路器关闭。

112.spring cloud 的核心组件有哪些？

Eureka： 服务启动的时候，服务上的Eureka客户端会把自身注册到Eureka服务端，并且可以通过Eureka服务端知道其他注册的服务 Ribbon： 服务间发起请求的时候，服务消费者方基于Ribbon服务做到负载均衡，从服务提供者存储的多台机器中选择一台，如果一个服务只在一台机器上面，那就用不到Ribbon选择机器了，如果有多台机器，那就需要使用Ribbon选择之后再去使用 Feign： Feign使用的时候会集成Ribbon，Ribbon去Eureka服务端中找到服务提供者的所在的服务器信息，然后根据随机策略选择一个，拼接Url地址后发起请求 Hystrix： 发起的请求是通过Hystrix的线程池去访问服务，不同的服务通过不同的线程池，实现了不同的服务调度隔离，如果服务出现故障，通过服务熔断，避免服务雪崩的问题 ，并且通过服务降级，保证可以手动实现服务正常功能 Zuul： 如果前端调用后台系统，统一走zull网关进入，通过zull网关转发请求给对应的服务

十三、Mybatis

125.mybatis 中 #{}和 ${}的区别是什么？

在mybatis中#和$的主要区别是：#传入的参数在SQL中显示为字符串，#方式能够很大程度防止SQL注入；$传入的参数在SQL中直接显示为传入的值，$方式无法防止SQL注入。

126.mybatis 有几种分页方式？

一.借助数组进行分页（逻辑分页）

二.借助Sql语句进行分页（物理分页）

三.拦截器分页 (物理分页) 通过拦截器给sql语句末尾加上limit语句来查询，一劳永逸最优

四.RowBounds实现分页 （逻辑分页）

127.RowBounds 是一次性查询全部结果吗？为什么？

128.mybatis 逻辑分页和物理分页的区别是什么？

逻辑分页：将数据一次性从数据库查出到内存中，在内存中进行逻辑上的分页

物理分页：直接特定的SQL语句，只从数据库中查询出需要的数据

129.mybatis 是否支持延迟加载？延迟加载的原理是什么？

Mybatis 仅支持 association 关联对象和 collection 关联集合对象的延迟加载，association 指的就是一对一，collection 指的就是一对多查询。在 Mybatis配置文件中，可以配置是否启用延迟加载 lazyLoadingEnabled=true|false。它的原理是，使用 CGLIB 创建目标对象的代理对象，当调用目标方法时，进入拦截器方法，比如调用 a.getB().getName()，拦截器 invoke()方法发现 a.getB()是null 值，那么就会单独发送事先保存好的查询关联 B 对象的 sql，把 B 查询上来，然后调用 a.setB(b)，于是 a 的对象 b 属性就有值了，接着完成 a.getB().getName()方法的调用。这就是延迟加载的基本原理。 当然了，不光是 Mybatis，几乎所有的包括 Hibernate，支持延迟加载的原理都 是一样的。

130.说一下 mybatis 的一级缓存和二级缓存？

Mybatis对缓存提供支持，一级缓存是默认使用的，二级缓存需要手动开启。

区别：

一级缓存的作用域是一个sqlsession内； 二级缓存作用域是针对mapper进行缓存； 一级缓存：

在参数和SQL完全一样的情况下，我们使用同一个SqlSession对象调用一个Mapper方法，往往只执行一次SQL，因为使用SelSession第一次查询后，MyBatis会将其放在缓存中，以后再查询的时候，如果没有声明需要刷新，并且缓存没有超时的情况下，SqlSession都会取出当前缓存的数据，而不会再次发送SQL到数据库。

一级缓存时执行commit，close，增删改等操作，就会清空当前的一级缓存；当对SqlSession执行更新操作（update、delete、insert）后并执行commit时，不仅清空其自身的一级缓存（执行更新操作的效果），也清空二级缓存（执行commit()的效果）。

二级缓存：

二级缓存指的就是同一个namespace下的mapper，二级缓存中，也有一个map结构，这个区域就是一级缓存区域。一级缓存中的key是由sql语句、条件、statement等信息组成一个唯一值。一级缓存中的value，就是查询出的结果对象。

131.mybatis 和 hibernate 的区别有哪些？

132.mybatis 有哪些执行器（Executor）？

1.mybatis有三种executor执行器，分别为simpleexecutor、reuseexecutor、batchexecutor。 simpleexecutor执行器：在每执行一次update或select，就开启一个statement对象，用完后就关闭。 reuseexecutor执行器：在执行update或select时以sql作为key去查找statement，有就直接使用，没有就创建，使用完毕后不关闭，放入Map<String,Statement>中，供下次使用。重复使用statement。 batchexecutor执行器：执行update（jdbc批处理不支持select），会把所有sql添加到批处理中addbatch（）；等待统一批处理executorbatch（）；它缓存了·多个statement，每一个statement都是addbatch（），后等待进行executorbatch（）批处理。 作用范围：统一限制在sqlsession生命周期范围内。

133.mybatis 分页插件的实现原理是什么？

Mybatis 使用 RowBounds 对象进行分页，它是针对 ResultSet 结果集执行的内存分页，而非物理分页。可以在 sql 内直接书写带有物理分页的参数来完成物理分页功能，也可以使用分页插件来完成物理分页。

分页插件的基本原理是使用 Mybatis 提供的插件接口，实现自定义插件，在插件的拦截方法内拦截待执行的 sql，然后重写 sql，根据 dialect 方言，添加对应的物理分页语句和物理分页参数。

134.mybatis 如何编写一个自定义插件？

实现原理：

MyBatis 自定义插件针对 MyBatis 四大对象（Executor,StatementHandler,ParamentHandler,ResultSetHandler）进行拦截。

Executor ：拦截内部执行器，它负责调用StatementHandler 操作数据库，并把结果集通过 ResultSetHandler 进行自动映射，另外它还处理了二级缓存的操作。 StatementHandler ：拦截 SQL 语法构建的处理，它是MyBatis 直接和数据库执行 SQL脚本的对象，另外它也实现了 MyBatis一级缓存 ParamenterHandler ：拦截参数的处理。 ResultSetHandler ：拦截结果集的处理。

十四、RabbitMQ

135.rabbitmq 的使用场景有哪些？

RabbitMQ是使用Erlang语言开发的开源消息队列系统，基于AMQP协议来实现。AMQP的主要特征是面向消息、队列、路由(包括点对点和发布/订阅)、可靠性、 安全。AMQP协议更多用在企业系统内，对数据一致性、稳定性和可靠性要求很高的场景，对性能和吞吐量的要求还在其次。

MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。

解耦 当发送短信执行成功后页面才执行倒计时60秒，假如在发送短信时网速原因，导致短信一直被阻塞，那么倒计时也会被一直延迟，这样及其影响用户体验感。 这时候就可以使用RabbitMQ了，将发送短信和倒计时解耦，基于消息的模型，关心的是“通知”，而非“处理”。 像下订单、邮件通知、缓存刷新等操作都可以使用消息队列进行优化。

异步提升效率 场景说明：用户需发送短信验证码时，点击发送短信，第三方平台发送短信至用户手机成功，执行倒计时60秒。传统的做法有两种 1.串行的方式；2.并行方式： （1）串行方式：将用户点击发送短信，第三方平台发送短信至用户手机成功，执行倒计时60秒。以上三个任务全部完成后，返回给客户端（响应150ms）。 （2）并行方式：在用户点击发送短信成功后，第三方平台发送短信的同时，执行倒计时60秒。与串行的差别是，并行的方式可以提高处理的时间（响应100ms）。

（3）引入消息队列，将不是必须的业务逻辑，异步处理（55ms）。改造后的架构如下：

流量削峰 流量削锋（流量错峰）也是消息队列中的常用场景，一般在秒杀或团抢活动中使用广泛。

应用场景：系统其他时间A系统每秒请求量就100个，系统可以稳定运行。系统每天晚间八点有秒杀活动，每秒并发请求量增至5000条，但是系统最大的处理能力只能每秒处理2000个请求（因为MySQL每秒只能处理2000个请求，MySQL的缺点：在海量数据处理与热数据时，效率会显著变慢），于是系统崩溃，服务器宕机。

引入RabbitMQ：系统A从RabbitMQ中慢慢拉取请求，每秒就拉取2000个请求，不要超过自己每秒能处理的请求数量即可。RabbitMQ，每秒5000个请求进来，结果只有2000个请求出去，所以在秒杀期间（将近一小时）可能会有几十万或者几百万的请求积压在RabbitMQ中。这个短暂的高峰期积压是没问题的，因为高峰期过了之后，每秒就只有50个请求进入RabbitMQ了，但是系统还是按照每秒2000个请求的速度在处理，所以说，只要高峰期一过，系统就会快速将积压的消息消费掉。我们在此计算一下，每秒在RabbitMQ积压3000条消息，1分钟会积压18万，1小时积压1000万条消息，高峰期过后，1个多小时就可以将积压的1000万消息消费掉。

136.rabbitmq 有哪些重要的角色？

生产者、消费者和代理

生产者：消息的创建者，负责创建和推送数据到消息服务器

消费者：消息的接收方，用于处理数据和确认消息

代理：就是RabbitMQ本身，用于扮演“快递”的角色，本身不生产消息，只是扮演“快递”的角色

137.rabbitmq 有哪些重要的组件？

ConnectionFactory（连接管理器）：应用程序与Rabbit之间建立连接的管理器，程序代码中使用

Channer（信道）：消息推送使用的通道

Exchange（交换器）：用于接收、分配消息

Queue（队列）：用于存储生产者的消息

RoutingKey（路由键）：用于把生产者的数据分配到交换器上

BindingKey（绑定键）：用于把交换器的消息绑定到队列上

138.rabbitmq 中 vhost 的作用是什么？

vhost可以理解为虚拟brokey，即mini-RabbitMQ server。其内部均含有独立的queue、exchange、bingding等，但最重要的是，其拥有独立的权限系统，可以做到vhost范围的用户控制。当然，从RabbitMQ的全局角度，vhost可以作为不同权限隔离的手段（一个典型的例子就是不同的应用可以跑在不同的vhost中）

139.rabbitmq 的消息是怎么发送的？

首先客户端必须连接到RabbitMQ服务器才能发布和消费消息，客户端和rabbit server之间回创建一个tcp连接，一旦tcp打开并通过了认证（认证就是你发送给rabbit服务器的用户名和密码），你的客户端和RabbitMQ就创建了一条amqp信道（channel），信道是创建在“真实”tcp上的虚拟连接，amqp命令都是通过信道发送出去的，每个信道都会有一个唯一的id，不论是发布消息，订阅队列都是通过这个信道完成的

140.rabbitmq 怎么保证消息的稳定性？

提供了事务的功能。 通过将 channel 设置为 confirm（确认）模式。

141.rabbitmq 怎么避免消息丢失？

消息持久化 ACK确认机制 设置集群镜像模式 消息补偿机制

142.要保证消息持久化成功的条件有哪些？

声明队列必须设置持久化 durable 设置为 true. 消息推送投递模式必须设置持久化，deliveryMode 设置为 2（持久）。 消息已经到达持久化交换器。 消息已经到达持久化队列。

以上四个条件都满足才能保证消息持久化成功。

143.rabbitmq 持久化有什么缺点？

持久化的缺地就是降低了服务器的吞吐量， 因为使用的是磁盘而非内存存储， 从而降低了吞吐量。可尽量使用 ssd 硬盘来缓解吞吐量的问题。

144.rabbitmq 有几种广播类型？

三种广播模式：

1 fanout: 所有bind到此exchange的queue都可以接收消息 （纯广播，绑定到RabbitMQ的接受者都能收到消息）； 2 direct: 通过routingKey和exchange决定的那个唯一的queue可以接收消息； 3 topic: 所有符合routingKey(此时可以是一个表达式)的routingKey所bind的queue可以接收消息；

145.rabbitmq 怎么实现延迟消息队列？

通过消息过期后进入死信交换器， 再由交换器转发到延迟消费队列，实现延迟功能；

使用 RabbitMQ-delayed-message-exchange 插件实现延迟功能。

146.rabbitmq 集群有什么用？

集群主要有以下两个用途：

高可用：某个服务器出现问题，整个 RabbitMQ 还可以继续使用； 高容量：集群可以承载更多的消息量。

147.rabbitmq 节点的类型有哪些？

磁盘节点：消息会存储到磁盘。

内存节点：消息都存储在内存中，重启服务器消息丢失，性能高于磁盘类型

148.rabbitmq 集群搭建需要注意哪些问题？

各节点之间使用“--link”连接，此属性不能忽略。

各节点使用的 erlang cookie 值必须相同，此值相当于“秘钥”的功能，用于各节点的认证。

整个集群中必须包含一个磁盘节点。

149.rabbitmq 每个节点是其他节点的完整拷贝吗？为什么？

不是，原因有以下两个：

存储空间的考虑：如果每个节点都拥有所有队列的完全拷贝， 这样新增节点不但没有新增存储空间，反而增加了更多的冗余数据；

性能的考虑：如果每条消息都需要完整拷贝到每一个集群节点， 那新增节点并没有提升处理消息的能力，最多是保持和单节点相同的性能甚至是更糟。

150.rabbitmq 集群中唯一一个磁盘节点崩溃了会发生什么情况？

如果唯一磁盘的磁盘节点崩溃了，不能进行以下操作：

不能创建队列 不能创建交换器 不能创建绑定 不能添加用户 不能更改权限 不能添加和删除集群节点

唯一磁盘节点崩溃了，集群是可以保持运行的，但你不能更改任何东西

151.rabbitmq 对集群节点停止顺序有要求吗？

RabbitMQ 对集群的停止的顺序是有要求的，

应该先关闭内存节点，最后再关闭磁盘节点。如果顺序恰好相反的话，可能会造成消息的丢失。

十五、Kafka

152.kafka 可以脱离 zookeeper 单独使用吗？为什么？

kafka 不能脱离 zookeeper 单独使用，

因为 kafka 使用 zookeeper 管理和协调 kafka 的节点服务器。

153.kafka 有几种数据保留的策略？

kafka 有两种数据保存策略：

按照过期时间保留 按照存储的消息大小保留。

154.kafka 同时设置了 7 天和 10G 清除数据，到第五天的时候消息达到了 10G，这个时候 kafka 将如何处理？

这个时候 kafka 会执行数据清除工作，时间和大小不论那个满足条件，都会清空数据。

155.什么情况会导致 kafka 运行变慢？

cpu 性能瓶颈

磁盘读写瓶颈

网络瓶颈

156.使用 kafka 集群需要注意什么？

集群的数量不是越多越好，最好不要超过 7 个，

因为节点越多，消息复制需要的时间就越长，整个群组的吞吐量就越低。

十六、Zookeeper

157.zookeeper 是什么？

ZooKeeper是一个经典的分布式数据一致性解决方案，致力于为分布式应用提供一个高性能、高可用，且具有严格顺序访问控制能力的分布式协调服务。 分布式应用程序可以基于ZooKeeper实现数据发布与订阅、负载均衡、命名服务、分布式协调与通知、集群管理、Leader选举、分布式锁、分布式队列等功能。

158.zookeeper 都有哪些功能？

1.统一命名服务 分布式应用中，通常需要有一套完整的命名规则，既能够产生唯一的命名又便于识别和记住，或许你并不需要将名称关联到特定资源上，你可能只需要一个不会重复的名称，就像数据库中产生的唯一的数字主键一样。 NameService已经是Zookeeper内置的功能，你只要调用Zookeeper的API就能实现，如调用create接口就可以很容易的创建一个目录节点。

2.配置管理 配置管理的在分布式应用环境下很常见,例如同一个应用系统需要多台PC Server运行,但是他们运行的应用系统的某些配置是相同的,如果要修改这个相同的配置项,那么就必须同时修改每台运行这个系统的PC Server这样非常麻烦而且容易出错。 像这样的配置信息完全可以交给Zookeeper来管理,将配置信息保存在Zookeeper的某个目录节点中,然后将所有需要修改的应用及其监控配置信息的状态,一旦配置信息发生变化,每台应用及其就会收到ZooKeeper的通知,然后从Zookeeper的通知,然后从Zookeeper获取新的配置信息应用到系统中。

3.集群管理 Zookeeper能够很容易的实现集群管理的功能,如有多台Server组成一个服务集群,那么必须要一个总管知道当前及权重每台机器的服务状态,一旦有机器不能提供服务,集群中其他集群必须知道,从而做出调整重新分配服务政策.同样增加集群的服务能力时,就会增加一台或者多台server,同样也必须让总管知道. Zookeeper不仅能够帮你维护当前的集群中机器的服务状态,而且能够帮你选出一个’总管’,让这个总管来管理集群,这就是Zookeeper的另一个功能 Leader Election。

4.队列管理 （1）当一个队列的成员都聚齐时，这个队列才可用，否则一直等待所有成员到达，这种是同步队列。 （2）队列按照 FIFO 方式进行入队和出队操作，例如实现生产者和消费者模型。

159.zookeeper 有几种部署模式？

1. 单机模式：zoo.cfg 中只配置一个 server.id 就是单机模式了，此模式一般用在测试环境，如果当前主机宕机，那么所有依赖于当前 ZooKeeper 服务工作的其他服务器都不能进行正常工作；

2. 伪分布式模式：在一台机器启动不同端口的 ZooKeeper，配置到 zoo.cfg 中，和单击模式相同，此模式一般用在测试环境；

3. 分布式模式：多台机器各自配置 zoo.cfg 文件，将各自互相加入服务器列表，上面搭建的集群就是这种完全分布式。

160.zookeeper 怎么保证主从节点的状态同步？

Zookeeper 的核心是原子广播机制，这个机制保证了各个 server 之间的同步。实现这个机制的协议叫做 Zab 协议。Zab 协议有两种模式，它们分别是恢复模式和广播模式。 恢复模式 当服务启动或者在领导者崩溃后，Zab就进入了恢复模式，当领导者被选举出来，且大多数 server 完成了和 leader 的状态同步以后，恢复模式就结束了。状态同步保证了 leader 和 server 具有相同的系统状态。 广播模式 一旦 leader 已经和多数的 follower 进行了状态同步后，它就可以开始广播消息了，即进入广播状态。这时候当一个 server 加入 ZooKeeper 服务中，它会在恢复模式下启动，发现 leader，并和 leader 进行状态同步。待到同步结束，它也参与消息广播。ZooKeeper 服务一直维持在 Broadcast 状态，直到 leader 崩溃了或者 leader 失去了大部分的 followers 支持。

161.集群中为什么要有主节点？

在分布式环境中，有些业务逻辑只需要集群中的某一台机器进行执行，

其他的机器可以共享这个结果，这样可以大大减少重复计算，提高性能，所以就需要主节点。

162.集群中有 3 台服务器，其中一个节点宕机，这个时候 zookeeper 还可以使用吗？

可以继续使用，单数服务器只要没超过一半的服务器宕机就可以继续使用。

163.说一下 zookeeper 的通知机制？

客户端端会对某个 znode 建立一个 watcher 事件，

当该 znode 发生变化时，这些客户端会收到 zookeeper 的通知，

然后客户端可以根据 znode 变化来做出业务上的改变。

十七、MySql

164.数据库的三范式是什么？

第一范式：强调的是列的原子性，就是列不能够再分成其他几列；

第二范式：一是表必须有一个主键；二是没有包含在主键中的列必须完全依赖于主键，而不能只依赖主键的一部分；

第三范式：任何非主属性不依赖于其他非主属性。

165.一张自增表里面总共有 7 条数据，删除了最后 2 条数据，重启 mysql 数据库，又插入了一条数据，此时 id 是几？

• 表类型如果是MyISAM，那 id 就是8.

• 表类型如果是 InnoDB，那id就是6.

InnoDB 表只会把自增主键的最大id记录在内存中，所以重启之后会导致最大的 id 丢失。

166.如何获取当前数据库版本？

使用 select version() 获取当前 MySQL 的数据库版本

167.说一下 ACID 是什么？

• Atomicity（原子性）：一个事务（transaction）中的所有操作，或者全部完成，或者全部不能完成，不会结束在中间的某个环节，就像事务从来没有执行过一样。即，事务不可分割，不可约简。

• Consistency（一致性）：在事务开始之前和事务结束之后，数据库的完整性没有被破坏，这表示写入的资料必须完全符合所有预设约束、触发器、级联回滚等。

• Isolation（隔离性）：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。事务的隔离分为不同的级别，包括读未提交（Read uncommitted）、读提交（Read committed）、可重复读（repeatable read）和串行化（Serializable）

• Durability（持久性）：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

168.char 和 varchar 的区别是什么？

• char(n)：固定长度类型，比如订阅char(10)，当你输入"abc"三个字符的时候，它们占的空间还是10个字节，其他7个字节是空字节。

char优点：效率高； char缺点：占用空间； 适用场景：存储密码的md5值，固定长度的，适用char非常合适。

• varchar(n)：可变长度，存储的值是每个值占用的字节再加上一个用来记录其长度的字节的长度。

所以，从空间上考虑varchar比较合适；从效率 考虑char比较合适，二者适用需要权衡。

169.float 和 double 的区别是什么？

• float 最多存储8位的十进制数，并在内存中占4字节

• double 最多可以存储16位的十进制数，并在内存中占8字节。

170.mysql 的内连接、左连接、右连接有什么区别？

内连接关键字：inner join； 左连接关键字：left join； 右连接关键字：right join；

内连接是把匹配的关联数据显示出来；左连接是左边的表全部显示出来，右边的表显示出符合条件的数据；右连接正好相反。

171.mysql 索引是怎么实现的？

索引是满足某种特定查找算法的数据结构，而这些数据结构会以某种方式指向数据，从而实现高效查找数据。

具体来说 MySQL 中的索引，不同的数据引擎实现偶不同，但目前主流的数据库引擎索引就是 B+数实现的，B+数的搜索效率，可以达到二分法 性能，找到数据区域之后就找到了完整的数据结构了，所以索引的性能也是更好的。

172.怎么验证 mysql 的索引是否满足需求？

使用 explain 查看SQL是如何执行查询语句的，从而分析你的索引是否满足需求。

explain 语法： explain select * from table where type=1;

173.说一下数据库的事务隔离？

MySQL 的事务隔离是在 MySQL.ini配置文件里添加的，在文件的最后添加

transaction-isolation = REPEATABLE-READ

可用的配置值：READ-UNCOMMITED、READ-COMMINTTED、REPEATABLE-READ、SERIALIZABLE.

• READ-UNCOMMITED：读未提交，最低的隔离级别。事务未提交前，就可以被其他事务读取（会出现幻读，脏读，不可重复读）

• READ-COMMINTTED：读已提交，一个事务提交后才能被其他事务读取到（会出现幻读，不可重复读）

• REPEATABLE-READ：可重复读，默认级别，保证多次读取同一个数据时，其值都和事务开始时候的内容是一致的，禁止读取到别的事务未提交的数据（会出现幻读）

• SERIALIZABLE：串行化，代价最高最可靠的隔离级别，该隔离级别能防止脏读，不可重复读，幻读。

脏读：表示一个事务能够读取另一个还未提交的数据。比如，某个事务尝试插入记录A，此时此事务还未提交，然后另外一个事务尝试读到了记录A。

不可重复读：表示一个事务范围内两个相同的查询却返回了不同数据。

幻读：表示一个事务多次查询返回的结果集不一样。比如同一个事务A第一次查询时有n条记录，但是第二次同等条件下查询却有n+1条记录，这就好像产生了幻觉。发生幻读的原因也是另外一个事务新增或者删除或者修改了第一个事务结果集里面的数据，同一个记录的数据内容被修改了，所有数据行的记录就变多或者变少了。

---

不可重复读和幻读的区别：

幻读的重点在于新增或者删除，不可重复读的重点是修改

如果使用锁机制来实现这两种隔离级别，在可重复读中，该sql第一次读取到数据后，就将这些数据加锁，其它事务无法修改这些数据，就可以实现可重复读了。但这种方法却无法锁住insert和delete的数据，所以当事务A先前读取了数据，或者修改了全部数据，事务B还是可以insert数据提交，这时事务A就会发现莫名其妙多了一条之前没有的数据，这就是幻读，不能通过行锁来避免。需要Serializable隔离级别 ，读用读锁，写用写锁，读锁和写锁互斥，这么做可以有效的避免幻读、不可重复读、脏读等问题，但会极大的降低数据库的并发能力。

所以说不可重复读和幻读最大的区别，就在于如何通过锁机制来解决他们产生的问题。

上文说的，是使用悲观锁机制来处理这两种问题，但是MySQL、ORACLE、PostgreSQL等成熟的数据库，出于性能考虑，都是使用了以乐观锁为理论基础的MVCC（多版本并发控制）来避免这两种问题。

174.说一下 mysql 常用的引擎？

• InnoDB 引擎：InnoDB引擎提供了对数据库acid事务的支持，并且还提供了行级锁和外键的约束，它的设计的目的就是处理大数据量的数据库系统。MySQL 运行的时候，InnoDB会在内存中建立缓冲池，用于缓冲数据和索引。但是该引擎不支持全文搜索，同时启动也比较慢，它是不会保存表的行数的，所以当进行 select count(*) from table 指令的时候，需要进行扫描全表。由于锁的粒度小，写操作是不会锁定全表的，所以在并发度较高的场景下使用会提升效率。MySQL5.5以后默认使用InnoDB存储引擎。

• MyIASM 引擎：不提供事务的支持，也不支持行级锁和外键。因此当执行插入和更新语句时，即执行写操作的时候需要锁定这个表，所以会导致效率降低。不过和InnoDB不同的是，MyIASM 引擎保存了表的行数，于是当进行 select count(*) from table 语句时，可以直接读取已经保存的值而不需要进行扫描全表。所以，如果表的读操作远远多于写操作时，并且不需要事务的支持的，可以将 MyIASM 作为数据库引擎的首选。

175.说一下 mysql 的行锁和表锁？

MyIASM 只支持表锁，InnoDB支持表锁和行锁，默认为行锁。

• 表级锁：开销小，加锁快，不会出现死锁。锁定力度大，发生锁冲突的概率最高，并发量最低。

• 行级锁：开销大，加锁慢，会出现死锁。锁粒度小，发生锁冲突的概率小，并发度最高。

176.说一下乐观锁和悲观锁？

• 乐观锁：每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在提交更新的时候会判断一下在此期间别人有没有去更新这个数据。

• 悲观锁：每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻止，直到这个锁被释放。

数据库的乐观锁需要自己实现，在表里添加一个version字段，每次修改成功值加1，这样每次修改的时候先对比一下，自己拥有的version和数据库现在的version是否一致，如果不一致就不修改，这样就实现了乐观锁。

两种锁的使用场景 从上面对两种锁的介绍，我们知道两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下（多读场景），即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断的进行retry，这样反倒是降低了性能，所以一般多写的场景下用悲观锁就比较合适。

177.mysql 问题排查都有哪些手段？

• 使用 show processlist 命令查看当前所有连接信息。

• 使用 explain 命令查看SQL语句执行计划。

• 开启慢查询日志，查看慢查询的SQL。

178.如何做 mysql 的性能优化？

• 为搜索字段创建索引。

• 避免使用 select * ，列出需要查询的字段。

• 垂直分割分表

• 选择正确的存储引擎。

十八、Redis

179.redis 是什么？都有哪些使用场景？

Redis是一个开源的使用ANSI C语言编写、支持网络、 可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

Redis 使用场景：

数据高并发的读写 海量数据的读写 对扩展性要求高的数据

180.redis 有哪些功能？

数据缓存功能

分布式锁的功能

支持数据持久化

支持事务

支持消息队列

181.redis 和 memecache 有什么区别？

memcached所有的值均是简单的字符串， redis作为其替代者，支持更为丰富的数据类型

redis的速度比memcached快很多 redis可以持久化其数据

182.redis 为什么是单线程的？

因为cpu不是Redis的瓶颈，Redis的瓶颈最有可能是机器内存或者网络带宽。既然单线程容易实现，而且cpu又不会成为瓶颈，那就顺理成章地采用单线程的方案了

关于Redis的性能，官方网站也有，普通笔记本轻松处理每秒几十万的请求

而且单线程并不代表就慢 nginx和nodejs也都是高性能单线程的代表

183.什么是缓存穿透？怎么解决？

缓存穿透：指查询一个一定不存在的数据，由于缓存是不命中时需要从数据库查询，查不到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到数据库去查询，造成缓存穿透

解决方案：最简单粗暴的方法如果一个查询返回的数据为空（不管是数据不存在，还是系统故障），我们就把这个空结果进行缓存，但它的过期时间会很短，最长不超过五分钟

184.redis 支持的数据类型有哪些？

string、 list、 hash、 set、 zset。

185.redis 支持的 java 客户端都有哪些？

Redisson、 Jedis、 lettuce等等，官方推荐使用Redisson

186.jedis 和 redisson 有哪些区别？

Jedis是Redis的Java实现的客户端，其API提供了比较全面的Redis命令的支持

Redisson实现了分布式和可扩展的Java数据结构，和Jedis相比，功能较为简单，不支持字符串操作，不支持排序、事务、管道、分区等Redis特性。Redisson的宗旨是促进使用者对Redis的关注分离，从而让使用者能够将精力更集中地放在处理业务逻辑上

187.怎么保证缓存和数据库数据的一致性？

合理设置缓存的过期时间。

新增、更改、删除数据库操作时同步更新 Redis，

可以使用事物机制来保证数据的一致性。

188.redis 持久化有几种方式？

Redis 的持久化有两种方式，或者说有两种策略：

RDB（Redis Database）：指定的时间间隔能对你的数据进行快照存储。

AOF（Append Only File）：每一个收到的写命令都通过write函数追加到文件中。

189.redis 怎么实现分布式锁？

Redis分布式锁其实就是在系统里面占一个“坑”，其他程序也要占“坑”的时候，占用成功了就可以继续执行，失败了就只能放弃或稍后重试

占坑一般使用 setnx(set if not exists)指令，只允许被一个程序占有，使用完调用del释放锁

190.redis 分布式锁有什么缺陷？

Redis 分布式锁不能解决超时的问题，

分布式锁有一个超时时间，程序的执行如果超出了锁的超时时间就会出现问题。

191.redis 如何做内存优化？

尽可能使用散列表（hashes），散列表（是说散列表里面存储的数少）使用的内存非常小，所以你应该尽可能 的将你的数据模型抽象到一个散列表里面

比如你的web系统中有一个用户对象，不要为这个用户的名称，姓氏，邮箱，密码设置单独的key,而是应该把这个用户的所有信息存储到一张散列表里面

192.redis 淘汰策略有哪些？

volatile-lru：从已设置过期时间的数据集（server.db[i].expires）中挑选最近最少使用的数据淘汰

volatile-ttl:从已设置过期时间的数据集（server.db[i].expires）中挑选将要过期的数据淘汰

volatile-random:从已设置过期时间的数据集（server.db[i].expires）中任意选择数据淘汰

allkeys-lru:从数据集（server.db[i].dict）中挑选最近最少使用的数据淘汰

allkeys-random:从数据集（server.db[i].dict）中任意选择数据淘汰

no-enviction(驱逐)：禁止驱逐数据

193.redis 常见的性能问题有哪些？该如何解决？

主服务器写内存快照，会阻塞主线程的工作，当快照比较大时，对性能影响是非常大的，会间断性暂停服务，所以主服务器最好不要写内存快照

Redis主从复制的性能问题，为了主从复制的速度和连接的稳定性，主从库最好在同一个局域网内

redis的缓存击穿

缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期）， 这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据， 引起数据库压力瞬间增大，造成过大压力

解决方案：

设置热点数据永远不过期。 加互斥锁

缓存穿透

缓存穿透

描述：

   缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，
   如发起为id为“-1”的数据或id为特别大不存在的数据。
  这时的用户很可能是攻击者，攻击会导致数据库压力过大。

解决方案：

  接口层增加校验，如用户鉴权校验，id做基础校验，id<=0的直接拦截；
  从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为key-null，
  缓存有效时间可以设置短点，如30秒（设置太长会导致正常情况也没法使用）。
  这样可以防止攻击用户反复用同一个id暴力攻击

缓存雪崩

描述：

  缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。
 
  和缓存击穿不同的是， 缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。

解决方案：

 缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。
 
 如果缓存数据库是分布式部署，将热点数据均匀分布在不同搞得缓存数据库中。
 
 设置热点数据永远不过期。

十九、JVM

194.说一下 jvm 的主要组成部分？及其作用？

JVM包括类加载子系统、堆、方法区、栈、本地方法栈、程序计数器、直接内存、垃圾回收器、执行引擎。

1、类加载子系统 类加载子系统负责加载class信息，加载的类信息存放于方法区中。

2、直接内存 直接内存是在Java堆外的、直接向系统申请的内存空间。访问直接内存的速度会由于Java堆。出于性能的考虑，读写频繁的场合可能会考虑使用直接内存。

3、垃圾回收器 垃圾回收器可以对堆、方法区、直接内存进行回收。

4、执行引擎 执行引擎负责执行虚拟机的字节码，虚拟机会使用即时编译技术将方法编译成机器码后再执行。

196.说一下堆栈的区别？

功能方面：堆是用来存放对象的，栈是用来执行程序的。

· 共享性：堆是线程共享的，栈是线程私有的。

· 空间大小：堆大小远远大于栈。

197.队列和栈是什么？有什么区别？

（1）队列先进先出，栈先进后出。

（2）遍历数据速度不同。

栈只能从头部取数据 也就最先放入的需要遍历整个栈最后才能取出来，而且在遍历数据的时候还得为数据开辟临时空间，保持数据在遍历前的一致性；

队列则不同，他基于地址指针进行遍历，而且可以从头或尾部开始遍历，但不能同时遍历，无需开辟临时空间，因为在遍历的过程中不影像数据结构，速度要快的多。

198.什么是双亲委派模型？

当类加载器（Class-Loader）试图加载某个类型的时候，除非父加载器找不到相应类型，否则尽量将这个任务代理给当前加载器的父加载器去做。 使用委派模型的目的

1. 避免重复加载

2. 保障加载的安全性

199.说一下类加载的执行过程？

类加载的过程主要分为三个部分：

• 加载

• 链接

• 初始化

而链接又可以细分为三个小部分：

• 验证

• 准备

• 解析

加载 简单来说，加载指的是把class字节码文件从各个来源通过类加载器装载入内存中。

这里有两个重点：

字节码来源。一般的加载来源包括从本地路径下编译生成的.class文件，从jar包中的.class文件，从远程网络，以及动态代理实时编译

类加载器。一般包括启动类加载器，扩展类加载器，应用类加载器，以及用户的自定义类加载器。

注：为什么会有自定义类加载器？

一方面是由于java代码很容易被反编译，如果需要对自己的代码加密的话，可以对编译后的代码进行加密，然后再通过实现自己的自定义类加载器进行解密，最后再加载。

另一方面也有可能从非标准的来源加载代码，比如从网络来源，那就需要自己实现一个类加载器，从指定源进行加载。

验证 主要是为了保证加载进来的字节流符合虚拟机规范，不会造成安全错误。

包括对于文件格式的验证，比如常量中是否有不被支持的常量？文件中是否有不规范的或者附加的其他信息？

对于元数据的验证，比如该类是否继承了被final修饰的类？类中的字段，方法是否与父类冲突？是否出现了不合理的重载？

对于字节码的验证，保证程序语义的合理性，比如要保证类型转换的合理性。

对于符号引用的验证，比如校验符号引用中通过全限定名是否能够找到对应的类？校验符号引用中的访问性（private，public等）是否可被当前类访问？

准备 主要是为类变量（注意，不是实例变量）分配内存，并且赋予初值。

特别需要注意，初值，不是代码中具体写的初始化的值，而是Java虚拟机根据不同变量类型的默认初始值。

比如8种基本类型的初值，默认为0；引用类型的初值则为null；常量的初值即为代码中设置的值，final static tmp = 456， 那么该阶段tmp的初值就是456

解析 将常量池内的符号引用替换为直接引用的过程。

两个重点：

符号引用。即一个字符串，但是这个字符串给出了一些能够唯一性识别一个方法，一个变量，一个类的相关信息。

直接引用。可以理解为一个内存地址，或者一个偏移量。比如类方法，类变量的直接引用是指向方法区的指针；而实例方法，实例变量的直接引用则是从实例的头指针开始算起到这个实例变量位置的偏移量

举个例子来说，现在调用方法hello()，这个方法的地址是1234567，那么hello就是符号引用，1234567就是直接引用。

在解析阶段，虚拟机会把所有的类名，方法名，字段名这些符号引用替换为具体的内存地址或偏移量，也就是直接引用。

初始化 这个阶段主要是对类变量初始化，是执行类构造器的过程。

换句话说，只对static修饰的变量或语句进行初始化。

如果初始化一个类的时候，其父类尚未初始化，则优先初始化其父类。

如果同时包含多个静态变量和静态代码块，则按照自上而下的顺序依次执行。

200.怎么判断对象是否可以被回收？

·引用计数法(feference-countint) : 每个对象有一个引用计数器，当对象被引用一次则计数器就加1，当对象引用失效一次则计数器减1，对于计数器为0的对象就意味着可以被回收。

·可达性分析算法(GC Root Tracing) ： 从GC Roots 作为起点开始搜索，能和GC Roots根直接相连的对象都被标记为非垃圾对象，其余未标记的都是垃圾对象。

哪些对象可以作为GC Roots根节点： 栈的本地变量表所引用的对象、方法区的静态变量和常量所引用的对象、本地方法栈中所引用的对象。

201.java 中都有哪些引用类型？

1、强引用：发生GC的时候不会被回收。 2、软引用：有用但不是必须的对象，在发生内存溢出之前会被回收。 3、弱引用：有用但不是必须的对象，在下一次GC的时候会被回收。 4、虚引用：无法通过虚引用获得对象，用PhantomReference实现虚引用，虚引用的用途是在GC时返回一个通知。

202.说一下 jvm 有哪些垃圾回收算法？

常用的垃圾回收算法有如下四种：标记-清除、复制、标记-整理和分代收集。

标记-清除算法 从算法的名称上可以看出，这个算法分为两部分，标记和清除。首先标记出所有需要被回收的对象，然后在标记完成后统一回收掉所有被标记的对象。

这个算法简单，但是有两个缺点：一是标记和清除的效率不是很高；二是标记和清除后会产生很多的内存碎片，导致可用的内存空间不连续，当分配大对象的时候，没有足够的空间时不得不提前触发一次垃圾回收。

复制算法 这个算法将可用的内存空间分为大小相等的两块，每次只是用其中的一块，当这一块被用完的时候，就将还存活的对象复制到另一块中，然后把原已使用过的那一块内存空间一次回收掉。这个算法常用于新生代的垃圾回收。

复制算法解决了标记-清除算法的效率问题，以空间换时间，但是当存活对象非常多的时候，复制操作效率将会变低，而且每次只能使用一半的内存空间，利用率不高。

标记-整理算法 这个算法分为三部分：一是标记出所有需要被回收的对象；二是把所有存活的对象都向一端移动；三是把所有存活对象边界以外的内存空间都回收掉。

标记-整理算法解决了复制算法多复制效率低、空间利用率低的问题，同时也解决了内存碎片的问题。

分代收集算法 根据对象生存周期的不同将内存空间划分为不同的块，然后对不同的块使用不同的回收算法。一般把Java堆分为新生代和老年代，新生代中对象的存活周期短，只有少量存活的对象，所以可以使用复制算法，而老年代中对象存活时间长，而且对象比较多，所以可以采用标记-清除和标记-整理算法。

203.说一下 jvm 有哪些垃圾回收器？

一、串行垃圾回收器

在JDK1.3之前，单线程回收器是唯一的选择。它的单线程意义不仅仅是说它只会使用一个CPU或一个手机线程去完成垃圾收集工作。而且它进行垃圾回收的时候，必须暂停其它所有的工作线程（Stop The World,STW），直到它收集完成。它适合Client模式的应用，在单CPU环境下，它效率高效，由于没有线程交互的开销，专心垃圾收集自然可以获得最高的单线程效率。

串行的垃圾收集器有两种，Serial和Serial Old，一般两者搭配使用。

新生代采用Serial，是利用复制算法；老年代使用Serial Old采用标记-整理算法。Client应用或者命令行程序可以通过

-XX:+UseSerialGC开启串行垃圾回收器。

二、并行垃圾回收器

并行垃圾回收器是通过多线程进行垃圾收集的。也会暂停其它所有的工作线程（Stop The World,STW）。适合Server模式以及多CPU环境。一般会和JDK1.5之后出现的CMS搭配使用。并行的垃圾回收器有以下几种：

ParNew：Serial收集器的多线程版本，默认开启的收集线程数和CPU数量一样，运行数量可以通过修改ParallelGCThreads设定。用于新生代手机，复制算法。用-XX:+UseParNewGC,和Serial Old收集器组合进行内存回收。

Parallel Scavenge: 关注吞吐量，吞吐量优先，吞吐量=代码运行时间/（代码运行时间+垃圾收集时间），也就是高效率利用CPU时间，尽快完成程序的运算任务可以升值最大停顿时间MaxGCPauseMillis以及，吞吐量大小GCTimeRatio。如果设置了-XX:+UseAdaptiveSizePolicy参数，则随着GC,会动态调整新生代的大小，Eden,Survivor比例等，以提供最合适的停顿时间或者最大的吞吐量。用于新生代收集，复制算法。通过-XX:+UseParallelGC参数，Server模式下默认提供了其和SerialOld进行搭配的分代收集方式。

Parllel Old：Parallel Scavenge的老年代版本。JDK 1.6开始提供的。在此之前Parallel Scavenge的地位也很尴尬，而有了Parllel Old之后，通过-XX:+UseParallelOldGC参数使用Parallel Scavenge + Parallel Old器组合进行内存回收。

三、CMS收集器

CMS（Concurrent Mark Sweep）收集器是一种以获得最短回收停顿时间为目标的收集器。从名字就能知道它是标记-清除算法的。但是它比一般的标记-清除算法要复杂一些，分为以下4个阶段：

1. 初始标记：标记一下GC Roots能直接关联到的对象，会"Stop The World"。

2. 并发标记：GC Roots Tracing，可以和用户线程并发执行。

3. 重新标记：标记期间产生的对象存活的再次判断，修正对这些对象的标记，执行时间相对并发标记短，会“Stop The World”。

4. 并发清除：清除对象，可以和用户线程并发执行。

由于垃圾回收线程可以和用户线程同时运行，也就是说它是并发的，那么它会对CPU的资源非常敏感，CMS默认启动的回收线程数是（CPU数量+3）/ 4，当CPU<4个时，并发回收是垃圾收集线程就不会少于25%，而且随着CPU减少而增加，这样会影响用户线程的执行。而且由于它是基于标记-清除算法的，那么就无法避免空间碎片的产生。CMS收集器无法处理浮动垃圾（Floating Garbage），可能出现“Concurrent Mode Failure”失败而导致另一次Full GC的产生。

所谓浮动垃圾，在CMS并发清理阶段用户线程还在运行着，伴随程序运行自然还会有新的垃圾不断产生，这一部分垃圾出现在标记过程之后，CMS无法在当次收集中处理掉它们，只能留待下一次GC时再清理掉。

四、G1垃圾收集器

1、G1垃圾收集器

把G1单独拿出来的原因是其比较复杂，在JDK 1.7确立是项目目标，在JDK 7u2版本之后发布，并在JDK 9中成为了默认的垃圾回收器。通过“-XX:+UseG1GC”启动参数即可指定使用G1 GC。

G1从整体看还是基于标记-清除算法的，但是局部上是基于复制算法的。这样就意味者它空间整合做的比较好，因为不会产生空间碎片。G1还是并发与并行的，它能够充分利用多CPU、多核的硬件环境来缩短“stop the world”的时间。G1还是分代收集的，但是G1不再像上文所述的垃圾收集器，需要分代配合不同的垃圾收集器，因为G1中的垃圾收集区域是“分区”（Region）的。G1的分代收集和以上垃圾收集器不同的就是除了有年轻代的ygc，全堆扫描的full GC外，还有包含所有年轻代以及部分老年代Region的Mixed GC。G1还可预测停顿，通过调整参数，制定垃圾收集的最大停顿时间。

G1收集器的运作大致可以分为以下步骤：初始标记、并发标记、最终标记、筛选回收。其中初始标记阶段仅仅只是标记一下GC Roots能直接关联到的对象，并且修改TAMS（Next Top at Mark Set）的值，让下一个阶段用户程序并发运行时，能在正确可用的Region中创建新对象，这个阶段需要STW，但耗时很短。并发标记阶段是从GC Roots开始对堆中对象进行可达性分析，找到存活的对象，这阶段耗时较长，但是可以和用户线程并发运行。最终标记阶段则是为了修正在并发标记期间因用户程序继续运行而导致标记产生变化的那一部分标记记录，虚拟机将这段时间对象变化记录在线程Remembered Set Logs里面，最终标记需要把Remembered Set Logs的数据合并到Remembered Sets中，这阶段需要暂停线程，但是可并行执行。最后的筛选回收阶段首先对各个Region的回收价值和成本进行排序，根据用户所期望的GC停顿时间来确定回收计划。

2、G1分区的概念

G1的堆区在分代的基础上，引入分区的概念。G1将堆分成了若干Region,以下和”分区”代表同一概念。（这些分区不要求是连续的内存空间）Region的大小可以通过G1HeapRegionSize参数进行设置，其必须是2的幂，范围允许为1Mb到32Mb。 JVM的会基于堆内存的初始值和最大值的平均数计算分区的尺寸，平均的堆尺寸会分出约2000个Region。分区大小一旦设置，则启动之后不会再变化。

Eden regions(年轻代-Eden区)

Survivor regions(年轻代-Survivor区)

Old regions（老年代）

Humongous regions（巨型对象区域）

Free regions（未分配区域，也会叫做可用分区）-上图中空白的区域

G1中的*巨型对象*是指，占用了Region容量的50%以上的一个对象。Humongous区，就专门用来存储巨型对象。如果一个H区装不下一个巨型对象，则会通过连续的若干H分区来存储。因为巨型对象的转移会影响GC效率，所以并发标记阶段发现巨型对象不再存活时，会将其直接回收。ygc也会在某些情况下对巨型对象进行回收。

分区可以有效利用内存空间，因为收集整体是使用“标记-整理”，Region之间基于“复制”算法，GC后会将存活对象复制到可用分区（未分配的分区），所以不会产生空间碎片。

3、G1 GC的分类和过程

JDK10 之前的G1中的GC只有Young GC,Mixed GC。Full GC处理会交给单线程的Serial Old垃圾收集器。

4、Young GC年轻代收集

在分配一般对象（非巨型对象）时，当所有Eden region使用达到最大阀值并且无法申请足够内存时，会触发一次Young GC。每次Young GC会回收所有Eden以及Survivor区，并且将存活对象复制到Old区以及另一部分的Survivor区。到Old区的标准就是在PLAB中得到的计算结果。因为Young GC会进行根扫描，所以会stop the world。

Young GC的回收过程如下：

1、根扫描,跟CMS类似，Stop the world，扫描GC Roots对象。

2、处理Dirty card,更新RSet.

3、扫描RSet,扫描RSet中所有old区对扫描到的young区或者survivor去的引用。

4、拷贝扫描出的存活的对象到survivor2/old区

5、处理引用队列，软引用，弱引用，虚引用

5、Mix GC混合收集

Mixed GC是G1 GC特有的，跟Full GC不同的是Mixed GC只回收部分老年代的Region。哪些old region能够放到CSet里面，有很多参数可以控制。比如G1HeapWastePercent参数，在一次young GC之后，可以允许的堆垃圾百占比，超过这个值就会触发mixed GC。

G1MixedGCLiveThresholdPercent参数控制的，old代分区中的存活对象比，达到阀值时，这个old分区会被放入CSet。

Mixed GC一般会发生在一次Young GC后面,为了提高效率，Mixed GC会复用Young GC的全局的根扫描结果，因为这个Stop the world过程是必须的，整体上来说缩短了暂停时间。

Mix GC的回收过程可以理解为Young GC后附加的全局concurrent marking，全局的并发标记主要用来处理old区（包含H区）的存活对象标记，过程如下：

\1. 初始标记（Initial Mark）。标记GC Roots，会STW,一般会复用Young GC的暂停时间。如前文所述，初始标记会设置好所有分区的NTAMS值。

\2. 根分区扫描（Root Region Scan）。这个阶段GC的线程可以和应用线程并发运行。其主要扫描初始标记以及之前Young GC对象转移到的Survivor分区，并标记Survivor区中引用的对象。所以此阶段的Survivor分区也叫根分区（Root Region）。

\3. 并发标记（Concurrent Mark）。会并发标记所有非完全空闲的分区的存活对象，也即使用了SATB算法，标记各个分区。

\4. 最终标记（Remark）。主要处理SATB缓冲区，以及并发标记阶段未标记到的漏网之鱼（存活对象），会STW,可以参考上文的SATB处理。

\5. 清除阶段（Clean UP）。上述SATB也提到了，会进行bitmap的swap，以及PTAMS,NTAMS互换。整理堆分区，调整相应的RSet（比如如果其中记录的Card中的对象都被回收，则这个卡片的也会从RSet中移除）,如果识别到了完全空的分区，则会清理这个分区的RSet。这个过程会STW。

清除阶段之后，还会对存活对象进行转移（复制算法），转移到其他可用分区，所以当前的分区就变成了新的可用分区。复制转移主要是为了解决分区内的碎片问题。

6、Full GC

G1在对象复制/转移失败或者没法分配足够内存（比如巨型对象没有足够的连续分区分配）时，会触发Full GC。Full GC使用的是stop the world的单线程的Serial Old模式,所以一旦触发Full GC则会STW应用线程，并且执行效率很慢。JDK 8版本的G1是不提供Full GC的处理的。对于G1 GC的优化，很大的目标就是没有Full GC。

204.详细介绍一下 CMS 垃圾回收器？

CMS（Concurrent Mark Sweep）收集器是一种以获得最短回收停顿时间为目标的收集器。从名字就能知道它是标记-清除算法的。但是它比一般的标记-清除算法要复杂一些，分为以下4个阶段：

1. 初始标记：标记一下GC Roots能直接关联到的对象，会"Stop The World"。

2. 并发标记：GC Roots Tracing，可以和用户线程并发执行。

3. 重新标记：标记期间产生的对象存活的再次判断，修正对这些对象的标记，执行时间相对并发标记短，会“Stop The World”。

4. 并发清除：清除对象，可以和用户线程并发执行。

由于垃圾回收线程可以和用户线程同时运行，也就是说它是并发的，那么它会对CPU的资源非常敏感，CMS默认启动的回收线程数是（CPU数量+3）/ 4，当CPU<4个时，并发回收是垃圾收集线程就不会少于25%，而且随着CPU减少而增加，这样会影响用户线程的执行。而且由于它是基于标记-清除算法的，那么就无法避免空间碎片的产生。CMS收集器无法处理浮动垃圾（Floating Garbage），可能出现“Concurrent Mode Failure”失败而导致另一次Full GC的产生。

所谓浮动垃圾，在CMS并发清理阶段用户线程还在运行着，伴随程序运行自然还会有新的垃圾不断产生，这一部分垃圾出现在标记过程之后，CMS无法在当次收集中处理掉它们，只能留待下一次GC时再清理掉。

205.新生代垃圾回收器和老生代垃圾回收器都有哪些？有什么区别？

新生代回收器：Serial、ParNew、Parallel Scavenge

老年代回收器：Serial Old、Parallel Old、CMS

新生代回收器一般采用的是复制算法，复制算法效率较高，但是浪费内存；

老生代回收器一般采用标记清楚算法，比如最常用的CMS；

206.简述分代垃圾回收器是怎么工作的？

分代回收器有两个分区：老生代和新生代，新生代默认的空间占比总空间的 1/3，老生代的默认占比是 2/3。

新生代使用的是复制算法，新生代里有 3 个分区：Eden、To Survivor、From Survivor，它们的默认占比是 8:1:1，它的执行流程如下：

把 Eden + From Survivor 存活的对象放入 To Survivor 区； 清空 Eden 和 From Survivor 分区； From Survivor 和 To Survivor 分区交换，From Survivor 变 To Survivor，To Survivor 变 From Survivor。

每次在 From Survivor 到 To Survivor 移动时都存活的对象，年龄就 +1，当年龄到达 15（默认配置是 15）时，升级为老生代。大对象也会直接进入老生代。

老生代当空间占用到达某个值之后就会触发全局垃圾收回，一般使用标记整理的执行算法。以上这些循环往复就构成了整个分代垃圾回收的整体执行流程

207.说一下 jvm 调优的工具？

常用调优工具分为两类,jdk自带监控工具：jconsole和jvisualvm，第三方有： MAT(Memory AnalyzerTool)、GChisto。 jconsole，Java Monitoring and Management Console是从java5开始，在JDK中自带的 java监控和管理控制台，用于对JVM中内存， 线程和类等的监控。 jvisualvm，jdk自带全能工具，可以分析内存快照、线程快照；监控内存变化、GC变化等。 MAT，Memory Analyzer Tool，一个基于Eclipse的内存分析工具，是一个快速、功能丰富 的Javaheap分析工具，它可以帮助我们查找内存泄漏和减少内存消耗。 GChisto，一款专业分析gc日志的工具。

208.常用的 jvm 调优的参数都有哪些？

-Xms s为strating，表示堆内存起始大小

-Xmx x为max，表示最大的堆内存

（一般来说-Xms和-Xmx的设置为相同大小，因为当heap自动扩容时，会发生内存抖动，影响程序的稳定性）

-Xmn n为new，表示新生代大小

（-Xss：规定了每个线程虚拟机栈（堆栈）的大小）

-XX:SurvivorRator=8 表示堆内存中新生代、老年代和永久代的比为8:1:1

-XX:PretenureSizeThreshold=3145728 表示当创建（new）的对象大于3M的时候直接进入老年代

-XX:MaxTenuringThreshold=15 表示当对象的存活的年龄（minor gc一次加1）大于多少时，进入老年代

-XX:-DisableExplicirGC 表示是否（+表示是，-表示否）打开GC日志