目录
基础
java基础
3.string_stringbuffer_stringbuilder的区别
4.Vector,ArrayList, LinkedList 的区别
父类静态变量、
父类静态代码块、
子类静态变量、
子类静态代码块、
父类匿名块
父类非静态变量（父类实例成员变量）、
父类构造函数、
子类匿名块
子类非静态变量（子类实例成员变量）、
子类构造函数。7.HashTable, TreeMap,HashMap,ConcurrentHashMap 区别
9.HashMap是怎么扩容的（扩容多少，已有元素怎么处理的）
//默认的初始容量16,且实际容量是2的整数幂
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量(传入容量过大将被这个值替换)
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认加载因子为0.75(当表达到3/4满时,才会再散列),这个因子在时间和空间代价之间达到了平衡.更高的因子可以降低表所需的空间,但是会增加查找代价,而查找是最频繁操作
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 最小树形化容量阈值：即 当哈希表中的容量 > 该值时，才允许树形化链表 （即 将链表 转换成红黑树）
// 为了避免扩容/树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD
static final int MIN_TREEIFY_CAPACITY = 64;
//桶的树化阈值：即 链表转成红黑树的阈值，在存储数据时，当链表长度 >= 8时，则将链表转换成红黑树
static final int TREEIFY_THRESHOLD = 8;
// 桶的链表还原阈值：即 红黑树转为链表的阈值，当在扩容（resize（））时（HashMap的数据存储位置会重新计算），在重新计算存储位置后，当原有的红黑树内数量 <= 6时，则将 红黑树转换成链表
static final int UNTREEIFY_THRESHOLD = 6;选择6和8，中间有个差值7可以有效防止链表和树频繁转换
假设一下，如果设计成链表个数超过8则链表转换成树结构，链表个数小于8则树结构转换成链表，如果一个HashMap不停的插入、删除元素，链表个数在8左右徘徊，就会频繁的发生树转链表、链表转树，效率会很低。
初始容量值用户没指定的话默认使用DEFAULT_INITIAL_CAPACITY ，jdk1.8会自动根据指定的值把这个初始容量值改成最大于或等于指定值得2的n次幂的最小值，当实际容量大于扩容阀值时，把默认容量值扩大一倍并重新计算扩容阀值（DEFAULT_INITIAL_CAPACITY *DEFAULT_LOAD_FACTOR ）
转红黑树的两个条件
一个是链表长度到8,一个是数组长度到64
Java 8中的散列值优化函数
为什么要异或呢？为什么要移位呢？而且移位16？
我们分析一下：
首先，假设有一种情况，对象 A 的 hashCode 为 1000010001110001000001111000000，对象 B 的 hashCode 为 0111011100111000101000010100000
如果数组长度是16，也就是 15 与运算这两个数， 你会发现结果都是0。这样的散列结果太让人失望了。很明显不是一个好的散列算法。
但是如果我们将 hashCode 值右移 16 位，也就是取 int 类型的一半，刚好将该二进制数对半切开。并且使用位异或运算（如果两个数对应的位置相反，则结果为1，反之为0），这样的话，就能避免我们上面的情况的发生。
总的来说，使用位移 16 位和 异或 就是防止这种极端情况。
但是，该方法在一些极端情况下还是有问题，比如：10000000000000000000000000 和 1000000000100000000000000 这两个数，如果数组长度是16，那么即使右移16位，在异或，hash 值还是会重复。
但是为了性能，对这种极端情况，JDK 的作者选择了性能。毕竟这是少数情况，为了这种情况去增加 hash 时间，性价比不高。
为什么cap要保持为2的幂次方
e.hash % newCap =e.hash &（newCap -1）
采用二进制位操作&,相对于%,能够提高运算效率,这就是cap的值被要求为2幂次的原因
http://m.nowcoder.com/discuss/151172
10.JAVA8 的 ConcurrentHashMap 为什么放弃了分段锁
而在1.8的时候摒弃了segment臃肿的设计，这种设计在定位到具体的桶时，要先定位到具体的segment，然后再
在segment中定位到具体的桶。而到了1.8的时候是针对的是Node[] tale数组中的每一个桶，进一步减小了锁粒
度。并且防止拉链过长导致性能下降，当链表长度大于8的时候采用红黑树的设计。
主要设计上的变化有以下几点:
1.不采用segment而采用node数组，锁住node来实现减小锁粒度。
2.设计了MOVED状态 当resize的中过程中 线程2还在put数据，线程2会帮助resize。
3.使用3个CAS操作来确保node的一些操作的原子性，这种方式代替了锁。
4.sizeCtl的不同值来代表不同含义，起到了控制的作用。
5.采用synchronized而不是ReentrantLock
延伸：
为什么是synchronized，而不是可重入锁
1. 减少内存开销
假设使用可重入锁来获得同步支持，那么每个节点都需要通过继承AQS来获得同步支持。但并不是每个节点都需
要获得同步支持的，只有链表的头节点（红黑树的根节点）需要同步，这无疑带来了巨大内存浪费。
2. 获得JVM的支持
可重入锁毕竟是API这个级别的，后续的性能优化空间很小。
synchronized则是JVM直接支持的，JVM能够在运行时作出相应的优化措施：锁粗化、锁消除、锁自旋等等。这
就使得synchronized能够随着JDK版本的升级而不改动代码的前提下获得性能上的提升。
11.有没有有顺序的Map实现类，如果有，他们是怎么保证有序的
14.nio的底层实现原理
1.由一个专门的线程来处理所有的IO事件，并负责分发。
2.事件驱动机制：事件到的时候触发，而不是同步的去监视事件。
3.线程通讯：线程之间通过wait,notify等方式通讯。保证每次上下文切换都是有意义的。减少无谓的线程切换。
在NIO中有几个核心对象需要掌握：缓冲区（Buffer）、通道（Channel）、选择器（Selector）。
Buffer实际上是一个容器对象，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的； 在写
入数据时，它也是写入到缓冲区中的
Channel是一个对象，通过它可以读取和写入数据，当然了所有数据都通过Buffer对象来处理。
读取数据Channel->Buffer, 写入数据Buffer->Channel
Selector就是注册各种IO事件的地方，而且当那些事件发生时，就是这个对象告诉我们所发生的事件。常见的Reactor线程模型有三种，分别如下：
Reactor单线程模型；
Reactor多线程模型；
主从Reactor多线程模型；16.反射的原理
JAVA语言编译之后会生成一个.class文件，反射就是通过字节码文件找到某一个类、类中的方法以及属性等。18.反射中，Class.forName 和ClassLoader.loadClass()区别
JDK动态代理的原理是根据定义好的规则，用传入的接口创建一个新类，这就是为什么采用动态代理时为什么只
能用接口引用指向代理，而不能用传入的类引用执行动态类。
CGLib采用的是用创建一个继承实现类的子类，用asm库动态修改子类的代码来实现的，所以可以用传入的类引
用执行代理类
CGLib创建的动态代理对象性能比JDK创建的动态代理对象的性能高不少，但是CGLib在创建代理对象时所花
费的时间却比JDK多得多，所以对于单例的对象，因为无需频繁创建对象，用CGLib合适，反之，使用JDK方式要更
为合适一些。同时，由于CGLib由于是采用动态创建子类的方法，对于final方法，无法进行代理CGLib代理的原理是通过二进制流生成一个动态class，该class继承被代理类以实现动态代理。那么就提供了一个
代理无实现类的接口的可能22.如何在父类中为子类自动完成所有的 hashcode和equals实现?这么做有何优劣
23.拦截器和过滤器的区别
拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。
25.error和exception的区别，CheckedException，RuntimeException的区别
1.Error（错误）是系统中的错误，程序员是不能改变的和处理的，是在程序编译时出现的错误，只能通过修改程序
才能修正。一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。对于这类
错误的导致的应用程序中断，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。2.Exception（异常）表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程
序恢复运行，而不应该随意终止异常。Exception又分为两类
CheckedException：（编译时异常） 需要用try——catch显示的捕获，对于可恢复的异常使用CheckedException。
UnCheckedException（RuntimeException）：（运行时异常）不需要捕获，对于程序错误（不可恢
复）的异常使用RuntimeException。
26.请列出 5 个运行时异常
Java的异常类层次结构27.在自己的代码中，如果创建一个 java.lang.String 类，这个类是否可以被类加载器加载？
28.说一说你对 java.lang.Object 对象中 hashCode 和 equals 方法的理解。在什么场景下需要重新实现这两个方法
29在jdk1.5中，引入了泛型，泛型的存在是用来解决什么问题
jdk1.7后，整形，枚举类型，boolean，字符串都可以。
31.序列化和反序列化
32.写出三种单例模式实现
33.有没有可能 2 个不相等的对象有相同的 hashcode
有可能
Java中的引用类型有4种，由强到弱依次如下：
1) 强引用（StrongReference）是使用最普遍的引用，类似：“Object obj = new Object()” 。如果
一个对象具有强引用，
那垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错
误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。2) 软引用（Soft Reference）是用来描述一些有用但并不是必需的对象，如果内存空间足够，垃圾回收
器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被
程序使用。软引用可用来实现内
存敏感的高速缓存。
3) 弱引用（WeakReference）也是用来描述非必需对象的，但是它的强度比软引用更弱一些，被弱引用关
联的对象只能生存到下一次垃圾收集发生之前，
当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。不过，由于垃圾回收
器是一个优先级很低的线程，因此不一定会很快发现那些
只具有弱引用的对象。
4) 虚引用（PhantomReference）也称为幽灵引用或者幻影引用，它是最弱的一种引用关系。需要和引用队列联合使用，主要用于跟踪一个引用对象被垃圾回收的过程
也无法通过虚引用来取得一个对象实例。
35.Hashcode的作用
36.object常用的方法
38.static 方法能不能被 overload,override?
39.Collection 与 Collections 的区别
java.util.Collection 是一个集合接口
Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。
40.了解哪些常用库?
41.final 的用途
42.java 8
一、Lambda表达式
Lambda表达式可以说是Java 8最大的卖点，她将函数式编程引入了Java。Lambda允许把函数作为一个方法的参数，或者把代码看成数据。
总结：对于耗时的操作用lambda表达式的for循环，如数据库的IO操作，多线程充分利用CPU资源；对于不太耗
时的操作使用普通for循环，比如纯CPU计算类型的操作，单线程性能更高，减少上下文切换的开销。
二、Stream
Stream API是把真正的函数式编程风格引入到Java中。其实简单来说可以把Stream理解为MapReduce，当然
Google的MapReduce的灵感也是来自函数式编程。她其实是一连串支持连续、并行聚集操作的元素。从语法上
看，也很像linux的管道、或者链式编程，代码写起来简洁明了，非常酷帅！
三、接口的默认方法与静态方法
我们可以在接口中定义默认方法，使用default关键字，并提供默认的实现。所有实现这个接口的类都会接受默
认方法的实现，除非子类提供的自己的实现。例如：
1 public interface DefaultFunctionInterface {
2 default String defaultFunction() {
3 return "default function";
4 }
5 }
我们还可以在接口中定义静态方法，使用static关键字，也可以提供实现。例如：
1 public interface StaticFunctionInterface {
2 static String staticFunction() {
3 return "static function";
4 }
5 }
接口的默认方法和静态方法的引入，其实可以认为引入了C＋＋中抽象类的理念，以后我们再也不用在每个实现
类中都写重复的代码了。
四、方法引用
通常与Lambda表达式联合使用，可以直接引用已有Java类或对象的方法。一般有四种不同的方法引用：
构造器引用。语法是Class::new，或者更一般的Class< T >::new，要求构造器方法是没有参数；
静态方法引用。语法是Class::static_method，要求接受一个Class类型的参数；
特定类的任意对象方法引用。它的语法是Class::method。要求方法是没有参数的；
特定对象的方法引用，它的语法是instance::method。要求方法接受一个参数，与3不同的地方在于，3是在列
表元素上分别调用方法，而4是在某个对象上调用方法，将列表元素作为参数传入；
五、重复注解
在Java 5中使用注解有一个限制，即相同的注解在同一位置只能声明一次。Java 8引入重复注解，这样相同的
注解在同一地方也可以声明多次。重复注解机制本身需要用@Repeatable注解。Java 8在编译器层做了优化，
相同注解会以集合的方式保存，因此底层的原理并没有变化。
六、Metaspace替代PermGen43.字符流和字节流的区别
45.stringbuffer内部的数据结构在字符串变化时怎么操作
String 类不可变，内部维护的char[] 数组长度不可变，为final修饰，String类也是final修饰，不存在扩
容。字符串拼接，截取，都会生成一个新的对象。频繁操作字符串效率低下，因为每次都会生成新的对象。
StringBuilder 类内部维护可变长度char[] ， 初始化数组容量为16，存在扩容， 其append拼接字符串方法内
部调用System的native方法，进行数组的拷贝，不会重新生成新的StringBuilder对象。非线程安全的字符串操
作类， 其每次调用 toString方法而重新生成的String对象，不会共享StringBuilder对象内部的char[]，会进
行一次char[]的copy操作。
StringBuffer 类内部维护可变长度char[]， 基本上与StringBuilder一致，但其为线程安全的字符串操作类，
大部分方法都采用了Synchronized关键字修改，以此来实现在多线程下的操作字符串的安全性。其toString方法
而重新生成的String对象，会共享StringBuffer对象中的toStringCache属性（char[]），但是每次的
StringBuffer对象修改，都会置null该属性值
如果JDK64位，8字节是引用，16字节是堆内存（对象头大小），总共是8+16=24字节，所以new一个Object对象占
用8+16=24字节。
如果JDK是32位，按如上分析方法可知new一个Object对象占用4+8=12字节jvm
引用计数算法(已废弃)
根集算法
引用计数算法简单高效，早期的Java虚拟机中使用这个方式，但是正如上面提到的不能解决“引用闭环”的问题，后来的Java虚拟机中普遍采用根集算法。从GCRoot（比如一个静态变量）开始遍历引用关系，能遍历到的，叫做引用可达，遍历不到的叫做不可达。不可达的对象就被判“死刑了”，GC的时候将被枪毙掉。
可以作为GCRoots的对象包括下面几种：
(1). 虚拟机栈（栈帧中的局部变量区，也叫做局部变量表）中引用的对象。
(2). 方法区中的类静态属性引用的对象。
(3). 方法区中常量引用的对象。
(4). 本地方法栈中JNI(Native方法)引用的对象。
Java.lang.OutOfMemeoryError:GC overhead limit exceeded
如上异常，即程序在垃圾回收上花费了98%的时间，却收集不回2%的空间，通常这样的异常伴随着CPU的冲高。定位方法同上（内存泄漏）
Java.lang.OutOfMemoryError: PermGen space（JAVA8引入了Metaspace区域）
永久代内存被耗尽（内存溢出）
Java.lang.OutOfMemeoryError:Unable to create new native thread
Java应用已经达到它可以运行的线程数的上限.
解决方法
1、检查是否存在大对象的分配，最有可能的是大数组分配
2、通过jmap命令，把堆内存dump下来，使用mat工具分析一下，检查是否存在内存泄露的问题
3、如果没有找到明显的内存泄露，使用 -Xmx 加大堆内存
4、还有一点容易被忽略，检查是否有大量的自定义的 Finalizable 对象，也有可能是框架内部提供的，考虑其存在的必要性
12.常见JVM参数列表
13.JVM内存为什么要分成新生代，老年代，持久代。新生代中为什么要分为Eden和Survivor？
15.你知道哪几种垃圾收集器，各自的优缺点，重点讲下 cms，包括原理，流程，优缺点
16.JVM为什么需要GC
17.怎么打出线程栈信息
18.JVM崩溃原因查找？（jvm内存镜像文件分析，常用jvm性能分析命令）
20.怎么打出线程栈信息
多线程
3.什么是线程安全
在线程的生命周期中，它要经过新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Dead）五种状态
9.解释以下名词：重排序，自旋锁，偏向锁，轻量级锁，可重入锁，公平锁，非公平锁，乐观锁，悲观锁
10.重排序
12.线程池原理，并说说newCache和newFixed有什么区别，构造函数的各个参数的含义是什么
shutdown()调用后，不可以再 submit 新的 task，已经 submit 的将继续执行shutdownNow()调用后，试图停止当前正在执行的 task，并返回尚未执行的 task 的 list
14.假如有一个第三方接口，有很多个线程去调用获取数据，现在规定每秒钟最多有10个线程同时调用它，如何做到
15.spring的controller是单例还是多例，怎么保证并发的安全
16.用三个线程按顺序循环打印 abc 三个字母，比如 abcabcabc
18.AQS同步器的实现原理(AbstractQueuedSynchronizer)
19.countdowlatch内部原理和用法(比如countdownlatch的await方法是怎么实现的)
CountDownLatch是基于AQS的共享锁来实现的，由于内部类继承了AQS，所以它内部也是FIFO队列，同时也一样是
前驱节点唤醒后继节点，不能像CyclicBarrier那样使用完毕后还可以复用；
1任务分为N个任子线程去执行，state也初始化为N(注意N要要与线程个数一致)
2这N个线程也是并行执行的，每个子线程执行完后后countDown（）一次，state会CAS减1
3等到所有子线程都执行完成之后即(state==0),会调用LockSupport.unpark(s.thread)
4然后主调用会从await()函数返回（之前是通过LockSupport.park(this);阻塞），继续后余动作
CyclicBarrier实现主要基于ReentrantLock
默认的构造方法是CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告
诉CyclicBarrier已经到达屏障位置，线程被阻塞。
另外一个构造方法CyclicBarrier(int parties, Runnable barrierAction)，其中barrierAction任务会在
所有线程到达屏障后执行。
https://www.jianshu.com/p/424374d71b67
21.Lock锁的实现原理
需要实现锁的功能，两个必备元素:
一个是表示（锁）状态的变量（我们假设0表示没有线程获取锁，1表示已有线程占有锁）,该变量必须声明为
voaltile类型;
另一个是队列，队列中的节点表示因未能获取锁而阻塞的线程。24.进程和线程的区别
27.简述ConcurrentLinkedQueue和LinkedBlockingQueue 的用处和不同之处
28.Queue添加数据方法add()put()offer()不同之处
add方法在添加元素的时候，若超出了度列的长度会直接抛出异常
offer方法在添加元素时，如果发现队列已满无法添加的话，会直接返回false。
put方法，若向队尾添加元素的时候发现队列已经满了会发生阻塞一直等待空间，以加入元素。
30编写一段死锁代码
//首先我们先定义两个final的对象锁.可以看做是共有的资源.
final Object lockA = new Object();
final Object lockB = new Object();
//生产者A
class ProductThreadA implements Runnable{
@Override
public void run() {
//这里一定要让线程睡一会儿来模拟处理数据 ,要不然的话死锁的现象不会那么的明显.这里就是同步语句块里面,首先获得对象锁lockA,然后执行一些代码,随后我们需要对象锁lockB去执行另外一些代码.
synchronized (lockA){
//这里一个log日志
Log.e("CHAO","ThreadA lock lockA");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lockB){
//这里一个log日志
Log.e("CHAO","ThreadA lock lockB");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
//生产者B
class ProductThreadB implements Runnable{
//我们生产的顺序真好好生产者A相反,我们首先需要对象锁lockB,然后需要对象锁lockA.
@Override
public void run() {
synchronized (lockB){
//这里一个log日志
Log.e("CHAO","ThreadB lock lockB");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lockA){
//这里一个log日志
Log.e("CHAO","ThreadB lock lockA");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
//这里运行线程
ProductThreadA productThreadA = new ProductThreadA();
ProductThreadB productThreadB = new ProductThreadB();
Thread threadA = new Thread(productThreadA);
Thread threadB = new Thread(productThreadB);
threadA.start();
threadB.start();当threadA开始执行run方法的时候,它会先持有对象锁localA,然后睡眠2秒,这时候threadB也开始执行run方法,它持有的是localB对象锁.当threadA运行到第二个同步方法的时候,发现localB的对象锁不能使用(threadB未释放localB锁),threadA就停在这里等待localB锁.随后threadB也执行到第二个同步方法,去访问localA对象锁的时候发现localA还没有被释放(threadA未释放localA锁),threadB也停在这里等待localA锁释放.就这样两个线程都没办法继续执行下去,进入死锁的状态.
ReentrantReadWriteLock是一个解决单线程写和多线程读的理想方法。它采用类似于读写分离的思路设定了读锁和写锁。对于这两个锁的访问保证尽可能大的读并行和写互斥。另外，在一定的条件下写锁可以转换成读锁，而读锁却不能转换成写锁。
ReentrantReadWriteLock却可以有锁的机制保证互斥。它同时也尽可能保证了足够大的并行性。
32.两个进程能否共享内存空间
35.开启多个线程，如何保证顺序执行，有哪几种实现方式，或者如何保证多个线程都执行完再拿到结果
36、延迟队列的实现方式，delayQueue 和时间轮算法的异同
37、非常多个线程（可能是不同机器）相互之间需要等待协调，才能完成某种工作，问怎么设计这种协调方案
39、什么是锁升级降级
43、线程常用的并发类及关键字
不安全的，因为在操作i++的时候，是分步骤做的，可以理解为：
tp = i;
tp2 = i+1;
i=tp2;
如果线程1在执行第一条代码的时候，线程2访问i变量，这个时候，i的值还没有变化，还是原来的值，所以是不安全的
这也是经典的内存不可见问题，那么把 i加上 volatile 让内存可见是否能解决这个问题呢？ 答案是：不
能。因为 volatile 只能保证可见性，不能保证原子性。多个线程同时读取这个共享变量的值，就算保证其他线
程修改的可见性，也不能保证线程之间读取到同样的值然后相互覆盖对方的值的情况。46、说说 JDK1.6 之后的synchronized 关键字底层做了哪些优化，可以详细介绍一下这些优化吗
JDK1.6 对锁的实现引入了大量的优化，如偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化等技术来减少锁操作的开销。
锁主要存在四中状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。
关于这几种优化的详细信息可以查看：synchronized 关键字使用、底层原理、JDK1.6 之后的底层优化以及 和ReenTrantLock 的对比
jdk1.7源码
HashMap结构中，是允许保存
null的，Entry.key和Entry.value均可以为null。但是HashTable中是不允许保存null的
HashTable类继承自Dictionary类，实现了三个接口，分别是Map，Cloneable和java.io.Serializable
HashTable的主要方法的源码实现逻辑，与HashMap中非常相似，有一点重大区别就是所有的操作都是通过synchronized锁保护的。只有获得了对应的锁，才能进行后续的读写等操作。
LinkedHashSet 底层使用 LinkedHashMap 来保存所有元素，它继承与 HashSet，其所有的方法操作上又与 HashSet 相同
开源框架与技术LinkedList存储元素的数据结构是双向链表结构，由存储元素的结点连接而成，每一个节点都包含前一个节点的引用，后一个节点的引用和节点存储的值。当一个新节点插入时，只需要修改其中保持先后关系的节点的引用即可。
tomcat
- 简单讲讲 tomcat结构
- tomcat启动流程
- tomcat怎么处理请求，流程是怎样的
- tomcat如何调优
- maxThreads、maxConnections、acceptAccount区别
- tomcat默认支持并发数,怎么修改？
- tomcatNIO线程模型
spring
4.Springmvc中DispatcherServlet初始化过程
5.Bean如何优雅的销毁
context.registerShutdownHook(); 是一个钩子方法，当jvm关闭退出的时候会调用这个钩子方法，在设计模式之 模板模式中 通过在抽象类中定义这样的钩子方法由实现类进行实现，这里的实现类是AbstractApplicationContext，这是spring 容器优雅关闭的方法
7.什么是IOC
10.BeanFactory和ApplicationContext区别
15.Spring怎么配置事务（具体说出一些关键的xml元素）
18.Spring循环依赖的处理（单例、多例状态下的处理，懒加载一定能处理掉循环依赖么？）
19.@Autowired 与@Resource和@Qualifier注解的区别
@Resource的作用相当于@Autowired，只不过@Autowired按byType自动注入，而@Resource默认按 byName自动注入罢了
@Autowired是根据类型进行自动装配的。如果当Spring上下文中存在不止一个UserDao类型的bean时，就会抛出BeanCreationException异常;如果Spring上下文中不存在UserDao类型的bean，也会抛出BeanCreationException异常。我们可以使用@Qualifier配合@Autowired来解决这些问题
可能存在多个UserDao实例
@Autowired
public void setUserDao(@Qualifier("userDao") UserDao userDao) {
this.userDao = userDao;
}
20.@transactional注解在什么情况下会失效，为什么
1、service类标签(一般不建议在接口上)上添加@Transactional，可以将整个类纳入spring事务管理，在每个业务方法执行时都会开启一个事务，不过这些事务采用相同的管理方式。
2、@Transactional 注解只能应用到 public 可见度的方法上。 如果应用在protected、private或者 package可见度的方法上，也不会报错，不过事务设置不会起作用。
3、默认情况下，Spring会对unchecked异常进行事务回滚；如果是checked异常则不回滚。 通俗一点：你写代码出现的空指针等异常，会被回滚，文件读写，网络出问题，spring就没法回滚了
netty
1.netty的线程模型是什么？netty是如何基于reactor模型上实现的
2.netty的HashedWheelTimer 的用法，实现原理，是否出现过调用不够准时，怎么解决
5.netty原理
dubbo
Dubbo的 protocol标签提供了三个参数 dispatcher,threads(默认为100)
和 threadpool来为我们自定义DUBBO协议下的线程模型dubbo提供了三种结果缓存机制：
lru：基于最近最少使用原则删除多余缓存，保持最热的数据被缓存
threadlocal：当前线程缓存
jcache：可以桥接各种缓存实现
使用方式
<dubbo:reference id="demoService" check="false" interface="com.alibaba.dubbo.demo.DemoService">
<dubbo:method name="sayHello" timeout="60000" cache="lru"/>
</dubbo:reference>第1种
在远程调用异常时，服务端直接返回一个固定的字符串(也就是写死的字符串)
具体配置：
在服务调用方配置mock参数：
<dubbo:reference id="xxxService" interface="com.x..service.xxxxService" check="false"
mock="return 123456..." />
说明：配置了mock参数之后，假设在调用服务的时候，远程服务没有启动，或者各种网络异常了，那远程服务
会把这个mock配置的值返回，也就是会返回123456...
第2种
在远程调用异常时，服务端根据自定义mock业务处理类进行返回)
具体配置：
在服务调用方配置mock参数：
<dubbo:reference id="xxxService" interface="com.x..service.xxxxService" check="false" mock="true" />
说明：配置了mock参数之后，假设在调用服务的时候，远程服务没有启动，或者各种网络异常了，那远程服务
会去寻找自定义的mock业务处理类进行业务处理。
因此还需配置一个自定义mock业务处理类
在接口服务xxxxService的目录下创建相应的mock业务处理类，同时实现业务接口xxxxService()，接口名要
注意命名规范：接口名+Mock后缀，mock实现需要保证有无参的构造方法。
public class xxxxServiceMock implements xxxxService {
@Override
public String getXXXX(int id) {
return "this is exception 自定义....";
}
}对于通过dubbo Main方式启动dubbo容器的，只需在启动前添加java环境变量-Ddubbo.shutdown.hook=true即
可。
对于tomcat等web容器方式启动dubbo的，需要在关闭时执行方法ProtocolConfig.destroyAll();
kill -9 默认对于dubbo Main方式启动的，优雅停机不生效dubbo 内部有几种线程模型，都是使用 java 线程池实现的，任务被拒绝后会输出堆栈信息。我们可以看它是怎
么实现的1dubbo协议
Dubbo缺省协议采用单一长连接和NIO异步通讯，使用基于于netty+hessian（序列化方式）交互。适合于小数据
量大并发的服务调用，以及服务消费者机器数远大于服务提供者机器数的情况。Dubbo缺省协议不适合传送大数据
量的服务，比如传文件，传视频等，除非请求量很低。
2 rmi协议
走java二进制序列化，多个短连接，适合消费者和提供者数量差不多，适用于文件的传输，一般较少用，在大数据
量下的传输性，建议使用rmi协议
3 hessian协议
走hessian序列化协议，多个短连接，适用于提供者数量比消费者数量还多，适用于文件的传输，一般较少用
4 http协议
走json序列化
5 webservice
14.dubbo的优缺点是什么
17.dubbo遇到那些坑
18.Dubbo运行时,突然所有的zookeeper全部宕机,Dubbo是否还会继续提供服务
可以，因为刚开始初始化的时候，消费者会将提供者的地址等信息拉取到本地缓存，所以注册中心挂了可以继续通信
19.Dubbo源码
<dubbo:registry address="redis://127.0.0.1:6379" username="admin" password="password"></dubbo:registry>
<dubbo:protocol name="dubbo" port="20880" />
22.Dubbo最佳实践
23.Dubbo调优经验
zookeeper
Zk的选举算法有两种：一种是基于basic paxos实现的，另外一种是基于fast paxos算法实现的。系统默认的选举算法为fast paxos。
一、basic paxos流程(推荐别人，超过半数投票机制)
1 .选举线程由当前Server发起选举的线程担任，其主要功能是对投票结果进行统计，并选出推荐的Server；
2 .选举线程首先向所有Server发起一次询问(包括自己)；
3 .选举线程收到回复后，验证是否是自己发起的询问(验证zxid是否一致)，然后获取对方的id(myid)，并存
储到当前询问对象列表中，最后获取对方提议的leader相关信息(id,zxid)，并将这些信息存储到当次选举的投票记
录表中；
4. 收到所有Server回复以后，就计算Server中zxid最大的那个Server，并将这个Server相关信
息设置成下一次要投票的Server；
5. 线程将当前zxid最大的Server设置为当前Server要推荐的Leader，如果此时获胜的Server获得n/2 + 1
的Server票数， 设置当前推荐的leader为获胜的Server，将根据获胜的Server相关信息设置自己的状态，否
则，继续这个过程，直到leader被选举出来。
二、fast paxos流程(推荐自己，全票机制)
在选举过程中，某Server首先向所有Server提议自己要成为leader，当其它Server收到提议以后，解决epoch
和zxid的冲突，并接受对方的提议，然后向对方发送接受提议完成的消息，重复这个流程，最后一定能选举出
Leader
3.zookeeper原理
Zookeeper的核心是原子广播，这个机制保证了各个Server之间的同步。实现这个机制的协议叫做Zab协议。Zab
协议有两种模式，它们分别是恢复模式（选主）和广播模式（同步）。
为了保证事务的顺序一致性，zookeeper采用了递增的事务id号（zxid）来标识事务。所有的提议（proposal）
都在被提出的时候加上了zxid。实现中zxid是一个64位的数字，它高32位是epoch用来标识leader关系是否改
变，每次一个leader被选出来，它都会有一个新的epoch，标识当前属于那个leader的统治时期。低32位用于递
增计数。
每个Server在工作过程中有三种状态：
LOOKING：当前Server不知道leader是谁，正在搜寻
LEADING：当前Server即为选举出来的leader
FOLLOWING：leader已经选举出来，当前Server与之同步把follower的数据同步给leader的过程：
1. leader等待server连接；
2.Follower连接leader，将最大的zxid发送给leader；
3.Leader根据follower的zxid确定同步点；
4.完成同步后通知follower 已经成为uptodate状态；
5.Follower收到uptodate消息后，又可以重新接受client的请求进行服务了。
1 .恢复数据；
2 .维持与Learner的心跳，接收Learner请求并判断Learner的请求消息类型；
3 .Learner的消息类型主要有PING消息、REQUEST消息、ACK消息、REVALIDATE消息，根据不同的消息类型，进行不同的处理1. 向Leader发送请求（PING消息、REQUEST消息、ACK消息、REVALIDATE消息）；
2 .接收Leader消息并进行处理；
3 .接收Client的请求，如果为写请求，发送给Leader进行投票；
4 .返回Client结果。10.什么是zab协议
ZAB(ZooKeeper Atomic Broadcast)协议是为协调分布式服务,ZooKeeper专门设计的一种支持漰溃恢复的原子
广播协议。
ZAB协议的两种基本模式：崩溃恢复模式和消息广播模式。(1)配置管理
(2)集群管理 12.为什么zookeeper不用paxos，而是用的zab算法
ZK的每一个操作都具有隐形事务要求，通过强一致性保证数据节点的数据的顺序性（FIFO）。Paxos协议无法实现
多个写操作的顺序性，或者通过串行操作实现，则以牺牲效率为代价。13.zookeeper的写入数据流程
客户端连接到集群中某一个节点
客户端发送写请求
服务端连接节点，把该写请求转发给leader
leader处理写请求，一半以上的从节点也写成功，返回给客户端成功。
mybatis
1）读取 MyBatis 配置文件：mybatis-config.xml 为 MyBatis 的全局配置文件，配置了 MyBatis 的运行环境等信息，例如数据库连接信息。
2）加载映射文件。映射文件即 SQL 映射文件，该文件中配置了操作数据库的 SQL 语句，需要在 MyBatis 配置文件 mybatis-config.xml 中加载。mybatis-config.xml 文件可以加载多个映射文件，每个文件对应数据库中的一张表。
3）构造会话工厂：通过 MyBatis 的环境等配置信息构建会话工厂 SqlSessionFactory。
4）创建会话对象：由会话工厂创建 SqlSession 对象，该对象中包含了执行 SQL 语句的所有方法。
5）Executor 执行器：MyBatis 底层定义了一个 Executor 接口来操作数据库，它将根据 SqlSession 传递的参数动态地生成需要执行的 SQL 语句，同时负责查询缓存的维护。
6）MappedStatement 对象：在 Executor 接口的执行方法中有一个 MappedStatement 类型的参数，该参数是对映射信息的封装，用于存储要映射的 SQL 语句的 id、参数等信息。
7）输入参数映射：输入参数类型可以是 Map、List 等集合类型，也可以是基本数据类型和 POJO 类型。输入参数映射过程类似于 JDBC 对 preparedStatement 对象设置参数的过程。
8）输出结果映射：输出结果类型可以是 Map、 List 等集合类型，也可以是基本数据类型和 POJO 类型。输出结果映射过程类似于 JDBC 对结果集的解析过程。
mybatis的mapper代理是用的jdk的动态代理
5.Mybatis缓存
MyBatis 默认开启了一级缓存，一级缓存是在SqlSession 层面进行缓存的。即，同一个SqlSession ，多次调用同一个Mapper和同一个方法的同一个参数，只会进行一次数据库查询，然后把数据缓存到缓冲中，以后直接先从缓存中取出数据，不会直接去查数据库。
但是不同的SqlSession对象，因为不用的SqlSession都是相互隔离的，所以相同的Mapper、参数和方法，他还是会再次发送到SQL到数据库去执行，返回结果。
为了克服这个问题，需要开启二级缓存，是的缓存zaiSqlSessionFactory层面给各个SqlSession 对象共享。默认二级缓存是不开启的，需要手动进行配置
elasticsearch
2.说说你们公司 es 的集群架构，索引数据大小，分片有多少
按数据库划分索引。十几个库对应十几个索引，每个索引几百G,5个分片，每个分片几十G。3个副本。1.关闭data结点的http功能
2.最小主节点数量，防止脑裂
3.指定集群及节点名字
4.一台服务器上最好只部署一个Node
5.预留一半内存给Lucene使用
6.集群恢复配置
7.索引别名和零停机
8.设置最优的分片数和备份数
9.设置合理的刷新时间
10.根据业务设置合理的字段类型尽可能使用基于时间的索引来管理数据保留期。根据保留期（retention period，可以理解成有效期）将数据分
组。基于时间的索引还可以轻松地随时间改变主分片和副本分片的数量（以为要生成的下一个索引进行更改）。这
简化了适应不断变化的数据量和需求。nginx
spring boot
spring cloud
服务发现——Netflix Eureka
客服端负载均衡——Netflix Ribbon
断路器——Netflix Hystrix
服务网关——Netflix Zuul
分布式配置——Spring Cloud Confighttp
- HTTP/1.1与HTTP/1.0的区别
- HTTPS的加密方式是什么，讲讲整个加密解密流程
- HTTP请求报文和HTTP响应报文
- 常用的http方法
- 常用的http响应码详解
- 如何避免浏览器缓存
- 简述Http请求get和post的区别
- 什么是HTTP2.0
- Http 如何处理长连接
- http和tcp的区别
tcp
架构系统架构
3.一个在线文档系统，文档可以被编辑，如何防止多人同时对同一份文档进a行编辑更新
7.聊下曾经参与设计的服务器架构并画图，谈谈遇到的问题，怎么解决的
13.如何优化线程数
14.常见的缓存策略有哪些，如何做到缓存与 DB 里的数据一致性，你们项目中用到了什么缓存系统，如何设计的
分布式、高并发
4.接口限流怎么做
一个基本的RPC架构里面应该至少包含以下4个组件：
1、客户端（Client）:服务调用方（服务消费者）
2、客户端存根（Client Stub）:存放服务端地址信息，将客户端的请求参数数据信息打包成网络消息，再通过网络传输发送给服务端
3、服务端存根（Server Stub）:接收客户端发送过来的请求消息并进行解包，然后再调用本地服务进行处理
4、服务端（Server）:服务的真正提供者
6自己实现过rpc么，原理可以简单讲讲，Rpc要解决什么问题
1、RPC是什么
RPC远程过程调用协议，它是一种通过网络从远程计算机程序上请求服
务，而不需要了解底层网络技术的协议。简言之，RPC使得程序能够像访问本地系统资源一样，去访问远端系统资
源。
2.RPC要解决什么问题
各个团队的服务提供方就不要各自实现一套序列化、反序列化、网络框架、连接池、收发线程、超时处理、状态机
等“业务之外”的重复技术劳动，造成整体的低效。https://mp.weixin.qq.com/s/uDdwV6eEw0mI5wdm3VX1Zw
7.高并发下1个数频繁更改（更改频率1000次-10000次）应该怎么处理？
系统设计、设计模式
- 常见设计原则
- 编程中自己都怎么考虑一些设计原则的，比如开闭原则，以及在工作中的应用
- OO 的设计原则
- 请结合 OO 设计理念，谈谈访问修饰符 public、private、protected、default 在应用设计中的作用
- 如何做到接口的幂等性
- 说说你平时用到的设计模式
- 工厂模式
- 代理模式
- 适配模式
性能优化
微服务
1、REST
可以看着是HTTP协议的一种直接应用，默认基于JSON作为传输格式,使用简单,学习成本低效率高,但是安全性较
低。
2、SOAP
SOAP是一种数据交换协议规范,是一种简单的、基于XML的协议的规范。而SOAP可以看着是一个重量级
的协议，基于XML、SOAP在安全方面是通过使用XML-Security和XML-Signature两个规范组成了WS-Security
来实现安全控制的,当前已经得到了各个厂商的支持 。
它有什么优点？简单总结为：易用、灵活、跨语言、跨平台。
3、SOA
面向服务架构，它可以根据需求通过网络对松散耦合的粗粒度应用组件进行分布式部署、组合和使用。服务层是
SOA的基础，可以直接被应用调用，从而有效控制系统中与软件代理交互的人为依赖性。
SOA是一种粗粒度、松耦合服务架构，服务之间通过简单、精确定义接口进行通讯，不涉及底层编程接口和通讯
模型。SOA可以看作是B/S模型、XML（标准通用标记语言的子集）/Web Service技术之后的自然延伸。
4、REST 和 SOAP、RPC 有何区别呢?
没什么太大区别，他们的本质都是提供可支持分布式的基础服务，最大的区别在于他们各自的的特点所带来的不
同应用场景 。
消息队列
- MQ的基本原理
- MQ消息可靠性保证
- MQ怎么解决幂等性
- MQ系统的数据如何保证不丢失
- 用过哪些 MQ，和其他 mq 比较有什么优缺点
- 用过哪些 MQ，和其他 mq 比较有什么优缺点，MQ 的连接是线程安全的吗
- 怎么利用 mq 实现最终一致性
- MQ有可能发生重复消费，如何避免，如何做到幂等
- MQ 的消息延迟了怎么处理，消息可以设置过期时间么，过期了你们一般怎么处理
- 消息队列满了怎么处理
- 如何自己设计一个消息中间件
- kafka，activemq，rabbitmq本质区别是啥
关系型数据库
1.数据库隔离级别有哪些，各自的含义是什么，MYSQL默认的隔离级别是是什么
3.MYSQL有哪些存储引擎，各自优缺点，myisam与innodb区别
8.数据库会死锁吗，举一个死锁的例子，mysql怎么解决死锁
10.Mysql的索引数据结构
14.select for update是什么含义，会锁表还是锁行或是其他
15.Btree原理
17.数据库的ACID是什么
21.数据库自增主键可能的问题
22.MVCC的含义
雪花算法
29.说下mysql内存分配
32.说下JDBC 连接步骤
33.MySQL事务实现原理
非关系型数据库
前者是一个完全无中心的设计，节点之间通过gossip方式传递集群信息，数据保证最终一致性
后者是一个中心化的方案设计，通过类似一个分布式锁服务来保证强一致性,数据写入先写内存和redo log，然后定期compat归并到磁盘上，将随机写优化为顺序写，提高写入性能。
15Redis的并发竞争问题如何解决，了解Redis事务的CAS操作吗
算法- 什么是一致性 hash算法？
- 说说你知道的几种hash算法
- 什么是paxos算法
- 什么是zab算法
- 什么是二叉树算法
- 什么是红黑树算法
- 二叉树和二叉查找树的区别是什么？
- 手写各种排序算法，如冒泡、快速等
- 算法的时间复杂度是什么？
- 说出常见的负载均衡算法？
- 写出常见排序算法(快排、冒泡)
- 二分法查找
项目开发
- 你们项目是怎么打包部署
- 项目出现乱码怎么解决
- 你们是怎么管理分支的，出现冲突怎么解决
- 项目中遇到那些难题挑战，怎么解决
- 线上出了问题怎么排查，分析的过程和方法
- 说说你最满意的一个项目的架构
- 画出你们项目的架构图
业务问题
1.分布式服务情况下，怎么保证一个新闻一天一个用户只能点赞一次
2.微信红包怎么实
Hadoop
Hbase
- RowKey设计原则
- Hbase内部是什么机制
- Hbase过滤器实现原则
- HBase, zookeeper 搭建过程
- hbase 写数据的原理是什么
- hbase读数据的原理是什么
- hbase 宕机如何处理
