编程语言
首页 > 编程语言> > 最常见的Java面试题【杭州多测师_王sir】【杭州多测师】

最常见的Java面试题【杭州多测师_王sir】【杭州多测师】

作者:互联网

JDK、JRE、JVM之间的区别
● JDK(Java SE Development Kit),Java标准开发包,它提供了编译、运⾏Java程序所需的各种⼯具和资源,包括Java编译器、Java运⾏时环境,以及常⽤的Java类库等
● JRE( Java Runtime Environment) ,Java运⾏环境,⽤于运⾏Java的字节码⽂件。JRE中包括了
JVM以及JVM⼯作所需要的类库,普通⽤户⽽只需要安装JRE来运⾏Java程序,⽽程序开发者必须安装JDK来编译、调试程序。
● JVM(Java Virtual Mechinal),Java虚拟机,是JRE的⼀部分,它是整个java实现跨平台的最核⼼的部分,负责运⾏字节码⽂件。

我们写Java代码,⽤txt就可以写,但是写出来的Java代码,想要运⾏,需要先编译成字节码,那就需要编译器,⽽JDK中就包含了编译器javac,编译之后的字节码,想要运⾏,就需要⼀个可以执⾏字节码的程序,这个程序就是JVM(Java虚拟机),专⻔⽤来执⾏Java字节码的。

如果我们要开发Java程序,那就需要JDK,因为要编译Java源⽂件。
如果我们只想运⾏已经编译好的Java字节码⽂件,也就是*.class⽂件,那么就只需要JRE。
JDK中包含了JRE,JRE中包含了JVM。
另外,JVM在执⾏Java字节码时,需要把字节码解释为机器指令,⽽不同操作系统的机器指令是有可能不⼀样的,所以就导致不同操作系统上的JVM是不⼀样的,所以我们在安装JDK时需要选择操作系统。 另外,JVM是⽤来执⾏Java字节码的,所以凡是某个代码编译之后是Java字节码,那就都能在JVM上运
⾏,⽐如Apache Groovy, Scala and Kotlin 等等。

hashCode()与equals()之间的关系
在Java中,每个对象都可以调⽤⾃⼰的hashCode()⽅法得到⾃⼰的哈希值(hashCode),相当于对象的 指纹信息,通常来说世界上没有完全相同的两个指纹,但是在Java中做不到这么绝对,但是我们仍然可 以利⽤hashCode来做⼀些提前的判断,⽐如:
● 如果两个对象的hashCode不相同,那么这两个对象肯定不同的两个对象
● 如果两个对象的hashCode相同,不代表这两个对象⼀定是同⼀个对象,也可能是两个对象
● 如果两个对象相等,那么他们的hashCode就⼀定相同

在Java的⼀些集合类的实现中,在⽐较两个对象是否相等时,会根据上⾯的原则,会先调⽤对象的
hashCode()⽅法得到hashCode进⾏⽐较,如果hashCode不相同,就可以直接认为这两个对象不相
同,如果hashCode相同,那么就会进⼀步调⽤equals()⽅法进⾏⽐较。⽽equals()⽅法,就是⽤来最终确定两个对象是不是相等的,通常equals⽅法的实现会⽐较重,逻辑⽐较多,⽽hashCode()主要就是得到⼀个哈希值,实际上就⼀个数字,相对⽽⾔⽐较轻,所以在⽐较两个对象时,通常都会先根据
hashCode想⽐较⼀下。

所以我们就需要注意,如果我们重写了equals()⽅法,那么就要注意hashCode()⽅法,⼀定要保证能遵守上述规则。

String、StringBuffer、StringBuilder的区别
String是不可变的,如果尝试去修改,会新⽣成⼀个字符串对象,StringBuffer和StringBuilder是可变的
StringBuffer是线程安全的,StringBuilder是线程不安全的,所以在单线程环境下StringBuilder效率会更⾼
泛型中extends和super的区别

<? extends T>表示包括T在内的任何T的⼦类
<? super T>表示包括T在内的任何T的⽗类
==和equals⽅法的区别
● ==:如果是基本数据类型,⽐较是值,如果是引⽤类型,⽐较的是引⽤地址
● equals:具体看各个类重写equals⽅法之后的⽐较逻辑,⽐如String类,虽然是引⽤类型,但是
String类中重写了equals⽅法,⽅法内部⽐较的是字符串中的各个字符是否全部相等。

重载和重写的区别

● 重载(Overload): 在⼀个类中,同名的⽅法如果有不同的参数列表(⽐如参数类型不同、参数个数不同)则视为重载。
● 重写(Override): 从字⾯上看,重写就是 重新写⼀遍的意思。其实就是在⼦类中把⽗类本身有的⽅法重新写⼀遍。⼦类继承了⽗类的⽅法,但有时⼦类并不想原封不动的继承⽗类中的某个⽅法,所 以在⽅法名,参数列表,返回类型都相同(⼦类中⽅法的返回值可以是⽗类中⽅法返回值的⼦类)的 情况下, 对⽅法体进⾏修改,这就是重写。但要注意⼦类⽅法的访问修饰权限不能⼩于⽗类的。

List和Set的区别
● List:有序,按对象插⼊的顺序保存对象,可重复,允许多个Null元素对象,可以使⽤Iterator取出所有元素,在逐⼀遍历,还可以使⽤get(int index)获取指定下标的元素
● Set:⽆序,不可重复,最多允许有⼀个Null元素对象,取元素时只能⽤Iterator接⼝取得所有元素,在逐⼀遍历各个元素

ArrayList和LinkedList区别
⾸先,他们的底层数据结构不同,ArrayList底层是基于数组实现的,LinkedList底层是基于链表实现的
由于底层数据结构不同,他们所适⽤的场景也不同,ArrayList更适合随机查找,LinkedList更适合删除和添加,查询、添加、删除的时间复杂度不同
另外ArrayList和LinkedList都实现了List接⼝,但是LinkedList还额外实现了Deque接⼝,所以
LinkedList还可以当做队列来使⽤
谈谈ConcurrentHashMap的扩容机制
1.7 版本

1.7版本的ConcurrentHashMap是基于Segment分段实现的

每个Segment相对于⼀个⼩型的HashMap

每个Segment内部会进⾏扩容,和HashMap的扩容逻辑类似

先⽣成新的数组,然后转移元素到新数组中

扩容的判断也是每个Segment内部单独判断的,判断是否超过阈值

1.8 版本

1.8版本的ConcurrentHashMap不再基于Segment实现
当某个线程进⾏put时,如果发现ConcurrentHashMap正在进⾏扩容那么该线程⼀起进⾏扩容
如果某个线程put时,发现没有正在进⾏扩容,则将key-value添加到ConcurrentHashMap中,然后判断是否超过阈值,超过了则进⾏扩容
ConcurrentHashMap是⽀持多个线程同时扩容的
扩容之前也先⽣成⼀个新的数组
在转移元素时,先将原数组分组,将每组分给不同的线程来进⾏元素的转移,每个线程负责⼀组或多组的元素转移⼯作
Jdk1.7到Jdk1.8 HashMap 发⽣了什么变化(底层)?

1.7中底层是数组+链表,1.8中底层是数组+链表+红⿊树,加红⿊树的⽬的是提⾼HashMap插⼊和查询整体效率
1.7中链表插⼊使⽤的是头插法,1.8中链表插⼊使⽤的是尾插法,因为1.8中插⼊key和value时需要 判断链表元素个数,所以需要遍历链表统计链表元素个数,所以正好就直接使⽤尾插法
1.7中哈希算法⽐较复杂,存在各种右移与异或运算,1.8中进⾏了简化,因为复杂的哈希算法的⽬的就是提⾼散列性,来提供HashMap的整体效率,⽽1.8中新增了红⿊树,所以可以适当的简化哈希 算法,节省CPU资源
说⼀下HashMap的Put⽅法
先说HashMap的Put⽅法的⼤体流程:

根据Key通过哈希算法与与运算得出数组下标
如果数组下标位置元素为空,则将key和value封装为Entry对象(JDK1.7中是Entry对象,JDK1.8中 是Node对象)并放⼊该位置
如果数组下标位置元素不为空,则要分情况讨论
a. 如果是JDK1.7,则先判断是否需要扩容,如果要扩容就进⾏扩容,如果不⽤扩容就⽣成Entry对象,并使⽤头插法添加到当前位置的链表中

b. 如果是JDK1.8,则会先判断当前位置上的Node的类型,看是红⿊树Node,还是链表Node

ⅰ. 如果是红⿊树Node,则将key和value封装为⼀个红⿊树节点并添加到红⿊树中去,在这个过程中会判断红⿊树中是否存在当前key,如果存在则更新value

ⅱ. 如果此位置上的Node对象是链表节点,则将key和value封装为⼀个链表Node并通过尾插法插⼊到链表的最后位置去,因为是尾插法,所以需要遍历链表,在遍历链表的过程中会 判断是否存在当前key,如果存在则更新value,当遍历完链表后,将新链表Node插⼊到链 表中,插⼊到链表后,会看当前链表的节点个数,如果⼤于等于8,那么则会将该链表转成 红⿊树
ⅲ. 将key和value封装为Node插⼊到链表或红⿊树中后,再判断是否需要进⾏扩容,如果需要就扩容,如果不需要就结束PUT⽅法

深拷⻉和浅拷⻉
深拷⻉和浅拷⻉就是指对象的拷⻉,⼀个对象中存在两种类型的属性,⼀种是基本数据类型,⼀种是实例对象的引⽤。

浅拷⻉是指,只会拷⻉基本数据类型的值,以及实例对象的引⽤地址,并不会复制⼀份引⽤地址所指向的对象,也就是浅拷⻉出来的对象,内部的类属性指向的是同⼀个对象
深拷⻉是指,既会拷⻉基本数据类型的值,也会针对实例对象的引⽤地址所指向的对象进⾏复制, 深拷⻉出来的对象,内部的属性指向的不是同⼀个对象
HashMap的扩容机制原理
1.7 版本

先⽣成新数组
遍历⽼数组中的每个位置上的链表上的每个元素
取每个元素的key,并基于新数组⻓度,计算出每个元素在新数组中的下标
将元素添加到新数组中去
所有元素转移完了之后,将新数组赋值给HashMap对象的table属性
1.8 版本

先⽣成新数组
遍历⽼数组中的每个位置上的链表或红⿊树
如果是链表,则直接将链表中的每个元素重新计算下标,并添加到新数组中去
如果是红⿊树,则先遍历红⿊树,先计算出红⿊树中每个元素对应在新数组中的下标位置
a. 统计每个下标位置的元素个数
b. 如果该位置下的元素个数超过了8,则⽣成⼀个新的红⿊树,并将根节点的添加到新数组的对应位置
c. 如果该位置下的元素个数没有超过8,那么则⽣成⼀个链表,并将链表的头节点添加到新数组的对应位置
所有元素转移完了之后,将新数组赋值给HashMap对象的table属性
CopyOnWriteArrayList的底层原理是怎样的
⾸先CopyOnWriteArrayList内部也是⽤过数组来实现的,在向CopyOnWriteArrayList添加元素时,会复制⼀个新的数组,写操作在新数组上进⾏,读操作在原数组上进⾏
并且,写操作会加锁,防⽌出现并发写⼊丢失数据的问题
写操作结束之后会把原数组指向新数组
CopyOnWriteArrayList允许在写操作时来读取数据,⼤⼤提⾼了读的性能,因此适合读多写少的应
⽤场景,但是CopyOnWriteArrayList会⽐较占内存,同时可能读到的数据不是实时最新的数据,所以不适合实时性要求很⾼的场景
什么是字节码?采⽤字节码的好处是什么?
编译器(javac)将Java源⽂件(.java)⽂件编译成为字节码⽂件(.class),可以做到⼀次编译到处运⾏,
windows上编译好的class⽂件,可以直接在linux上运⾏,通过这种⽅式做到跨平台,不过Java的跨平台有⼀个前提条件,就是不同的操作系统上安装的JDK或JRE是不⼀样的,虽然字节码是通⽤的,但是需要把字节码解释成各个操作系统的机器码是需要不同的解释器的,所以针对各个操作系统需要有各⾃ 的JDK或JRE。

采⽤字节码的好处,⼀⽅⾯实现了跨平台,另外⼀⽅⾯也提⾼了代码执⾏的性能,编译器在编译源代码 时可以做⼀些编译期的优化,⽐如锁消除、标量替换、⽅法内联等。

Java中的异常体系是怎样的
● Java中的所有异常都来⾃顶级⽗类Throwable。
● Throwable下有两个⼦类Exception和Error。
● Error表示⾮常严重的错误,⽐如java.lang.StackOverFlowError和Java.lang.OutOfMemoryError, 通常这些错误出现时,仅仅想靠程序⾃⼰是解决不了的,可能是虚拟机、磁盘、操作系统层⾯出现 的问题了,所以通常也不建议在代码中去捕获这些Error,因为捕获的意义不⼤,因为程序可能已经 根本运⾏不了了。
● Exception表示异常,表示程序出现Exception时,是可以靠程序⾃⼰来解决的,⽐如
NullPointerException、IllegalAccessException等,我们可以捕获这些异常来做特殊处理。

● Exception的⼦类通常⼜可以分为RuntimeException和⾮RuntimeException两类
● RunTimeException表示运⾏期异常,表示这个异常是在代码运⾏过程中抛出的,这些异常是⾮检查
异常,程序中可以选择捕获处理,也可以不处理。这些异常⼀般是由程序逻辑错误引起的,程序应该从逻辑⻆度尽可能避免这类异常的发⽣,⽐如NullPointerException、IndexOutOfBoundsException等。
● ⾮RuntimeException表示⾮运⾏期异常,也就是我们常说的检查异常,是必须进⾏处理的异常,如果
不处理,程序就不能检查异常通过。如IOException、SQLException等以及⽤户⾃定义的Exception异常

在Java的异常处理机制中,什么时候应该抛出异常,什么时候捕获异常?
异常相当于⼀种提示,如果我们抛出异常,就相当于告诉上层⽅法,我抛了⼀个异常,我处理不了这个异常,交给你来处理,⽽对于上层⽅法来说,它也需要决定⾃⼰能不能处理这个异常,是否也需要交给它的上层。

所以我们在写⼀个⽅法时,我们需要考虑的就是,本⽅法能否合理的处理该异常,如果处理不了就继续 向上抛出异常,包括本⽅法中在调⽤另外⼀个⽅法时,发现出现了异常,如果这个异常应该由⾃⼰来处理,那就捕获该异常并进⾏处理。

Java中有哪些类加载器
JDK⾃带有三个类加载器:bootstrap ClassLoader、ExtClassLoader、AppClassLoader。

● BootStrapClassLoader是ExtClassLoader的⽗类加载器,默认负责加载%JAVA_HOME%lib下的
jar包和class⽂件。
● ExtClassLoader是AppClassLoader的⽗类加载器,负责加载%JAVA_HOME%/lib/ext⽂件夹下的
jar包和class类。
● AppClassLoader是⾃定义类加载器的⽗类,负责加载classpath下的类⽂件。

说说类加载器双亲委派模型
JVM中存在三个默认的类加载器:

BootstrapClassLoader

ExtClassLoader

AppClassLoader

AppClassLoader的⽗加载器是ExtClassLoader,ExtClassLoader的⽗加载器是BootstrapClassLoader。

JVM在加载⼀个类时,会调⽤AppClassLoader的loadClass⽅法来加载这个类,不过在这个⽅法中,会 先使⽤ExtClassLoader的loadClass⽅法来加载类,同样ExtClassLoader的loadClass⽅法中会先使⽤
BootstrapClassLoader来加载类,如果BootstrapClassLoader加载到了就直接成功,如果
BootstrapClassLoader没有加载到,那么ExtClassLoader就会⾃⼰尝试加载该类,如果没有加载到, 那么则会由AppClassLoader来加载这个类。

所以,双亲委派指得是,JVM在加载类时,会委派给Ext和Bootstrap进⾏加载,如果没加载到才由⾃⼰进⾏加载。

JVM中哪些是线程共享区
堆区和⽅法区是所有线程共享的,栈、本地⽅法栈、程序计数器是每个线程独有的

你们项⽬如何排查JVM问题
对于还在正常运⾏的系统:

可以使⽤jmap来查看JVM中各个区域的使⽤情况
可以通过jstack来查看线程的运⾏情况,⽐如哪些线程阻塞、是否出现了死锁
可以通过jstat命令来查看垃圾回收的情况,特别是fullgc,如果发现fullgc⽐较频繁,那么就得进⾏ 调优了
通过各个命令的结果,或者jvisualvm等⼯具来进⾏分析
⾸先,初步猜测频繁发送fullgc的原因,如果频繁发⽣fullgc但是⼜⼀直没有出现内存溢出,那么表 示fullgc实际上是回收了很多对象了,所以这些对象最好能在younggc过程中就直接回收掉,避免这些对象进⼊到⽼年代,对于这种情况,就要考虑这些存活时间不⻓的对象是不是⽐较⼤,导致年轻 代放不下,直接进⼊到了⽼年代,尝试加⼤年轻代的⼤⼩,如果改完之后,fullgc减少,则证明修改有效
同时,还可以找到占⽤CPU最多的线程,定位到具体的⽅法,优化这个⽅法的执⾏,看是否能避免某些对象的创建,从⽽节省内存
对于已经发⽣了OOM的系统:

⼀般⽣产系统中都会设置当系统发⽣了OOM时,⽣成当时的dump⽂件(- XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/usr/local/base)
我们可以利⽤jsisualvm等⼯具来分析dump⽂件
根据dump⽂件找到异常的实例对象,和异常的线程(占⽤CPU⾼),定位到具体的代码
然后再进⾏详细的分析和调试
总之,调优不是⼀蹴⽽就的,需要分析、推理、实践、总结、再分析,最终定位到具体的问题

⼀个对象从加载到JVM,再到被GC清除,都经历了什么过程?
⾸先把字节码⽂件内容加载到⽅法区
然后再根据类信息在堆区创建对象
对象⾸先会分配在堆区中年轻代的Eden区,经过⼀次Minor GC后,对象如果存活,就会进⼊
Suvivor区。在后续的每次Minor GC中,如果对象⼀直存活,就会在Suvivor区来回拷⻉,每移动
⼀次,年龄加1
当年龄超过15后,对象依然存活,对象就会进⼊⽼年代
如果经过Full GC,被标记为垃圾对象,那么就会被GC线程清理掉
怎么确定⼀个对象到底是不是垃圾?

引⽤计数算法: 这种⽅式是给堆内存当中的每个对象记录⼀个引⽤个数。引⽤个数为0的就认为是垃圾。这是早期JDK中使⽤的⽅式。引⽤计数⽆法解决循环引⽤的问题。
可达性算法: 这种⽅式是在内存中,从根对象向下⼀直找引⽤,找到的对象就不是垃圾,没找到的对象就是垃圾。
JVM有哪些垃圾回收算法?
标记清除算法:
a. 标记阶段:把垃圾内存标记出来
b. 清除阶段:直接将垃圾内存回收。
c. 这种算法是⽐较简单的,但是有个很严重的问题,就是会产⽣⼤量的内存碎⽚。
复制算法:为了解决标记清除算法的内存碎⽚问题,就产⽣了复制算法。复制算法将内存分为⼤⼩ 相等的两半,每次只使⽤其中⼀半。垃圾回收时,将当前这⼀块的存活对象全部拷⻉到另⼀半,然后当前这⼀半内存就可以直接清除。这种算法没有内存碎⽚,但是他的问题就在于浪费空间。⽽ 且,他的效率跟存活对象的个数有关。
标记压缩算法:为了解决复制算法的缺陷,就提出了标记压缩算法。这种算法在标记阶段跟标记清 除算法是⼀样的,但是在完成标记之后,不是直接清理垃圾内存,⽽是将存活对象往⼀端移动,然后将边界以外的所有内存直接清除。
什么是STW?
STW: Stop-The-World,是在垃圾回收算法执⾏过程当中,需要将JVM内存冻结的⼀种状态。在STW 状态下,JAVA的所有线程都是停⽌执⾏的-GC线程除外,native⽅法可以执⾏,但是,不能与JVM交互。GC各种算法优化的重点,就是减少STW,同时这也是JVM调优的重点。

JVM参数有哪些?
JVM参数⼤致可以分为三类:

标注指令: -开头,这些是所有的HotSpot都⽀持的参数。可以⽤java -help 打印出来。
⾮标准指令: -X开头,这些指令通常是跟特定的HotSpot版本对应的。可以⽤java -X 打印出来。
不稳定参数: -XX 开头,这⼀类参数是跟特定HotSpot版本对应的,并且变化⾮常⼤。
说说对线程安全的理解
线程安全指的是,我们写的某段代码,在多个线程同时执⾏这段代码时,不会产⽣混乱,依然能够得到 正常的结果,⽐如i++,i初始化值为0,那么两个线程来同时执⾏这⾏代码,如果代码是线程安全的,那 么最终的结果应该就是⼀个线程的结果为1,⼀个线程的结果为2,如果出现了两个线程的结果都为1,则表示这段代码是线程不安全的。

所以线程安全,主要指的是⼀段代码在多个线程同时执⾏的情况下,能否得到正确的结果。

对守护线程的理解
线程分为⽤户线程和守护线程,⽤户线程就是普通线程,守护线程就是JVM的后台线程,⽐如垃圾回收 线程就是⼀个守护线程,守护线程会在其他普通线程都停⽌运⾏之后⾃动关闭。我们可以通过设置
thread.setDaemon(true)来把⼀个线程设置为守护线程。

ThreadLocal的底层原理
ThreadLocal是Java中所提供的线程本地存储机制,可以利⽤该机制将数据缓存在某个线程内部, 该线程可以在任意时刻、任意⽅法中获取缓存的数据
ThreadLocal底层是通过ThreadLocalMap来实现的,每个Thread对象(注意不是ThreadLocal对 象)中都存在⼀个ThreadLocalMap,Map的key为ThreadLocal对象,Map的value为需要缓存的

如果在线程池中使⽤ThreadLocal会造成内存泄漏,因为当ThreadLocal对象使⽤完之后,应该要把设置的key,value,也就是Entry对象进⾏回收,但线程池中的线程不会回收,⽽线程对象是通过强引⽤指向ThreadLocalMap,ThreadLocalMap也是通过强引⽤指向Entry对象,线程不被回收,
Entry对象也就不会被回收,从⽽出现内存泄漏,解决办法是,在使⽤了ThreadLocal对象之后,⼿动调⽤ThreadLocal的remove⽅法,⼿动清楚Entry对象
ThreadLocal经典的应⽤场景就是连接管理(⼀个线程持有⼀个连接,该连接对象可以在不同的⽅法之间进⾏传递,线程之间不共享同⼀个连接)
并发、并⾏、串⾏之间的区别
串⾏:⼀个任务执⾏完,才能执⾏下⼀个任务
并⾏(Parallelism):两个任务同时执⾏
并发(Concurrency):两个任务整体看上去是同时执⾏,在底层,两个任务被拆成了很多份,然后
⼀个⼀个执⾏,站在更⾼的⻆度看来两个任务是同时在执⾏的
Java死锁如何避免?
造成死锁的⼏个原因:

⼀个资源每次只能被⼀个线程使⽤
⼀个线程在阻塞等待某个资源时,不释放已占有资源
⼀个线程已经获得的资源,在未使⽤完之前,不能被强⾏剥夺
若⼲线程形成头尾相接的循环等待资源关系
这是造成死锁必须要达到的4个条件,如果要避免死锁,只需要不满⾜其中某⼀个条件即可。⽽其中前3 个条件是作为锁要符合的条件,所以要避免死锁就需要打破第4个条件,不出现循环等待锁的关系。

在开发过程中:

要注意加锁顺序,保证每个线程按同样的顺序进⾏加锁
要注意加锁时限,可以针对所设置⼀个超时时间
要注意死锁检查,这是⼀种预防机制,确保在第⼀时间发现死锁并进⾏解决
线程池的底层⼯作原理
线程池内部是通过队列+线程实现的,当我们利⽤线程池执⾏任务时:

如果此时线程池中的线程数量⼩于corePoolSize,即使线程池中的线程都处于空闲状态,也要创建新的线程来处理被添加的任务。
如果此时线程池中的线程数量等于corePoolSize,但是缓冲队列workQueue未满,那么任务被放⼊缓冲队列。
如果此时线程池中的线程数量⼤于等于corePoolSize,缓冲队列workQueue满,并且线程池中的数量⼩于maximumPoolSize,建新的线程来处理被添加的任务。
如果此时线程池中的线程数量⼤于corePoolSize,缓冲队列workQueue满,并且线程池中的数量等于maximumPoolSize,那么通过 handler所指定的策略来处理此任务。
当线程池中的线程数量⼤于 corePoolSize时,如果某线程空闲时间超过keepAliveTime,线程将被终⽌。这样,线程池可以动态的调整池中的线程数
线程池为什么是先添加列队⽽不是先创建最⼤线程?
当线程池中的核⼼线程都在忙时,如果继续往线程池中添加任务,那么任务会先放⼊队列,队列满了之 后,才会新开线程。这就相当于,⼀个公司本来有10个程序员,本来这10个程序员能正常的处理各种需求,但是随着公司的发展,需求在慢慢的增加,但是⼀开始这些需求只会增加在待开发列表中,然后这
10个程序员加班加点的从待开发列表中获取需求并进⾏处理,但是某⼀天待开发列表满了,公司发现现有的10个程序员是真的处理不过来了,所以就开始新招员⼯了。

ReentrantLock中的公平锁和⾮公平锁的底层实现
⾸先不管是公平锁和⾮公平锁,它们的底层实现都会使⽤AQS来进⾏排队,它们的区别在于:线程在使
⽤lock()⽅法加锁时,如果是公平锁,会先检查AQS队列中是否存在线程在排队,如果有线程在排队, 则当前线程也进⾏排队,如果是⾮公平锁,则不会去检查是否有线程在排队,⽽是直接竞争锁。

不管是公平锁还是⾮公平锁,⼀旦没竞争到锁,都会进⾏排队,当锁释放时,都是唤醒排在最前⾯的线 程,所以⾮公平锁只是体现在了线程加锁阶段,⽽没有体现在线程被唤醒阶段。

另外,ReentrantLock是可重⼊锁,不管是公平锁还是⾮公平锁都是可重⼊的。

ReentrantLock中tryLock()和lock()⽅法的区别
tryLock()表示尝试加锁,可能加到,也可能加不到,该⽅法不会阻塞线程,如果加到锁则返回
true,没有加到则返回false
lock()表示阻塞加锁,线程会阻塞直到加到锁,⽅法也没有返回值
CountDownLatch和Semaphore的区别和底层原理
CountDownLatch表示计数器,可以给CountDownLatch设置⼀个数字,⼀个线程调⽤
CountDownLatch的await()将会阻塞,其他线程可以调⽤CountDownLatch的countDown()⽅法来对
CountDownLatch中的数字减⼀,当数字被减成0后,所有await的线程都将被唤醒。
对应的底层原理就是,调⽤await()⽅法的线程会利⽤AQS排队,⼀旦数字被减为0,则会将AQS中 排队的线程依次唤醒

Semaphore表示信号量,可以设置许可的个数,表示同时允许最多多少个线程使⽤该信号量,通 过acquire()来获取许可,如果没有许可可⽤则线程阻塞,并通过AQS来排队,可以通过release()

⽅法来释放许可,当某个线程释放了某个许可后,会从AQS中正在排队的第⼀个线程开始依次唤 醒,直到没有空闲许可。

Sychronized的偏向锁、轻量级锁、重量级锁
偏向锁:在锁对象的对象头中记录⼀下当前获取到该锁的线程ID,该线程下次如果⼜来获取该锁就可以直接获取到了
轻量级锁:由偏向锁升级⽽来,当⼀个线程获取到锁后,此时这把锁是偏向锁,此时如果有第⼆个线程来竞争锁,偏向锁就会升级为轻量级锁,之所以叫轻量级锁,是为了和重量级锁区分开来,轻 量级锁底层是通过⾃旋来实现的,并不会阻塞线程
如果⾃旋次数过多仍然没有获取到锁,则会升级为重量级锁,重量级锁会导致线程阻塞
⾃旋锁:⾃旋锁就是线程在获取锁的过程中,不会去阻塞线程,也就⽆所谓唤醒线程,阻塞和唤醒 这两个步骤都是需要操作系统去进⾏的,⽐较消耗时间,⾃旋锁是线程通过CAS获取预期的⼀个标记,如果没有获取到,则继续循环获取,如果获取到了则表示获取到了锁,这个过程线程⼀直在运
⾏中,相对⽽⾔没有使⽤太多的操作系统资源,⽐较轻量。
Sychronized和ReentrantLock的区别
sychronized是⼀个关键字,ReentrantLock是⼀个类
sychronized会⾃动的加锁与释放锁,ReentrantLock需要程序员⼿动加锁与释放锁
sychronized的底层是JVM层⾯的锁,ReentrantLock是API层⾯的锁
sychronized是⾮公平锁,ReentrantLock可以选择公平锁或⾮公平锁
sychronized锁的是对象,锁信息保存在对象头中,ReentrantLock通过代码中int类型的state标识来标识锁的状态
sychronized底层有⼀个锁升级的过程
谈谈你对AQS的理解,AQS如何实现可重⼊锁?
AQS是⼀个JAVA线程同步的框架。是JDK中很多锁⼯具的核⼼实现框架。
在AQS中,维护了⼀个信号量state和⼀个线程组成的双向链表队列。其中,这个线程队列,就是⽤来给线程排队的,⽽state就像是⼀个红绿灯,⽤来控制线程排队或者放⾏的。 在不同的场景下, 有不⽤的意义。
在可重⼊锁这个场景下,state就⽤来表示加锁的次数。0标识⽆锁,每加⼀次锁,state就加1。释放锁state就减1。
谈谈你对IOC的理解
通常,我们认为Spring有两⼤特性IoC和AOP,那到底该如何理解IoC呢?

对于很多初学者来说,IoC这个概念给⼈的感觉就是我好像会,但是我说不出来。

那么IoC到底是什么,接下来来说说我的理解,实际上这是⼀个⾮常⼤的问题,所以我们就把它拆细了来回答,IoC表示控制反转,那么:

什么是控制?控制了什么?
什么是反转?反转之前是谁控制的?反转之后是谁控制的?如何控制的?
为什么要反转?反转之前有什么问题?反转之后有什么好处? 这就是解决这⼀类⼤问题的思路,⼤⽽化⼩。
那么,我们先来解决第⼀个问题:什么是控制?控制了什么? 我们在⽤Spring的时候,我们需要做什么:
建⼀些类,⽐如UserService、OrderService
⽤⼀些注解,⽐如@Autowired
但是,我们也知道,当程序运⾏时,⽤的是具体的UserService对象、OrderService对象,那这些对象是什么时候创建的?谁创建的?包括对象⾥的属性是什么时候赋的值?谁赋的?所有这些都是我们程序 员做的,以为我们只是写了类⽽已,所有的这些都是Spring做的,它才是幕后⿊⼿。

这就是控制:

控制对象的创建
控制对象内属性的赋值
如果我们不⽤Spring,那我们得⾃⼰来做这两件事,反过来,我们⽤Spring,这两件事情就不⽤我们做了,我们要做的仅仅是定义类,以及定义哪些属性需要Spring来赋值(⽐如某个属性上加
@Autowired),⽽这其实就是第⼆个问题的答案,这就是反转,表示⼀种对象控制权的转移。那反转有什么⽤,为什么要反转?
如果我们⾃⼰来负责创建对象,⾃⼰来给对象中的属性赋值,会出现什么情况?

⽐如,现在有三个类:

A类,A类⾥有⼀个属性C c;
B类,B类⾥也有⼀个属性C c;
C类
现在程序要运⾏,这三个类的对象都需要创建出来,并且相应的属性都需要有值,那么除开定义这三个类之外,我们还得写:

A a = new A();
B b = new B();
C c = new C();
a.c = c;
b.c = c;
这五⾏代码是不⽤Spring的情况下多出来的代码,⽽且,如果类在多⼀些,类中的属性在多⼀些,那相应的代码会更多,⽽且代码会更复杂。所以我们可以发现,我们⾃⼰来控制⽐交给Spring来控制,我们 的代码量以及代码复杂度是要⾼很多的,反⾔之,将对象交给Spring来控制,减轻了程序员的负担。

总结⼀下,IoC表示控制反转,表示如果⽤Spring,那么Spring会负责来创建对象,以及给对象内的属 性赋值,也就是如果⽤Spring,那么对象的控制权会转交给Spring。

单例Bean和单例模式
单例模式表示JVM中某个类的对象只会存在唯⼀⼀个。
⽽单例Bean并不表示JVM中只能存在唯⼀的某个类的Bean对象。

Spring事务传播机制
多个事务⽅法相互调⽤时,事务如何在这些⽅法间传播,⽅法A是⼀个事务的⽅法,⽅法A执⾏过程中调
⽤了⽅法B,那么⽅法B有⽆事务以及⽅法B对事务的要求不同都会对⽅法A的事务具体执⾏造成影响, 同时⽅法A的事务对⽅法B的事务执⾏也有影响,这种影响具体是什么就由两个⽅法所定义的事务传播类 型所决定。

REQUIRED(Spring默认的事务传播类型):如果当前没有事务,则⾃⼰新建⼀个事务,如果当前存在事务,则加⼊这个事务

SUPPORTS:当前存在事务,则加⼊当前事务,如果当前没有事务,就以⾮事务⽅法执⾏

MANDATORY:当前存在事务,则加⼊当前事务,如果当前事务不存在,则抛出异常。

REQUIRES_NEW:创建⼀个新事务,如果存在当前事务,则挂起该事务。

NOT_SUPPORTED:以⾮事务⽅式执⾏,如果当前存在事务,则挂起当前事务

NEVER:不使⽤事务,如果当前事务存在,则抛出异常

NESTED:如果当前事务存在,则在嵌套事务中执⾏,否则REQUIRED的操作⼀样(开启⼀个事 务)

Spring事务什么时候会失效?
spring事务的原理是AOP,进⾏了切⾯增强,那么失效的根本原因是这个AOP不起作⽤了!常⻅情况有如下⼏种

1、发⽣⾃调⽤,类⾥⾯使⽤this调⽤本类的⽅法(this通常省略),此时这个this对象不是代理类,⽽是
UserService对象本身!
解决⽅法很简单,让那个this变成UserService的代理类即可!
2、⽅法不是public的:@Transactional 只能⽤于 public 的⽅法上,否则事务不会失效,如果要⽤在
⾮ public ⽅法上,可以开启 AspectJ 代理模式。
3、数据库不⽀持事务
4、没有被spring管理
5、异常被吃掉,事务不会回滚(或者抛出的异常没有被定义,默认为RuntimeException)

 

JAVA基础
JAVA中的几种基本数据类型是什么,各自占用多少字节。
String类能被继承吗,为什么。
String,Stringbuffer,StringBuilder的区别。
ArrayList和LinkedList有什么区别。
讲讲类的实例化顺序,比如父类静态数据,构造函数,字段,子类静态数据,构造函数,字段,当new的时候,他们的执行顺序。
用过哪些Map类,都有什么区别,HashMap是线程安全的吗,并发下使用的Map是什么,他们内部原理分别是什么,比如存储方式,hashcode,扩容,默认容量等。
JAVA8的ConcurrentHashMap为什么放弃了分段锁,有什么问题吗,如果你来设计,你如何设计。
有没有有顺序的Map实现类,如果有,他们是怎么保证有序的。
抽象类和接口的区别,类可以继承多个类么,接口可以继承多个接口么,类可以实现多个接口么。
继承和聚合的区别在哪。
IO模型有哪些,讲讲你理解的nio ,他和bio,aio的区别是啥,谈谈reactor模型。
反射的原理,反射创建类实例的三种方式是什么。
反射中,Class.forName和ClassLoader区别 。
描述动态代理的几种实现方式,分别说出相应的优缺点。
动态代理与cglib实现的区别。
为什么CGlib方式可以对接口实现代理。
final的用途。
写出三种单例模式实现 。
如何在父类中为子类自动完成所有的hashcode和equals实现?这么做有何优劣。
请结合OO设计理念,谈谈访问修饰符public、private、protected、default在应用设计中的作用。
深拷贝和浅拷贝区别。
数组和链表数据结构描述,各自的时间复杂度。
error和exception的区别,CheckedException,RuntimeException的区别。
请列出5个运行时异常。
在自己的代码中,如果创建一个java.lang.String类,这个类是否可以被类加载器加载?为什么。
说一说你对java.lang.Object对象中hashCode和equals方法的理解。在什么场景下需
要重新实现这两个方法。
在jdk1.5中,引入了泛型,泛型的存在是用来解决什么问题。
这样的a.hashcode() 有什么用,与a.equals(b)有什么关系。
有没有可能2个不相等的对象有相同的hashcode。
Java中的HashSet内部是如何工作的。
什么是序列化,怎么序列化,为什么序列化,反序列化会遇到什么问题,如何解决。
java8的新特性。
JVM知识
什么情况下会发生栈内存溢出。
JVM的内存结构,Eden和Survivor比例。
JVM内存为什么要分成新生代,老年代,持久代。新生代中为什么要分为Eden和Survivor。
JVM中一次完整的GC流程是怎样的,对象如何晋升到老年代,说说你知道的几种主要的JVM参
数。
你知道哪几种垃圾收集器,各自的优缺点,重点讲下cms和G1,包括原理,流程,优缺点。
垃圾回收算法的实现原理。
当出现了内存溢出,你怎么排错。
JVM内存模型的相关知识了解多少,比如重排序,内存屏障,happen-before,主内存,工作
内存等。
简单说说你了解的类加载器,可以打破双亲委派么,怎么打破。
讲讲JAVA的反射机制。
你们线上应用的JVM参数有哪些。
g1和cms区别,吞吐量优先和响应优先的垃圾收集器选择。
怎么打出线程栈信息。
请解释如下jvm参数的含义:
-server -Xms512m -Xmx512m -Xss1024K
-XX:PermSize=256m -XX:MaxPermSize=512m -
XX:MaxTenuringThreshold=20XX:CMSInitiatingOccupancyFraction=80 -
XX:+UseCMSInitiatingOccupancyOnly。
开源框架知识
简单讲讲tomcat结构,以及其类加载器流程,线程模型等。
tomcat如何调优,涉及哪些参数 。
讲讲Spring加载流程。
Spring AOP的实现原理。
讲讲Spring事务的传播属性。
Spring如何管理事务的。
Spring怎么配置事务(具体说出一些关键的xml 元素)。
说说你对Spring的理解,非单例注入的原理?它的生命周期?循环注入的原理,aop的实现原
理,说说aop中的几个术语,它们是怎么相互工作的。
Springmvc 中DispatcherServlet初始化过程。
netty的线程模型,netty如何基于reactor模型上实现的。
为什么选择netty。
什么是TCP粘包,拆包。解决方式是什么。
netty的fashwheeltimer的用法,实现原理,是否出现过调用不够准时,怎么解决。
netty的心跳处理在弱网下怎么办。
netty的通讯协议是什么样的。
springmvc用到的注解,作用是什么,原理。
springboot启动机制。
点击这里有一套答案版的Spring试题。
操作系统
Linux系统下你关注过哪些内核参数,说说你知道的。
Linux下IO模型有几种,各自的含义是什么。
epoll和poll有什么区别。
平时用到哪些Linux命令。
用一行命令查看文件的最后五行。
用一行命令输出正在运行的java进程。
介绍下你理解的操作系统中线程切换过程。
进程和线程的区别。
top 命令之后有哪些内容,有什么作用。
线上CPU爆高,请问你如何找到问题所在。
多线程
多线程的几种实现方式,什么是线程安全。
volatile的原理,作用,能代替锁么。
画一个线程的生命周期状态图。
sleep和wait的区别。
sleep和sleep(0)的区别。
Lock与Synchronized的区别 。
synchronized的原理是什么,一般用在什么地方(比如加在静态方法和非静态方法的区别,静
态方法和非静态方法同时执行的时候会有影响吗),解释以下名词:重排序,自旋锁,偏向锁,轻
量级锁,可重入锁,公平锁,非公平锁,乐观锁,悲观锁。
用过哪些原子类,他们的原理是什么。
JUC下研究过哪些并发工具,讲讲原理。
用过线程池吗,如果用过,请说明原理,并说说newCache和newFixed有什么区别,构造函
数的各个参数的含义是什么,比如coreSize,maxsize等。
线程池的关闭方式有几种,各自的区别是什么。
假如有一个第三方接口,有很多个线程去调用获取数据,现在规定每秒钟最多有10个线程同
时调用它,如何做到。
spring的controller是单例还是多例,怎么保证并发的安全。
用三个线程按顺序循环打印abc三个字母,比如abcabcabc。
ThreadLocal用过么,用途是什么,原理是什么,用的时候要注意什么。
如果让你实现一个并发安全的链表,你会怎么做。
有哪些无锁数据结构,他们实现的原理是什么。
讲讲java同步机制的wait和notify。
CAS机制是什么,如何解决ABA问题。
多线程如果线程挂住了怎么办。
countdowlatch和cyclicbarrier的内部原理和用法,以及相互之间的差别(比如
countdownlatch的await方法和是怎么实现的)。
对AbstractQueuedSynchronizer了解多少,讲讲加锁和解锁的流程,独占锁和公平所
加锁有什么不同。
使用synchronized修饰静态方法和非静态方法有什么区别。
简述ConcurrentLinkedQueue和LinkedBlockingQueue的用处和不同之处。
导致线程死锁的原因?怎么解除线程死锁。
非常多个线程(可能是不同机器),相互之间需要等待协调,才能完成某种工作,问怎么设计这种协调方案。
用过读写锁吗,原理是什么,一般在什么场景下用。
开启多个线程,如果保证顺序执行,有哪几种实现方式,或者如何保证多个线程都执行完
再拿到结果。
延迟队列的实现方式,delayQueue和时间轮算法的异同。
点击这里有一套答案版的多线程试题。
TCP与HTTP
http1.0和http1.1有什么区别。
TCP三次握手和四次挥手的流程,为什么断开连接要4次,如果握手只有两次,会出现什么。
TIME_WAIT和CLOSE_WAIT的区别。
说说你知道的几种HTTP响应码,比如200, 302, 404。
当你用浏览器打开一个链接(如:http://www.javastack.cn)的时候,计算机做了哪些工作步骤。
TCP/IP如何保证可靠性,说说TCP头的结构。
如何避免浏览器缓存。
如何理解HTTP协议的无状态性。
简述Http请求get和post的区别以及数据包格式。
HTTP有哪些method
简述HTTP请求的报文格式。
HTTP的长连接是什么意思。
HTTPS的加密方式是什么,讲讲整个加密解密流程。
Http和https的三次握手有什么区别。
什么是分块传送。
Session和cookie的区别。
点击这里有一套答案版的试题。
架构设计与分布式
用java自己实现一个LRU。
分布式集群下如何做到唯一序列号。
设计一个秒杀系统,30分钟没付款就自动关闭交易。
如何使用redis和zookeeper实现分布式锁?有什么区别优缺点,会有什么问题,分别适用什么
场景。(延伸:如果知道redlock,讲讲他的算法实现,争议在哪里)
如果有人恶意创建非法连接,怎么解决。
分布式事务的原理,优缺点,如何使用分布式事务,2pc 3pc 的区别,解决了哪些问题,还有
哪些问题没解决,如何解决,你自己项目里涉及到分布式事务是怎么处理的。
什么是一致性hash。
什么是restful,讲讲你理解的restful。
如何设计一个良好的API。
如何设计建立和保持100w的长连接。
解释什么是MESI协议(缓存一致性)。
说说你知道的几种HASH算法,简单的也可以。
什么是paxos算法, 什么是zab协议。
一个在线文档系统,文档可以被编辑,如何防止多人同时对同
一份文档进行编辑更新。
线上系统突然变得异常缓慢,你如何查找问题。
说说你平时用到的设计模式。
Dubbo的原理,有看过源码么,数据怎么流转的,怎么实现集群,负载均衡,服务注册
和发现,重试转发,快速失败的策略是怎样的 。
一次RPC请求的流程是什么。
自己实现过rpc么,原理可以简单讲讲。Rpc要解决什么问题。
异步模式的用途和意义。
编程中自己都怎么考虑一些设计原则的,比如开闭原则,以及在工作中的应用。
设计一个社交网站中的“私信”功能,要求高并发、可扩展等等。 画一下架构图。
MVC模式,即常见的MVC框架。
聊下曾经参与设计的服务器架构并画图,谈谈遇到的问题,怎么解决的。
应用服务器怎么监控性能,各种方式的区别。
如何设计一套高并发支付方案,架构如何设计。
如何实现负载均衡,有哪些算法可以实现。
Zookeeper的用途,选举的原理是什么。
Zookeeper watch机制原理。
Mybatis的底层实现原理。
请思考一个方案,实现分布式环境下的countDownLatch。
后台系统怎么防止请求重复提交。
描述一个服务从发布到被消费的详细过程。
讲讲你理解的服务治理。
如何做到接口的幂等性。
如何做限流策略,令牌桶和漏斗算法的使用场景。
什么叫数据一致性,你怎么理解数据一致性。
分布式服务调用方,不依赖服务提供方的话,怎么处理服务方挂掉后,大量无效资源请求
的浪费,如果只是服务提供方吞吐不高的时候该怎么做,如果服务挂了,那么一会重启,该怎
么做到最小的资源浪费,流量半开的实现机制是什么。
dubbo的泛化调用怎么实现的,如果是你,你会怎么做。
远程调用会有超时现象,如果做到优雅的控制,JDK自带的超时机制有哪些,怎么实现的。
算法
10亿个数字里里面找最小的10个。
有1亿个数字,其中有2个是重复的,快速找到它,时间和空间要最优。
2亿个随机生成的无序整数,找出中间大小的值。
给一个不知道长度的(可能很大)输入字符串,设计一种方案,将重复的字符排重。
遍历二叉树。
有3n+1个数字,其中3n个中是重复的,只有1个是不重复的,怎么找出来。
写一个字符串(如:www.javastack.cn)反转函数。
常用的排序算法,快排,归并、冒泡。 快排的最优时间复杂度,最差复杂度。冒泡排序的
优化方案。
二分查找的时间复杂度,优势。
一个已经构建好的TreeSet,怎么完成倒排序。
什么是B+树,B-树,列出实际的使用场景。
一个单向链表,删除倒数第N个数据。
200个有序的数组,每个数组里面100个元素,找出top20的元素。
单向链表,查找中间的那个元素。
数据库知识
数据库隔离级别有哪些,各自的含义是什么,MYSQL默认的隔离级别是是什么。
什么是幻读。
MYSQL有哪些存储引擎,各自优缺点。
高并发下,如何做到安全的修改同一行数据。
乐观锁和悲观锁是什么,INNODB的标准行级锁有哪2种,解释其含义。
SQL优化的一般步骤是什么,怎么看执行计划,如何理解其中各个字段的含义。
数据库会死锁吗,举一个死锁的例子,mysql怎么解决死锁。
MYsql的索引原理,索引的类型有哪些,如何创建合理的索引,索引如何优化。
聚集索引和非聚集索引的区别。
select for update 是什么含义,会锁表还是锁行或是其他。
为什么要用Btree实现,它是怎么分裂的,什么时候分裂,为什么是平衡的。
数据库的ACID是什么。
某个表有近千万数据,CRUD比较慢,如何优化。
Mysql怎么优化table scan的。
如何写sql能够有效的使用到复合索引。
mysql中in 和exists 区别。
数据库自增主键可能的问题。
MVCC的含义,如何实现的。
你做过的项目里遇到分库分表了吗,怎么做的,有用到中间件么,比如sharding jdbc等,他
们的原理知道么。
MYSQL的主从延迟怎么解决。
消息队列
消息队列的使用场景。
消息的重发,补充策略。
如何保证消息的有序性。
用过哪些MQ,和其他mq比较有什么优缺点,MQ的连接是线程安全的吗,你们公司的MQ服务
架构怎样的。
MQ系统的数据如何保证不丢失。
rabbitmq如何实现集群高可用。
kafka吞吐量高的原因。
kafka 和其他消息队列的区别,kafka 主从同步怎么实现。
利用mq怎么实现最终一致性。
使用kafka有没有遇到什么问题,怎么解决的。
MQ有可能发生重复消费,如何避免,如何做到幂等。
MQ的消息延迟了怎么处理,消息可以设置过期时间么,过期了你们一般怎么处理。
缓存
常见的缓存策略有哪些,如何做到缓存(比如redis)与DB里的数据一致性,你们项目中用到了
什么缓存系统,如何设计的。
如何防止缓存击穿和雪崩。
缓存数据过期后的更新如何设计。
redis的list结构相关的操作。
Redis的数据结构都有哪些。
Redis的使用要注意什么,讲讲持久化方式,内存设置,集群的应用和优劣势,淘汰策略等。
redis2和redis3的区别,redis3内部通讯机制。
当前redis集群有哪些玩法,各自优缺点,场景。
Memcache的原理,哪些数据适合放在缓存中。
redis和memcached 的内存管理的区别。
Redis的并发竞争问题如何解决,了解Redis事务的CAS操作吗。
Redis的选举算法和流程是怎样的。
redis的持久化的机制,aof和rdb的区别。
redis的集群怎么同步的数据的。
知道哪些redis的优化操作。
Reids的主从复制机制原理。
Redis的线程模型是什么。
请思考一个方案,设计一个可以控制缓存总体大小的自动适应的本地缓存。
如何看待缓存的使用(本地缓存,集中式缓存),简述本地缓存和集中式缓存和优缺点。
本地缓存在并发使用时的注意事项。
搜索
elasticsearch了解多少,说说你们公司es的集群架构,索引数据大小,分片有多少,以及一些
调优手段 。elasticsearch的倒排索引是什么。
elasticsearch 索引数据多了怎么办,如何调优,部署。
elasticsearch是如何实现master选举的。
详细描述一下Elasticsearch索引文档的过程。
详细描述一下Elasticsearch搜索的过程。
Elasticsearch在部署时,对Linux的设置有哪些优化方法?
lucence内部结构是什么。

标签:面试题,多测师,对象,链表,线程,JVM,如果,Java,杭州
来源: https://www.cnblogs.com/xiaoshubass/p/16582016.html