小提示：绿色的题代表是简单的，黄色的题代表中等，红色代表有点难度；绿色题回答的很全面，很深入，则有可能比红色的题还难；蓝色的是作为扩展，面试的时候问到的不是很多，能答出来挺好，答不出来也没关系

java基础

Queue和Stack你平时有用过么，说说你常用的方法，他们的区别在哪呢？**

**

了解java的异常吗，有什么区别，常见的异常有哪些呢？


编译时异常 和 运行时异常 父类都是Throwable

Error
Java运行时系统的内部错误和资源耗尽错误。应用不会抛出该类对象，如果出现了这样的错误，除了告知用户，剩下的就是尽力是程序安全的终止。
Exception
CheckedException: IO异常 SQL 异常
发生在编译阶段，Java编译器会强制程序捕获相关异常 try catch finally
RunTimeException: 空指针 类型转换错误
在Java虚拟机运行期间可能出现的异常，一定是代码的问题。

异常处理的三种方式：try catch ; throw throws

两个字面值相同的Integer，它们两个用等于号去比较，结果是true还是false？（这个题要分两部分去回答，结果可能为true，也可能为false。因为有缓存）


当大于或者等于128的时候不相等
JVM 会自动维护八种基本类型的常量池，int常量池中初始化-128-127的范围，所以当Integer=127 时，自动装箱过程是取常量池中的数据
可以使用inValue 比较或者使用equals比较

可以讲一下你常用的集合类么？他们的实现类有哪些？

ArrayList
LinkedArrayList
HashMap
Set 值的存储无序，值不能重复。可以覆盖对象的hashCode和equals 方法

ArrayList、LinkedList的区别，底层的实现呢了解吗，有没有什么优缺点，分别适合于什么样的场景，多线程环境下，有没有安全的list的实现类呢？


ArrayList 是List接口的可变数组非同步实现，并允许包含null 在内的所有元素。
底层用数组实现，默认扩容1.5倍，
由于扩容需要把老数组的数据拷贝一份到新的数据组，效率太低

LinkedList 是List接口的双向链表非同步实现，允许包含null在内的所有元素。
底层数据结构是双向链表

查找方式是对半查找
各自优缺点：
随机Index 访问 ArrayList 速度优于LinkedList
新增和删除元素 LinkedList 速度优于ArrayList

Vector 线程安全 也是用数组实现，某一时刻只有一个线程能够写Vector synchronized

其他数据结构的了解吗？LinkedHashMap、ConcurrentSkipHashMap（作为一个扩展，面试的时候问到的不是很多，能答出来挺好，答不出来也没关系）

IdentityHashMap

IdentityHashMap

说一说你对HashSet的理解

越详细越好 ( tip：底层是用hashMap实现的)，treeSet有了解吗？聊一聊？

HashSet实现了Set接口，不允许出现重复元素。底层使用HashMap实现
元素集合使用HashMap的可以來保存。存儲对象一般要重写该类的hashCode 和 equals接口 两个方法的返回值需要一致。

HashMap的疯狂试探：

HashMap的底层数据结构是什么样子的

数组+链表+红黑树 根据元素的hashCode 存储数据
内部使用实体嵌套类Entry实现，Entry包含四个属性 key value hash 和用于单向链表的next
capacity : 当前数组容量 始终保持2^n 扩容后数组大小应该是当前的2倍
loadFactor 负载因子 默认为0.75
threshold： 扩容的阈值 为 capacity * loadFactor

了解hash冲突吗？它是如何解决hash冲突的

hash冲突，根据key 通过一定的函数计算出来的值作为地址去进行存储时，当前位置已经有数据存在。当到当前位置Entry 的next节点

请你简单叙述一下hashMap的put和get操作，当然，能说多细就说多细？

跟hash冲突一个思路

Jdk7和jdk8中对hashMap做了什么改进嘛（红黑树）？

特殊的二叉查找树
（1）若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
（2） 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
（3） 任意节点的左、右子树也分别为二叉查找树；
（4） 没有键值相等的节点。

有没有其他的解决冲突的办法呢

HashMap中的hash函数了解吗？那他的扩容机制了解吗？

HashMap为什么扩容是2倍呢，可以说说嘛？

HashMap为了存取高效，要尽量较少碰撞，就是要尽量把数据分配均匀，每个链表长度大致相同，这个实现就在把数据存到哪个链表中的算法；
这个算法实际就是取模，hash%length，计算机中直接求余效率不如位移运算，源码中做了优化hash&(length-1)，
hash%length==hash&(length-1)的前提是length是2的n次方；
为什么这样能均匀分布减少碰撞呢？2的n次方实际就是1后面n个0，2的n次方-1 实际就是n个1；
例如长度为9时候，3&(9-1)=0 2&(9-1)=0 ，都在0上，碰撞了；
例如长度为8时候，3&(8-1)=3 2&(8-1)=2 ，不同位置上，不碰撞；
为啥用16不用别的呢？
因为在使用2的幂的数字的时候，Length-1的值是所有二进制位全为1，这种情况下，index的结果等同于HashCode后几位的值。
只要输入的HashCode本身分布均匀，Hash算法的结果就是均匀的。
这是为了实现均匀分布**。

假如说我加入一个键值对，这个时候出现了冲突，它只怎么把这个节点加入进去？

是加入到当前bucket所对应的链表的头结点还是尾节点？（答不上来可以问一个稍微简单的，equals和 == 的区别，以及其中hashCode的作用）
Jdk7 是头节点 jsk8 之后是尾节点
**

可以说说什么条件下，可以把一个链表转成红黑树呢？它里面的大概流程是什么，了解吗？


链表元素超过8个的时候

有没有想过为什么选用了红黑树，而不是其他的数据结构，譬如说二叉树，二叉查找树，或者其他的树？

**

在高并发大流量的情况下，hashMap有什么问题吗，会不会造成cpu达到100%？如果会，那是在哪一步可能会出现这个问题呢（插入、删除、查找、扩容）？


1）多线程put的时候可能导致元素丢失在并发环境下会发生错误，导致数组链表中的链表形成循环链表，在后面的get操作时e = e.next操作无限循环，Infinite Loop出现
2）HashMap在并发环境下多线程put后可能导致get死循环
线程不安全

ConcurrentHashMap的疯狂试探：

**

他和HashTable的区别呢？

线程同步Hashtable 是锁住整个数据结构 ConcurrentHashMap是采用分段锁
**

说说你对JUC包的了解？

**
java.util.concurrent
提供了多种并发容器类来改进同步容器的性能;

ConcurrentHashMap中是怎么加锁的？

内部
ConCurrentHashMap 1.8 相比 1.7的话，主要改变为：

  • 去除 Segment + HashEntry + Unsafe 的实现，
    改为 Synchronized + CAS + Node + Unsafe 的实现
    其实 Node 和 HashEntry 的内容一样，但是HashEntry是一个内部类。
    用 Synchronized + CAS 代替 Segment ，这样锁的粒度更小了，并且不是每次都要加锁了，CAS尝试失败了在加锁。
  • put()方法中 初始化数组大小时，1.8不用加锁，因为用了个 sizeCtl 变量，将这个变量置为-1，就表明table正在初始化。

**

put() 方法

JDK1.7中的实现：
ConCurrentHashMap 和 HashMap 的put()方法实现基本类似，所以主要讲一下为了实现并发性，ConCurrentHashMap 1.7 有了什么改变

  • 需要定位 2 次 （segments[i]，segment中的table[i]） 由于引入segment的概念，所以需要
    1. 先通过key的 rehash值的高位 和 segments数组大小-1 相与得到在 segments中的位置
    2. 然后在通过 key的rehash值 和 table数组大小-1 相与得到在table中的位置
  • 没获取到 segment锁的线程，没有权力进行put操作，不是像HashTable一样去挂起等待，而是会去做一下put操作前的准备：
    1. table[i]的位置(你的值要put到哪个桶中)
    2. 通过首节点first遍历链表找有没有相同key
    3. 在进行1、2的期间还不断自旋获取锁，超过 64次 线程挂起！

JDK1.8中的实现：

  • 先拿到根据 rehash值 定位，拿到table[i]的 首节点first，然后：

    1. 如果为 null ，通过 CAS 的方式把 value put进去
    2. 如果 非null ，并且 first.hash == -1 ，说明其他线程在扩容，参与一起扩容
    3. 如果 非null ，并且 first.hash != -1 ，Synchronized锁住 first节点，判断是链表还是红黑树，遍历插入。

      get() 方法

      JDK1.7中的实现：

  • 由于变量 value 是由 volatile 修饰的，java内存模型中的 happen before 规则保证了 对于 volatile 修饰的变量始终是 写操作 先于 读操作 的，并且还有 volatile 的 内存可见性 保证修改完的数据可以马上更新到主存中，所以能保证在并发情况下，读出来的数据是最新的数据。

  • 如果get()到的是null值才去加锁。

JDK1.8中的实现：

  • 和 JDK1.7类似

    resize() 方法

    JDK1.7中的实现：

  • 跟HashMap的 resize() 没太大区别，都是在 put() 元素时去做的扩容，所以在1.7中的实现是获得了锁之后，在单线程中去做扩容（1.new个2倍数组 2.遍历old数组节点搬去新数组）。

JDK1.8中的实现：

  • jdk1.8的扩容支持并发迁移节点，从old数组的尾部开始，如果该桶被其他线程处理过了，就创建一个 ForwardingNode 放到该桶的首节点，hash值为-1，其他线程判断hash值为-1后就知道该桶被处理过了。

    计算size

    JDK1.7中的实现：

    1. 先采用不加锁的方式，计算两次，如果两次结果一样，说明是正确的，返回。
    2. 如果两次结果不一样，则把所有 segment 锁住，重新计算所有 segment的 Count 的和

JDK1.8中的实现：
由于没有segment的概念，所以只需要用一个 baseCount 变量来记录ConcurrentHashMap 当前 节点的个数。

  1. 先尝试通过CAS 修改 baseCount
  2. 如果多线程竞争激烈，某些线程CAS失败，那就CAS尝试将 CELLSBUSY 置1，成功则可以把 baseCount变化的次数 暂存到一个数组 counterCells 里，后续数组 counterCells 的值会加到 baseCount 中。
  3. 如果 CELLSBUSY 置1失败又会反复进行CASbaseCount 和 CAScounterCells数组

1.7和1.8中，ConcurrentHashMap的区别是什么？

**去除 Segment + HashEntry + Unsafe 的实现，
改为 Synchronized + CAS + Node + Unsafe 的实现

jdk1.8 中 ConcurrentHashMap取消了segment分段锁，而采用CAS和synchronized来保证并发安全。数据结构跟HashMap1.8的结构一样，数组+链表/红黑二叉树。
synchronized只锁定当前链表或红黑二叉树的首节点，这样只要hash不冲突，就不会产生并发，效率又提升N倍。

ConcurrentHashMap是怎么做到线程安全的呢？（CAS和锁）

**
CAS是英文单词Compare And Swap的缩写，翻译过来就是比较并替换。
CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。
更新一个变量的时候，只有当变量的预期值A和内存地址V当中的实际值相同时，才会将内存地址V对应的值修改为B。
CAS是英文单词Compare And Swap的缩写，翻译过来就是比较并替换。
CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。
更新一个变量的时候，只有当变量的预期值A和内存地址V当中的实际值相同时，才会将内存地址V对应的值修改为B。

**

为什么会抛弃分段锁，它有什么毛病吗（上面一个题回答上才可以问这个）？

**

关于分段锁

段Segment继承了重入锁ReentrantLock，有了锁的功能，每个锁控制的是一段，当每个Segment越来越大时，锁的粒度就变得有些大了。

  • 分段锁的优势在于保证在操作不同段 map 的时候可以并发执行，操作同段 map 的时候，进行锁的竞争和等待。这相对于直接对整个map同步synchronized是有优势的。
  • 缺点在于分成很多段时会比较浪费内存空间(不连续，碎片化); 操作map时竞争同一个分段锁的概率非常小时，分段锁反而会造成更新等操作的长时间等待; 当某个段很大时，分段锁的性能会下降。

知道红黑树的transfer过程么？简单的描述一下

**
当数组大小已经超过64并且链表中的元素个数超过默认设定（8个）时，将链表转化为红黑树

多线程下的疯狂试探：

多线程了解吗？说说线程的生命周期？


新建(New)、就绪（Runnable）、运行（Running）、阻塞(Blocked)和死亡(Dead)5种状态**。尤其是当线程启动以后，它不可能一直”霸占”着CPU独自运行，所以CPU需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换

线程池有用到过吗？怎么用的，jdk有提供那些线程池（总共提供了四种）？

**
ExecutorService pool = Executors.newCachedThreadPool();//

可缓存线程池：

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

ExecutorService pool = Executors.newScheduledThreadPool(10);//

定长线程池：

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

ExecutorService pool = Executors.newSingleThreadExecutor(); //Step1 创建线程池

线程化的线程池：

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

ExecutorService pool = Executors.newFixedThreadPool(10);

定长线程池：

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


线程的状态有哪些呢？


新建(New)、就绪（Runnable）、运行（Running）、阻塞(Blocked)和死亡(Dead)5种状态

线程池的核心参数有哪些？

（核心线程数、最大线程数、时间、时间单位、队列、拒绝策略、默认的线程工厂）

  1.                 **      int corePoolSize,**<br />线程池新建线程的时候，如果当前线程总数小于corePoolSize，则新建的是核心线程，如果超过corePoolSize，则新建的是非核心线程<br />核心线程默认情况下会一直存活在线程池中，即使这个核心线程啥也不干(闲置状态)。<br />如果指定ThreadPoolExecutor的allowCoreThreadTimeOut这个属性为true，那么核心线程如果不干活(闲置状态)的话，超过一定时间(时长下面参数决定)，就会被销毁掉

int maximumPoolSize,

long keepAliveTime,
该线程池中非核心线程闲置超时时长
一个非核心线程，如果不干活(闲置状态)的时长超过这个参数所设定的时长，就会被销毁掉
如果设置allowCoreThreadTimeOut = true，则会作用于核心线程

TimeUnit unit,

BlockingQueue workQueue,
该线程池中的任务队列：维护着等待执行的Runnable对象
当所有的核心线程都在干活时，新添加的任务会被添加到这个队列中等待处理，如果队列满了，则新建非核心线程执行任务
常用的workQueue类型：

  1. SynchronousQueue：这个队列接收到任务的时候，会直接提交给线程处理，而不保留它，如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误，使用这个类型队列的时候，maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大
  2. LinkedBlockingQueue：这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程(核心线程)处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致了maximumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize
  3. ArrayBlockingQueue：可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程(核心线程)执行任务，如果达到了，则入队等候，如果队列已满，则新建线程(非核心线程)执行任务，又如果总线程数到了maximumPoolSize，并且队列也满了，则发生错误
  4. DelayQueue：队列内元素必须实现Delayed接口，这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务

ThreadFactory threadFactory,

RejectedExecutionHandler handler
**这玩意儿就是抛出异常专用的，比如上面提到的两个错误发生了，就会由这个handler抛出异常，你不指定他也有个默认的
抛异常能抛出什么花样来？所以这个星期天不管了，一边去，根本用不上

Wait，yeild，stop，sleep、join、start、run的区别和如何使用？



**

接着上题：这四种有什么区别吗，你用过哪一种，可能存在什么问题吗？

**

接上题：拒绝策略有哪些呢？了解吗？聊聊？

**

接上题：你刚才说了队列，线程池中的队列有哪些？有界队列、无界队列、同步队列都有了解吗？聊聊？

**

如何实现一个消费者和生产者的循环消费和生产呢？（有两种方式，一种是通过锁，lock或者Synchronize，还有一个是通过ArrayBlockingQueue实现）

**

你可以实现线程之间的相互通信吗？如何实现？要不写一个？

线程安全的疯狂试探：

Synchronzie了解吗？谈谈你的理解

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：
1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

在一个普通方法上加synchronize和在一个静态方法上加synchronize有什么区别（对象锁和类锁的的区别）？

Synchronize和lock有什么区别呢？说说你对lock的理解？

**

Lock的公平和非公平锁？

**

说一说volitaile为什么保证不了原子性，可以保证可见性嘛？如何保证的（jvm的多线程的内存模型有关系）

**

了解CountDownLatch么，CyclicBarrier的区别呢？

**

Synchronize的实现原理知道吗？moniter的实现机制呢，为什么加了Synchronzie关键字，就可以在多线程下是安全的（这个回答要从java对象的Object头来回答）

**

类锁和对象锁的区别呢？字节码的体现呢？

**

Java中的自旋锁、偏向锁、读写锁、重锁等了解吗？

**

了解java重对象的对象头嘛？有哪些属性和字段呢？

**

Aqs(AbstractQueuedSynchronizer)了解吗？它和lock的关系？说说aqs中的核心思想?

**

Lock中存在锁升级嘛，他是可重入得嘛，那Synchronize是可重入得嘛，有没有锁升级的概念？

**

Volitaile了解吗？他的作用是什么呢，内存语义是什么呢？有没有了解过cpu的缓存一致性协议？

**

还知道其他的juc类嘛，有哪些呢（譬如lockSupport）？

jvm的疯狂试探：

a. 了解jvm么？jvm的内存模型？
b. Java如何判断一个对象是否还活着呢？
c.
Java的类加载了解吗？
d. Java类加载器了解吗，有哪些呢？那它的双亲委派了解吗？
e. Jvm指令你知道哪些（jps，jstack，jinfo，jmap……），都有什么作用呢？
f.
Java的垃圾回收算呢，了解吗,G1回收算法了解吗？
g.
Jvm参数你了解吗，知道多少说多少？
h.
在实战中有进行过jvm调优嘛，怎么做的，
i.
Java的对象年龄知道吗，有什么作用吗？
j.
Young GC和full GC了解吗，如何触发，如果在你的项目中，频繁出现young GC 怎么办？

设计模式的疯狂试探：

a. 你了解的设计模式有哪些？
b. 可以写一个单例模式嘛，工厂模式呢，抽象工厂模式解决了什么问题？
c.
策略模式、责任链模式、适配器模式写一个，写不出来的话，java中在哪用到了这些模式
d.
代理模式了解吗，会写吗，jdk代理和cglib代理的区别呢，说说你的理解？

数据结构与算法

1、 排序算法了解什么？能不能手写一个快速排序、或者归并排序，堆排序有了解吗？
冒泡排序
hasChange=true;
for(int i=0,ihasChange = false;
for(j=0 ;j if(nums[j]>nums[j+1]){
swrap(nums[j],nums[j+1])
hasChange = true
}

}
}

插入排序
public int[] charuSort(int[] nums) {
for (int i = 1, j, current; i < nums.length; i++) {
current = nums[i];
for (j = i - 1; j >= 0 && nums[j] > current; j—) {
nums[j + 1] = nums[j]; }
System.out.println(j);
nums[j + 1] = current;
}
System.out.println(Arrays.toString(nums)); return nums;}

快速排序


归并排序


堆排序

2、 给你一个一元二次方程公式，你写一个方法，用计算机语言实现它。


3、 图了解么，有向图呢？你可以实现一个有向图么？（假如他回答的是二维矩阵，可以反问他有没有更好的解决方案呢，因为这个图可能是个稀疏矩阵）

4、 接上题，在图中，如何判断两个节点的联通性，可以写代码写出来么？

5、 给你一个1T的Int文件，然后你只有一台内存是8G的机器，如何用最快的方法，求出里面出现频率最高的topN个数？

6、 算法的时间复杂度和空间复杂度了解吗？说说你了解的算法的时间复杂度和空间复杂度。

7、 二叉树了解吗，树的广度优先算法和宽度优先算法了解吗？写一个他的前序（中序、后序）遍历可以么（递归和非递归的方式都可以写出来么）？

8、 给你一个字符串，请检查中间出现的括号的正确性，譬如：（{[]}），（（（）））这都是个合法的字符串，（（）（））（（（）这就不是一个合法的字符串；

9、 给你一个单向链表，检测它有没有形成环？

10、 给你一个单向链表，如何反转，可不可以把空间复杂度降低到O(1)级别？

11、 写一个字符串匹配算法，判断在一个字符串中是否包含另外一个字符串（一般都会说循环去比较，这样的时间复杂度很高，有一个算法是KMP，面试者要是能提到KMP都就很不错了，因为很多面试官都不知道，也不会）？

12、 可以用两个栈模拟一个队列么？

13、
如何判断两棵树相不相等

14、
动态规划有了解吗？
a. 给你一个机器人，它每次只能向右或者向下走一步，其中，中间有一个障碍物，不可以经过，请问，在一个n*m的矩阵中，这个机器人总共有多少种走的方法？（答不出来就降低一下难度，把中间的那个障碍物去掉）

b. 青蛙跳知道吗？给你一个数组，里面的每一个数字代表青蛙可以前进的最大的步数，如何判断这个青蛙可不可以达到终点；譬如2，3，4，1就可以，1，2，1，0，1就不可以；

c.
爬楼梯，假设有一个n阶的楼梯，你每次都只能爬1或者2个台阶，请问有多少种不同的方法可以爬上去呢？

d. 给你一个整数数组，找到一个具有最大和的连续子数组（子数组至少包含一个元素），返回最大值

e.
给你一个容量为V的背包，现在有N件商品（有重复，相同的商品可以随意取），每件商品的体积是v1，价值是w1，请问，这个背包所能容纳的最大价值是多少？

f.
一个100层高的楼，有两颗鸡蛋，你需要用最少的次数找到那个临界点，这个临界点以上的楼层上摔下去，鸡蛋都会碎掉，以下的楼层，鸡蛋是不会碎的，（扩展，加入现在是N层高的楼房，你现在有m个鸡蛋，m>=1，用最少的次数找到那个临界点）**

数据库大汇总

1、 用过mysql嘛？了解吗？
2、 Mysql事务了解吗，隔离级别呢，每种隔离级别会出现什么问题？
3、 Mysql的锁了解吗（表锁、行锁、间隙锁，读写锁）？
4、 Mysql引擎知道吗，innodb和myisam的区别知道吗，说说底层的实现？
5、 聚簇索引和非聚簇索引知道么，有什么区别？
6、 B+树知道吗？为什么使用B+树？

7、 分库分表做过吗，如果让你去实现分库分表，你有什么需要考虑或者注意的嘛？
8、 了解死锁嘛？知道他是怎么产生的嘛，如何避免呢？

9、 Sql优化了解过吗？说说你的理解，给你一条sql，你会怎么优化？

框架

1、 redis大家庭：
a. redis是什么，能干嘛，怎么用？
b. Redis的基础数据类型有哪些？
c.
Reids除了这些，还有哪些数据结构，能解决什么问题？
d. Redis集群有搭建过么，说说你的实现
e. Redis如何实现分布式锁
f.
Redis的支持事务么？
g. 位图了解吗？
h.
布隆过滤器了解吗，他的原理是什么呢？
i.
Redis的通信协议你知道嘛？
j.
Redis中的数据结构底层了解吗？string的编码、list的编码、zset的编码；
k.
在集群环境下，Redis的分布式锁一定可靠吗，redis社区有没有提供可靠地分布式锁的集群方案（有，红锁）?
l.
Redis的持久化你知道么，说说rdb和aof的区别
m.
Aof瘦身知道么？如何瘦身
n.
Redis的拒绝策略你知道么？那它的淘汰策略你知道么
o.
Redis的哨兵模式呢，了解吗？
p.
Zookeeper了解吗，用zookeeper实现分布式锁，和redis实现有什么不同呢，说说他们的原理？

2、 Spring大家庭：
a. Autowire和Resource 的区别
b. 谈谈你对spring的理解，它干了什么？
c.
Spring的依赖注入和切面呢？
d. Spring的事务了解吗，他的传播机制呢
e. Spring的aop切面详细说说，你的应用场景呢？
f.
Springmvc用过吗？了解他的启动流程嘛？说说你的看法
g.
Spring中的bean的生命周期呢，了解吗？如何扩展一个bean的生命周期？
h.
Spring源码读过吗？有没有想过他是如何解析在xml中定义的bean的。
i.
在spring的配置文件中加入component-scan标签，它就可以自动加载所有添加相应注解的java类，这个是怎么做到的呢，你知道嘛？
j.
Dubbo了解吗？dubbo是怎么和spring想结合的？

3、 消息中间件大家庭：
a.
你了解消息中间件有哪些？
b.
谈谈你对topic和partition的理解？
c.
Kafka中的isr和osr有了解吗？
d.
Kafka的高水位你知道嘛？
e.
Kafka的分区器、拦截器、序列化器你了解吗？
f.
消息的可靠性怎么保证？
g.
消息丢失怎么办？kafka有什么保证策略？（我了解kafka，你们也可以问问其他的，譬如rocketMq）
h.
Kafka的事务你了解过吗（这个特别难，一般别问昂）？

4、 zookeeper大家庭：
a. 谈谈你对zookeeper的理解？
b. Zookeeper的节点类型你知道么？
c.
Zookeeper的心跳机制呢？
d. Zookeeper的优势在哪？
e. 知道zookeeper的watch嘛？
f.
Cap理论知道吗？
g.
Paxos算法呢，了解吗？

5、 springBoot大家庭：
a.
什么是spring boot？
b.
为什么要用spring boot呢？
c.
Spring boot 的核心配置文件有哪几个？他们的区别是什么？
d.
Spring boot 的配置文件有哪几种格式？区别？
e.
Spring boot的核心注解是那个？它主要由哪几个注解组成的？
f.
如何理解spring boot的配置加载顺序？


**

**