2018-06-27

一 基础篇

1.1 Java基础

• 面向对象的特征

  抽象:将一类对象的共同特征总结出来构建类的过程。
  继承:对已有类的一种复制。
  多态:不同子类型的对象对同一种消息做出不同的回应。
  封装:把数据和操作数据的方法绑定起来，对数据访问时只能通过定义的接口
  

• final、finally、finalize的区别

  final:修饰变量，被修饰的变量值不能改变
  finally:使用try捕获异常时候，一定会执行的代码块
  finalize:垃圾回收前,会调用finalize方法，释放对象持有的资源
  
  

• Exception、Error、运行时异常与一般异常有何异同

  Exception与Error都是throwable的子类
  Eroor：系统内部错误与资源耗尽错误，程序不抛出这种错误
  Exception又分为runtimeException与I/OException。程序本身错误时runtimeException,Io就属于其他异常。
  

• 请写出5种常见到的runtime exception,IOException

  1.NullPointerException (空指针异常)
  2.IndexOutBoundsException(下标越界异常)
  3.ArithmeticException(算数异常)
  4.SecurityException(安全异常)
  5.ArrayStoreException(数组存放类型异常)
  6.NumberFormatException(String转数字类型异常)
  
  1.FileNotFountException
  2.IOException
  3.EOFException
  

• int 和 Integer 有什么区别，Integer的值缓存范围

   int是基本数据类型，Integer是包装数据类型,包装数据类型是对象，可以使用静态方法。
   Integer的值缓存范围-128-127
  

• 包装类，拆箱和装箱

   拆箱和装箱的过程就是包装类型与基本数据类型相互转化的过程。
  

• String、StringBuilder、StringBuffer
  提供了两种类型的字符串String和StringBuilder/StringBuffer都可以存储和操作字符串。
  String 是只读字符串，StringBuilder是单线程下使用的，所以方面都没有被Synchronized修饰。效率更高。

• 重载和重写的区别

   都是实现多态：重载发生在同一个类下，相同的方法名，参数不同。而重写发生在子类与父类之间，方法名参数返回类型都相同。
   重载是编译时的多态性，而重写是运行时的多态性。
  

• 抽象类与接口的区别

   抽象类与接口都不能被实例化，一个类继承了某个抽象类或者实现了某个接口，都需要对他们的所有方法进行实现。抽象类可以定义构造器，有抽象方法、具体方法，所有接口更抽象。
   抽象类中的成员可以是public、private的，但是接口中成员全部都是public，接口中定义的成员变量其实是常量。
  

• 说说反射的用途及实现

• 自定义注解的实现

• get请求与post请求的区别

   get请求查询字符串在url上拼接着,post请求的是单独的。get请求能够被缓存，存放书签等
  

• Session与Cookie区别

   cookie存放在浏览器本地，session存放在服务器，浏览器可以禁止cookie,但是不能禁止session，
  

• 列出常用的jdk包

   1.java.lang 2.java.util 3.java.sql 4. java.math 5.java.nio  6.java.net
  

• MVC设计思想

• equals与==的区别

   ==：比较的是栈中存放的对象的内存地址，判断是否指向同一个对象。
   equals：Object.equals()实际调用的依然是 ==，只有其他地方进行重写String、Integer
  

• hashCode和equals方法的区别与联系

   hashCode计算出实例的hash码，并返回hash码，equals判断两个对象的地址是不是同一个。
   hashcode相同，equals不一定相同；equals相同，hashcode一定相同。
   hashMap中，hashcode定位到应该存放的位置，如果该位置已经存在元素了，再调用equals。
  

• 什么是Java序列化和反序列化，如何实现Java序列化？或者请解释Serializable 接口的作用。

   无论什么样的数据都是以二进制的形式在网络上传送的。把Java对象转化为字节码序列的过程就称为对象的序列化，把字节码转为Java对象就叫做反序列化。
   调用OutputStream的writeObject方法
  

• Object类中常见的方法，为什么wait notify会放在Object里边？

   wait本来就是暂停获取锁的对象
  

1.2、Java常见集合

• List 和 Set 区别

      list和set都是继承了Collection接口。
          list可以允许重复的对象，允许插入多个null元素，是一个有序容器，保留插入的顺序。常用的实现类有ArrayList LinkedList和Vector.arraylist提供了索引的随意访问，而linkedList对经常需要添加删除的场合更加合适。
          set不允许有重复的元素，无序容器，TreeSet通过Comparator或者Comparable维护排序。只允许一个null元素。set接口实现的类有HashSet,LinkedHashSet以及TreeSet.TreeSet还实现了Sorted接口，因此是一个根据compare()与compareTo()的定义进行排序的有序容器。
  

• Set和hashCode以及equals方法的联系

      HashSet通过hashCode与equals维护元素的唯一性。
  

• List 和 Map 区别

      list继承conllection，而map是接口，map以key-value的形式，value可能相同，但是key一定唯一，null-key唯一。
  

• Arraylist 与 LinkedList 区别

      ArrrayList实现了基于动态数组的数据结构，而LinkedList是基于链表的数据结构，并且是双向链表。
      对于随机访问get set,A>L，因为L需要移动指针。
      对于新增删除来说L>A，因为A要移动数据。
  

• ArrayList 与 Vector 区别

      Vector的方法都是同步的、线程安全的，而ArrayList不是，所以ArrayList的性能较好。
      当容量达到初始大小后，Vector会翻倍，而Arraylst会上涨0.5倍。更加节省空间
  

• HashMap 和 Hashtable 的区别

      都是基于哈希表的,HashMap继承的是map 而HashTable继承的是Dictionary。HashMap的初始容量是16,HashTable 11,填充因子0.75，2n 2n+1
  

• HashSet 和 HashMap 区别

      HashSet实现了set接口，不容许重复，存储对象是需要重写hashCode与equals方法。使用add添加元素，hashCode计算时利用成员对象
      HasgMap实现了map接口，key允许一个null。存储key value，使用put方法添加元素，使用key来计算hashcode
  

• HashMap 和 ConcurrentHashMap 的区别

      想要线程安全的HashMap可以通过Collections的静态方法SynchronizedMap来获得。CouncurrecnHashMap 分段锁，默认16个。
      使用put的时候，根据key的hash值得到在数组中的位置，然后放到位置中，如果已经有元素，那么将以链表的形式存放。新插入的在前面 1.8之后先插入的在后面。
  

• HashMap 的工作原理及代码实现，什么时候用到红黑树

      1.6 1.7采用的是位桶加链表的形式，1.8采用位桶加链表加红黑树。当链表的长度超过阀值（8）时采用红黑树，将减少查找的时间。
      根据key计算hash得到在位桶（数组）中的位置，元素放到后面列表。如果已有元素添加到后面。
  

• 多线程情况下HashMap死循环的问题

      rehash的时候链表结构发生变化，会发生闭合的回路。
  

• HashMap出现Hash DOS攻击的问题

• ConcurrentHashMap 的工作原理及代码实现，如何统计所有的元素个数

• 手写简单的HashMap

• 看过那些Java集合类的源码

1.3、进程和线程

• 线程和进程的概念、并行和并发的概念

   进程：是一个程序的实例，每个进程都有自己的虚拟地址空间和控制线程。
   线程：线程是操作系统调度器分配处理器的基础单元。
   并行：一个cpu同步处理多个进程。
   并发：一个cpu可以异步的处理多个进程。
  

• 创建线程的方式及实现

   Thread是实现了Runnable的。
   有三种,1.继承Thread  2.实现了runnable 3.使用callable和future创建线程。
  

• 进程间通信的方式 !!!!!!!!!!!

   线程之间通信方式：
       1.共享变量  --必须指向同一个共享实例的引用（synchronized）
       2.wait/notify机制
       3.Lock/Condition
       4.管道（缺点：只能两个线程之间，只能单向通信）
          创建管道输出流PipedOutputStream pos 与输入流PipedInputStream pis
          将pos与pis匹配,pos.connect(pis);
          pos赋给信息输入线程，pis赋给信息获取线程。
          
   进程之间的通信方式：
       1.管道
       2.命名管道
       3.信号
       4.消息队列
       5.共享内存
       6.内存映射
       7.信号量
       8.套接口
  

• 说说 CountDownLatch、CyclicBarrier 原理和区别

   CountDownLatch:一个线程等待其他多个线程完成。CountDownLatch有一个构造方法，两个常用的方法 await() --等待变为0和countdown() ---减一
   CyclicBarrier:所有线程到达某个状态，再一起执行    await()加一
  

• 说说 Semaphore 原理

   Semaphore：一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。 AQS控制
  

• 说说 Exchanger 原理

   两个工作线程之间的交换数据，等同时到达某一个状态 进行交换数据
  

• ThreadLocal 原理分析，ThreadLocal为什么会出现OOM，出现的深层次原理

   ThreadLocal:线程本地变量或线程本地存储。
   ThreadLocal在每个线程中会对该变量创建一个副本(资源消耗的问题)，先set再get，如果不set，可以重写initalValue方法
  

• 讲讲线程池的实现原理

   多线程技术主要解决处理器单元内多个线程执行的问题。可以显著的减少处理器单元的闲置时间。增加啊处理器单元的吞吐能力。T1+T3>>>T2
       1.线程池管理器(ThreadPool)：用于创建并管理线程池，包括创建线程，销毁线程，添加新任务
       2.工作线程(PoolWorker):线程池中线程，在没有任务时处于等待章台，可以循环的执行任务。
       3.任务接口(Task)：每个任务必须实现的接口，以供工作线程调度任务的执行，主要规定了任务的入口、任务执行完的收尾工作，任务的执行状态
       4.任务队列(taskQueue):用于存放没有处理的任务，一种缓冲机制。
   常见的线程池：Executors中的静态方法
       1.newSingleThreadExecutor  单个线程，串行执行
       2.newFixedThreadExecutor(n)    固定数量的线城市
       3.newCacheThreadExecutor    可缓存线程池,当线程池大小超过了处理任务所需的线程，就会回收线程，有新任务来时，添加新的线程来执行
       4.newScheduleThreadExecutor 大小无限制的线程池，支持定时和周期性的执行线程
       
       newWorkStealingPool 多个队列的线程池 减少连接数
   重要的类：
       ExecutorService  --真正的线程池接口
       ScheduledExecutorService  --和Timer/TimerTask类似，解决需要重复执行的问题
       ThredPoolExecutor   --ExecutorService的默认实现
       ScheduledThredPoolExecutor  --继承ScheduledExecutorService接口时间，周期性任务调度的类实现
   queue有三种类型，即排毒有三种通用策略：
       直接提交：工作队列默认是SynchronousQueue。当命令超过队列所能处理的平均数连续到达数，此策略允许无界线程具有增长的可能性。使用这种策略，要求maxnumPoolSize是无界的，可以保证A2一定在A1后执行。
       无界队列：不具有预定义容量的LinkedBlockingQueue，corePoolSize线程都忙时新任务在队列中等待，当超过corePoolSize，新任务始终添加到队列中
       有界队列：ArrayBlockingQueue. 拒绝策略，够了就不添加到队列中去了
   可选择的饱和策略RejectExceptionHandler
       1.AbortPolicy   中止策略，饱和时会抛出RejectedExcutionException
       2.discardPolicy   抛弃策略，不做任何处理 直接抛弃
       3.discardOldestPolicy  抛弃旧任务策略  优先级队列，会抛弃优先级较高的，不建议
       4.CallerRunsPolicy  调用者运行，调用调用者的主线程来执行任务。所以主线程无法再提交新任务。
   
   
   线程池最核心的一个类  java.util.concurrent.ThreadPoolExcutor类
   Executor是一个顶层接口，在它里面只声明了一个方法execute(Runnable)，返回值为void，参数为Runnable类型，从字面意思可以理解，就是用来执行传进去的任务的；
   
   然后ExecutorService接口继承了Executor接口，并声明了一些方法：submit、invokeAll、invokeAny以及shutDown等；
   
   抽象类AbstractExecutorService实现了ExecutorService接口，基本实现了ExecutorService中声明的所有方法；
   
   然后ThreadPoolExecutor继承了类AbstractExecutorService。
   
   在ThreadPoolExecutor类中有几个非常重要的方法：
       execute()
       submit()
       shutdown()
       shutdownNow()
   execute()方法实际上是Executor中声明的方法，在ThreadPoolExecutor进行了具体的实现，这个方法是ThreadPoolExecutor的核心方法，通过这个方法可以向线程池提交一个任务，交由线程池去执行。
   submit()方法是在ExecutorService中声明的方法，在AbstractExecutorService就已经有了具体的实现，在ThreadPoolExecutor中并没有对其进行重写，这个方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果，去看submit()方法的实现，会发现它实际上还是调用的execute()方法，只不过它利用了Future来获取任务执行结果（Future相关内容将在下一篇讲述）。
  

• 线程池的几种实现方式

• 线程的生命周期，状态是如何转移的

   （1）New：创建线程对象后，该线程处于新建状态，此时它不能运行，和其他Java对象一样，仅仅有Java虚拟机为其分配了内存，没有表现出任何线程的动态特征； 
   （2）Runnable：线程对象调用了start（）方法后，该线程就进入了就绪状态（也称可运行状态）。处于就绪状态的线程位于可运行池中，此时它只是具备了运行的条件，能否获得CPU的使用权开始运行，还需要等待系统的调度； 
   （3）Runing：处于就绪状态的线程获得了CPU使用权，开始执行run（）方法中的线程执行体，则线程处于运行状态。当一个线程启动后，它不能一直处于运行状态（除非它的线程执行体足够短，瞬间结束），当使用完系统分配的时间后，系统就会剥脱该线程占用的CPU资源，让其他线程获得执行的机会。只有处于就绪状态的线程才可能转换到运行状态。 
   （4）Blocked：一个正在执行的线程在某些特殊情况下，如执行耗时的输入/输出操作时，会放弃CPU的使用权，进入阻塞状态。线程进入阻塞状态后，就不能进入排队队列。只有当引用阻塞的原因，被消除后，线程才可以进入就绪状态。 
       ——当线程试图获取某个对象的同步锁时，如果该锁被其他线程所持有，则当前线程进入阻塞状态，如果想从阻塞状态进入就绪状态必须得获取到其他线程所持有的锁。 
       ——当线程调用了一个阻塞式的IO方法时，该线程就会进入阻塞状态，如果想进入就绪状态就必须要等到这个阻塞的IO方法返回。 
       ——当线程调用了某个对象的wait（）方法时，也会使线程进入阻塞状态，notify（）方法唤醒。 
       ——调用了Thread的sleep（long millis）。线程睡眠时间到了会自动进入阻塞状态。 
       ——一个线程调用了另一个线程的join（）方法时，当前线程进入阻塞状态。等新加入的线程运行结束后会结束阻塞状态，进入就绪状态。 
       线程从阻塞状态只能进入就绪状态，而不能直接进入运行状态，即结束阻塞的线程需要重新进入可运行池中，等待系统的调度。 
   （5）Terminated：线程的run（）方法正常执行完毕或者线程抛出一个未捕获的异常（Exception）、错误（Error），线程就进入死亡状态。一旦进入死亡状态，线程将不再拥有运行的资格，也不能转换为其他状态。
  

• 可参考：《Java多线程编程核心技术》

1.4、锁机制

• 说说线程安全问题，什么是线程安全，如何保证线程安全

  线程安全：多个线程同时运行，每次结果与单线程的结果一样，变量也与预期一样。线程安全问题都是由全局变量以及静态变量引起的
  1.保证原子性：锁和同步  lock（）  synchronized  CAS AtomicInteger
  2.保证可见性：volatile
  happens-before原则（先行发生原则）
  

• 重入锁的概念，重入锁为什么可以防止死锁

  重入锁：同一个线程再次进入同步代码块的时候，使用自己已获取的锁
  synchronized 和   ReentrantLock 都是可重入锁
  

• 产生死锁的四个条件（互斥、请求与保持、不可剥夺、循环等待）

• 如何检查死锁（通过jConsole检查死锁）

• volatile 实现原理（禁止指令重排、刷新内存）

  volatile保证可见性的原理是在每次访问变量时都会进行一次刷新，因此每次访问都是主内存中最新的版本。所以volatile关键字的作用之一就是保证变量修改的实时可见性。
  还有另一个重要的作用：在JDK1.5之后，可以使用volatile变量禁止指令重排序。
  

• synchronized 实现原理（对象监视器）

  Java对象头和monitor是实现synchronized的基础
  

• synchronized 与 lock 的区别

  1.首先synchronized是java内置关键字，在jvm层面，Lock是个java类；
  
  2.synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；
  
  3.synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；
  
  4.用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；
  
  5.synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）
  
  6.Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。
  

• synchronized 与 ReentrantLock的区别

  由于ReentrantLock是java.util.concurrent包下提供的一套互斥锁，相比Synchronized，ReentrantLock类提供了一些高级功能，主要有以下3项：
  
          1.等待可中断，持有锁的线程长期不释放的时候，正在等待的线程可以选择放弃等待，这相当于Synchronized来说可以避免出现死锁的情况。
  
          2.公平锁，多个线程等待同一个锁时，必须按照申请锁的时间顺序获得锁，Synchronized锁非公平锁，ReentrantLock默认的构造函数是创建的非公平锁，可以通过参数true设为公平锁，但公平锁表现的性能不是很好。
  
          3.锁绑定多个条件，一个ReentrantLock对象可以同时绑定对个对象。
  

• AQS同步队列

• CAS无锁的概念、乐观锁和悲观锁

• 常见的原子操作类

• 什么是ABA问题，出现ABA问题JDK是如何解决的

• 乐观锁的业务场景及实现方式

• Java 8并法包下常见的并发类

• 偏向锁、轻量级锁、重量级锁、自旋锁的概念

1.5、JVM

• JVM运行时内存区域划分

     内存区划分为：堆、Java栈、本地方法栈、程序计数器、方法区
     所有线程共享的区域：堆、方法区
     程序计数器：记录执行的指令的地址（native方法）
     Java栈：存放的是一个个的栈帧，对应的调用方法，在栈帧中包括局部变量表、操作数栈、当前方法所属类的常量尺码的引用，方法返回地址。！！当线程执行一个方法时，就会创建一个对应的栈帧，并压栈，方法执行完毕后就会出栈。
     本地方法栈：是执行本地方法服务的
     堆：用来存储对象本身以及数组（数组引用存放在Java栈中）
     方法区：存储了每个类的信息(类的名称、方法信息、字段信息)、静态变量、常量和编译后的代码
  

• 内存溢出OOM和堆栈溢出SOE的示例及原因、如何排查与解决

     OOM:过多的静态变量、大量递归、大量循环、sql查询超过十万条，集合中存放对象的引用而不是对象、非字面量字符串+操作
     栈溢出：递归调用、大量循环、全局变量过多、数组 list map数据是否过大，DDMS工具
  

• 如何判断对象是否可以回收或存活

     引用计数法：引用加1，引用失效减1  但无法解决对象之间的循环引用的问题 
     可达性分析：通过一系列被称为"GC ROOTS"的对象作为起始点，搜索所走过的路径称为引用链。当没有引用链的时候，就认为不可达 可以被回收。
  

• 常见的GC回收算法及其含义

     1.引用计数法：
     2.标记-清除法：
     3.copy:
     4.标记-整理
     5.分区：对于栈来说
  

• 常见的JVM性能监控和故障处理工具类：jps、jstat、jmap、jinfo、jconsole等

• JVM如何设置参数--tomcat的配置文件中

• JVM性能调优

• 类加载器、双亲委派模型、一个类的生命周期、类是如何加载到JVM中的

     .java文件通过编译器（javac）编译成为.class的二进制文件，通过类加载器加载到内存中。
     类的生命周期：加载、验证、准备、解析、初始化、使用、卸载。
     加载：通过类的全限定名来获取定义此类的二进制字节流，将字节流代表的静态存储结构转化为区域运行时的数据结构。在Java堆中生成一个代表这个类的java.lang.class对象，作为方法区数据的访问入口。
     验证：分为四个阶段文件格式、元数据、字节码、符号引用
     解析：是将常量池的符号引用转化为直接引用，四种类型的引用解析：类或接口的解析、字段解析、方法解析、接口方法解析
     初始化：根据程序员制定的计划去初始化。包括static{} 构造函数、父类初始化等。
     
     双亲委派模型：机制：类加载器(bootstrap)-->标准扩展(Extension)类加载器-->系统加载器-->上下文加载器。从上到下加载，先将加载任务委托给父类加载器、依次递归，如果父类成功完成，就返回成功、无法完成时才去自己加载。
  

• 类加载的过程：加载、验证、准备、解析、初始化

• 强引用、软引用、弱引用、虚引用

     强引用：只要引用存在，永远不会被回收
     软引用：非必须引用，内存溢出之前回收，类似缓存
     弱引用：第二次垃圾回收时回收 监控被垃圾回收器标记为即将被回收的垃圾
     虚引用：垃圾回收时回收，无法通过引用取到对象值。检测是否从内存中删除
  

• Java内存模型JMM

     JMM的主要目标是定义程序中各个变量的访问规则，虚拟机中将变量存储到内存和从内存中取出变量的细节。
  

1.6、设计模式

• 常见的设计模式

      1.单例模式
      2.工厂模式
      3.建造者模式
      4.门面模式
      5.策略模式
  

• 设计模式的的六大原则及其含义

      1.开闭原则（抽象类和接口）：对扩展开放，对修改关闭
      2.里氏代换原侧（使用抽象类继承）：基类可以被子类替换
      3.依赖倒转原则（针对接口编程）：要依赖抽象
      4.接口隔离（建立最小接口）：多接口更好
      5.迪米特法则：尽量减少与其他实体相互作用
      6.合成复用法则：减少继承
  

• 常见的单例模式以及各种实现方式的优缺点，哪一种最好，手写常见的单利模式

      饿汉：定义静态，如果实例没有被引用，会造成资源浪费。
      懒汉：synchronized 并发效率低。
  

• 设计模式在实际场景中的应用

• Spring中用到了哪些设计模式

• MyBatis中用到了哪些设计模式

• 你项目中有使用哪些设计模式

• 说说常用开源框架中设计模式使用分析

• 动态代理很重要InvocationHandler

  手写代理模式：1.先写接口，定义接口内方法  2.写主人类，实现接口内的方法。 3.写代理类，实现InvocationHandler
      利用到了反射
  

1.7、数据结构

• 树（二叉查找树、平衡二叉树、红黑树、B树、B+树

• 深度有限算法、广度优先算法

• 克鲁斯卡尔算法、普林母算法、迪克拉斯算法

• 什么是一致性Hash及其原理、Hash环问题

• 常见的排序算法和查找算法：快排、折半查找、堆排序等

2.1、数据库

• MySQL 索引使用的注意事项

   索引的目的在于提高查询效率。索引的类型：1.index 2.unique 3.primary key 4.fulltext 5.组合索引
   创建索引：1.ALTER TABLE table_name ADD INDEX index_name (col_name1,col_name2)
            2. CREATE INDEX index_name ON table_name(col_name)
   删除索引：1.DROP INDEX index_name ON table_name;
            2.ALTER TABLE table_name DROP PRIMART KEY;
   注意事项：EXPLAIN可以帮助开发人员分析sql的问题。
           1.索引在提高查询毒素的同时，也降低了更新表的速度，不仅要保存数据，还需要保存索引文件
           2.建立索引会占用磁盘空间的索引文件
  

• DDL、DML、DCL分别指什么

   DML:有select、update、insert、delete 对数据库的数据进行操作的数据
   DDL:有create、alter、drop 主要是定义或改变表结构，表建立时使用
   DCL:数据库控制功能，用来设置数据库用户或角色权限的语句
  

• explain命令

• left join，right join，inner join

• 数据库事物ACID（原子性、一致性、隔离性、持久性）

   操作序列要么都执行要么都不执行。
   原子性：事务是一个不可分割的工作单位、要么都执行要么都不执行。
   一致性：开始与结束后，数据库的完整性没有被破坏。解决办法，约束
  

• 事物的隔离级别（读未提交、读以提交、可重复读、可序列化读）

   读未提交:
   读以提交:等到提交完在读取数据。
   可重复读:执行事务的时候不允许其他事务进入
   可序列化读:Serializable 是最高的事务隔离级别，在该级别下，事务串行化顺序执行，可以避免脏读、不可重复读与幻读。但是这种事务隔离级别效率低下，比较耗数据库性能，一般不使用。
  

• 脏读、幻读、不可重复读

   脏读：读取到还未确认的数据   ===>事务提交前，对其他事务不可读取其修改的值。
   幻读：对同一行数据做出修改，更新丢失  ===>对行加锁，只允许并发一个更新事务。
   不可重复读：多次读取不一致  ====> 只有当修改事务完全提交后才可以读取数据。
   幻象读：读取后新增操作  ===>在操作完成数据处理之前，任何事务都不可以在添加新数据。
  

• 数据库的几大范式（三大范式）

   1NF: 原子性，列不应该再分为几列（电话|家庭电话/手机）
   2NF: 1.必须有主键2.完全依赖于主键 数据冗余的问题
   3NF: 不能传递依赖，反作用依赖，非主键依赖于主键
  

• 数据库常见的命令

--- 数据库的扩展:业务拆分、主从复制、数据库的分库分表

• 说说分库与分表设计

       单表的记录行数过大：采用Master-Slave复制模式的mysql架构。写操作集中在Master,并且挂在的Slave受到master能力和负载的限制。
       拆表可以用取余的办法，表的数量一般是2的N次方，分表一般解决单表数量过大带来的查询效率问题。无法解决并发问题，所以还得分库。
       
       分库分表的策略：1.中间变量=user_id%(库容量*每个库中表的数量)；
                     2.库序号=取整（中间变量/每个库中表的数量）
                     3.表序号=中间变量%每个库中表的数量
       先计算出中间变量，库序号取整、表序号取模，都是针对单个库中表的数量。
  

• 分库与分表带来的分布式困境与应对之策（如何解决分布式下的分库分表，全局表？）

       1.数据迁移与扩容问题 2.表关联的问题 3.分页与排序的问题 4.分布式事务的问题 5.分布式全局唯一ID
       跨库Join的几种解决办法：
       1.全局表：将这类表在其他每个数据库均保存一份
       2.字段冗余：反范式，把需要的字段加到列中。
       3.数据同步，关联的库同步了
       4.数据组装
  

• 说说 SQL 优化之道

       1.explain 查询  十万条数据分水岭
       2.创建正确的索引
       3.不使用默认配置
           > 1 innodb_buffer_pool_size
           > 2 innodb_log_file_size  单个innodb日志文件大小
           > 3 最大连接数
       4 数据库转入到内存中
       5 固态硬盘
  

• MySQL遇到的死锁问题、如何排查与解决

       死锁成因：两个事务相互等待 innodb_lock_wait_timeout
       wait-for graph:是否形成环形有向图、
       1.2 innodb隔离级别、索引与锁
           索引与锁的关系：无索引查询是全表扫描，二级索引会先锁住二级索引，接着会锁住相对应的主键对应的记录 3.一级索引会直接锁住那一行
           
           隔离级别：
               1.未提交读：
               2.提交读：
               3.重复读：
               4.可串行读：
       定位死锁：根据日志找到相应事务对应的sql，确定数据库的隔离级别，innodb的级别是RC,排除gar锁。
                查看死锁的日志：show innodb status
  

• 存储引擎的 InnoDB与MyISAM区别，优缺点，使用场景
  myISAM：不支持事务处理、外键和行级锁。执行大量的select

• 索引类别（B+树索引、全文索引、哈希索引）、索引的原理

       常用的索引类型：主键索引、唯一索引、全文索引、普通索引和组合索引
       常用的索引结构：b+树索引、哈希索引
           索引的原理：
  

• 什么是自适应哈希索引（AHI）

       InnoDB存储引擎会监控表上各索引页的查询。检测到如果检测到建立哈希索引带来更高的速度，就建立哈希索引，称之为自适应哈希索引。
  

• 为什么要用 B+tree作为MySQL索引的数据结构

       1.文件很大，不可能全部存储在内存中，所以存储到磁盘里
       2.索引的结构组织要尽量减少查到磁盘中I/O的存取次数
       3.红黑树 比较深
  

• 聚集索引与非聚集索引的区别

• 遇到过索引失效的情况没，什么时候可能会出现，如何解决

       1.or语句
       2.like 以%开头的
       3.多列索引，不是使用的第一部分
       4.列类型是字符串，需要在条件中用引号引用起来
  

• limit 20000 加载很慢怎么解决

       1.order by 加索引
       2.反向查找  超过一般，偏移逆转
  

• 如何选择合适的分布式主键方案

       1.UUID  2.自然主键
  

• 选择合适的数据存储方案

• 常见的几种分布式ID的设计方案

       1.Twitter的snowflake算法  2.利用zookeeper生成唯一ID  3.利用redis生成唯一ID
  

• 常见的数据库优化方案，在你的项目中数据库如何进行优化的

       1.选择最有效率的表名顺序（笔试常考） 从右到左顺序处理
       2.WHERE子句中的连接顺序
       3.SELECT子句中避免使用*号
       4.删除全表，利用Truncate
       5.尽量多使用COMMIT
       6.用WHERE子句替换HAVING子句
       7.多使用内部函数提高SQL效率
       8.使用别名
  

2.2、Redis

• Redis 有哪些数据类型，可参考《Redis常见的5种不同的数据类型详解》

       string(最大可以512M，文件图片都可以)、list、set、hash（key-value）、zset(不同的是每个元素都会关联一个double类型的分数)
  

• Redis 内部结构

• Redis 使用场景

       1.为什么使用
           解决应用服务器的cpu与内存压力
           减少IO操作，减轻IO压力
           关系型数据库扩展性不强，难以改变表结构
       2.优点
           nosql数据库没有关联关系，数据结构简单
           读取速度快，对较大数据处理快
       3.适用场景
           数据高并发的读写
           海量数据的读写
           扩展性能高的数据
       4.不适用的场景
           需要事物支持
           关系复杂，需要sql结构化查询存储的。
           
       5使用场景
           1.配合关系型数据库做高速缓存
               缓存高频访问的数据，降低数据库io
               分布式架构，做session缓存
           2.可以持久化特定数据
               利用zset类型可以存储排行榜
               利用list的自然时间排序存储n个最新数据
       redis基础知识：端口6379 默认16个数据库，下标从0开始，
           redis:单线程+io多路复用：检查文件描述的就绪状态
           memchached:多线程+锁
  

• Redis 持久化机制，可参考《使用快照和AOF将Redis数据持久化到硬盘中》

       redis提供了两种不同方式的持久化：1.快照（RDB） 2.只追加文件(AOF)
       一、创建快照的方式
           （1）客户端向redis发送BGSAVE命令  save 60 1000(当60秒内有1000次写入操作时)
           （2）客户端向redis发送SAVE命令，会阻断其他命令，shutdown前调用
           注意：可以考虑关闭自动快照，选择适当的时间通过命令保存
       二、AOF持久化（将被执行的写命令写道AOF文件的末尾）
            appendonly yes:打开AOF
            appendfsync everysec(每秒执行一次)/always(每个命令都执行，会降低redis的速度)/no(系统决定)
       三、重写/压缩AOF文件
            BGREWRITEAOF  与BGSAVE一样会创建子线程
               自动压缩文件条件：auto-aof-rewrite-percentage  auto-aof-rewrite-min-size 
  

• Redis 集群方案与实现

       Redis Cluster,阿里云redis
  

• Redis 为什么是单线程的？

       对于redis来说，cpu不是瓶颈，而是来自机器内存或者网络带宽
  

• 缓存雪崩、缓存穿透、缓存预热、缓存更新、缓存降级

       缓存雪崩：原有缓存时效，新缓存未到，大量请求到了数据库  （加锁排队，请求量不大的时候）（设置过期标志更新缓存）（为key设置不同的缓存失效时间）
       缓存穿透：缓存没有、数据库也没有，两次无用查询 （bitmap:布隆过滤器）（对空结果进行缓存）
       缓存预热：系统上线后，提前把相关的缓存数据加载到缓存系统中
       缓存更新：定时清理  或者等用户请求
       缓存降级：一般、警告、严重、严重错误
  

• 使用缓存的合理性问题

• Redis常见的回收策略（6）
  根据过期时间：
  1.volatile-lru:淘汰最少使用的
  2.volatile-ttl:淘汰即将要过期的
  3.volatile-random:任意淘汰
  从数据集
  4.allkeys-lru:数据集中最少使用的
  5.allkeys-random:数据集中任意淘汰

           6.no-envication:禁止驱逐
  

2.3、消息队列

• 消息队列的使用场景

       主要解决：应用耦合、异步消息、流量削峰、日志等问题
       使用场景：异步处理，应用解耦，流量削锋和消息通讯四个场景。
  

• 消息的重发补偿解决思路

       处理失败：onMessageListener的onMessage方法抛出RuntimeException Message头里有两个相关字段：Redelivered默认false RedeliveryCounter默认0
       消息先由broker发送给consumer,consumer调用listener,如果处理失败，本地redeliveryCounter++,给broker一个特定的应答，broker端的message里redeliveryCount++,延迟一点时间继续调用，默认1s。超过六次，给Broker另一个特定应答，broker直接发送消息到DLD
       如果失败2次，consumer重启，redeliveryCount=2 本地再重试四次进入DLQ
  

• 消息的幂等性解决思路

       上半场幂等：MQ-client没有收到消息回执，再次发送===> 对每条消息，MQ系统内部必须生成一个inner-msg-id,作为去重与幂等的依据， 1.全局唯一2.MQ生成，与业务无关
       
       下半场幂等：MQ-server没有拿到ack,服务端超时后重发消息。===》保证业务幂等，业务消息体中必须由一个biz-id，1.对于同一个业务场景，全局唯一2.由业务消息发送方生成，业务相关，对mq透明。3.判重也是由业务消息方判断。
  

• 消息的堆积解决思路

       消息发送的效率远远大于消费的效率。默认情况下rabbitmq消费者为单线程串行消费。可以通过设置并发消费提高消费的效率。
       concurrentConsumers：设置并发消费者的个数
       prefetchCount:每次一次性从broker里面取得待消费的个数
  

• 自己如何实现消息队列

• 如何保证消息的有序性

   调用一个master的consumer，其他slave消费，利用zookeeper进行选主。
   脑裂问题：zookeeper可以用来选主，但不能保证某一时间内只有一个主。exclusive consumer。全部消息会发给这个consumer，如果这个挂了，会自动选择另外一个
  

三、开源框架和容器

3.1、SSM/Servlet

• Servlet的生命周期

  生命周期：加载--->实例化--->服务--->销毁
   init():只会执行一次init,在服务器装入servlet时进行，负责初始化servlet对象
   service():是servlet的核心，负责响应客户的请求 ServletRequest  ServletResponse
   destroy():仅执行一次，服务端停止且卸载Servlet时执行该方法。
  

• 转发与重定向的区别

  1.转发是服务器行为，重定向是客户端行为，
  2.重定向是两次request，传输的信息会丢失  
  

• BeanFactory 和 ApplicationContext 有什么区别

   BeanFactory是比较原始的Factory,无法支持spring的很多插件，例如AOP功能，web应用。
   ApplictionContext是由BeanFactory派生而来，以一种更面向框架的方式工作以及对上下文分层，实现继承。
   ApplictionContext还提供以下功能：
       * MessageSource,提供国际化的消息访问（i18n）
       * 资源访问，url和文件
       * 事件传播
       * 载入多个上下文，使每一个上下文都专注于一个特定的层次。
   1.利用MessagSource进行国际化(i18n) 2.强大的事件机制（Event）3.底层资源的访问（ResourceLoader）4.对web应用的支持
           其他：BeanFactory是延迟加载的，这样不能及时发现问题 手动注册，而ApplicationContext在容器启动时，一次性创建所有的Bean 自动注册
  

• Spring Bean 的生命周期
  -----beanFactory----
  * Bean的建立，由BeanFactory读取bean的定义文件，生成各个实例。
  * Setter注入，执行Bean的属性依赖注入
  -----beanFactory----

   * 实例化一个Bean  new
   * 按照spring上下文对实例化的Bean进行配置，也就是IOC注入。
   * BeanNameAware的setBeanName(),如果实现该接口，则执行setBeanName方法。
   * BeanFactoryAware的setBeanFactory(),如果实现该接口，则执行setBeanFactory方法。
   
   -----ApplicationContext----
   * ApplicationContextAware接口，则执行其setApplicationContext()方法
   -----ApplicationContext----
   
   * BeanPostProcessor的processBeforeInitialization(),如果有关联的processor，则在初始化之前都会执行这个实例的processBeforeInitialization()方法。
   * InitializingBean的afterPropertiesSet(),实现了该接口，则执行其afterPropertieSet()方法。
   * Bean定义文件中定义init-method
   * BeanPostProcessors的processAfterInitialization()，如果有关联的processor，则在Bean初始化之前都会执行这个实例的processAfterInitialization()方法
   * DisposableBean的destory(),在容器关闭时，如果bean类实现了该接口，则会执行destroy()方法
   * Bean定义文件定义了destroy-method。在容器关闭时，可以在Bean定义文件中使用"destroy-method"定义的方法。
  

• Spring IOC 如何实现

   IOC是一种思想，而DI(依赖注入)是实现IoC的一种方法：将对象的创建转移给第三方。
       实现方式：1.xml  2.注解
       注入方式：1.构造方法注入  2.setter注入   3.接口注入
  

• Spring中Bean的作用域，默认的是哪一个

   spring中注入的bean默认是配置为单例模式,四种作用域： ConfigurableBeanFactory.SCOPE_xxx
       1.singleton：单例 singleton 整个应用只创建一个实例 
       2.prototype： 原型 prototype 每次注入时都创建一个实例
       3.session： 会话 session 为每次会话创建一个
       4. request：请求 request 为每个请求创建一个实例
       5.globalsession：：每个全局的HTTP Session，使用session定义的Bean都将产生一个新实例。典型情况下，仅在使用portlet context的时候有效。同样只有在Web应用中使用Spring时，该作用域才有效
   单例对象需要注入请求对象，请求对象并没有被创建，此时会先注入一个代理对象，当这个对象被使用时，则会委托给真正的bean去完成。
       <bean id="xxx" class=""xx.xxx.xxx" scope="session">
           <aop:scoped-proxy/>
       </bean>
       <aop:scoped-proxy/>
       
       @Scope(value=WebApplicationContext.SCOPE_SESSION,proxyMode=ScopeProxyMode.INTERFACES)
  

• 说说 Spring AOP、Spring AOP 实现原理

   面向切面编程，aop分为静态代理（AspectJ 编译时增强 在编译阶段将代码织入）与动态代理(Spring AOP)
   Spring AOP的动态方式有两种，JDK动态代理与CGLIB动态代理，JDK动态代理通过反射来接收InvocationHandler与Proxy。如果类被final标记，则无法使用CGLIB做动态代理
  

• 动态代理（CGLib 与 JDK）、优缺点、性能对比、如何选择

   使用JDK动态代理，目标类必须实现某个接口，如果没有实现接口则无法生成代理对象。
   
   CGLIB的原理是针对目标类生成一个子类，覆盖其中的方法，所以目标修不能被声明为final类型。
   
   从执行效率上看CgLib动态代理效率更高。
  

• Spring 事务实现方式、事务的传播机制、默认的事务类别

   事物的配置有五种方式，spring中配置文件中关于事物的配置有三个部分组成。分别是DataSource、TransactionManager和代理机制三个部分，变化的只是代理机制这部分。
   
   Spring配置文件=====>实现方式:
       方式一：通过事务代理工厂bean进行配置 xml方式
           1.引入一系列的约束头文件与标签
           2.配置C3P0数据源，以及dao、service
           3.配置事物管理器以及事物代理工厂bean.，测试类getBean获取代理工厂id
           
       方式二：注解
           <tx:annotation-driven transaction-manager-"mytx"/>
           
           @Transactional(rollbackFor=StockExption.class)
           
       方式三：Aspecth AOP配置事物
           <tx:advice id="txAdvice" transaction-manager="mytx">
               <tx:attributes>
                   <tx:method name="add* islation="DEFAULT" ..../>
               </tx:attributes>
           </tx:advice>
           <aop:config>
           </aop:config>
           
   事物的传播机制：多个事物同时存在时，srping应该如何处理这些事物的行为（七个）
    (默认)PROPAGATION_REQUIRED:支持当前事物，如果当前没有事物，就创建一个事物，默认的事物的传播
       PROPAGATION_REQUIRED_NEW:新建事物，如果当前事物存在，就将当前事物挂起，是两个独立的事物，外层事物失败回滚，不能回滚内层事物执行的结果，内存事物失败抛出异常，外层捕获异常，也可以不回滚。
       PROPAGATION_SUPPORTS:支持当前事物，如果当前没有事物，就以非事物的方式执行。
       PROPAGATION_MANDATORY:支持当前事物，如果没有则抛出异常
       PROPAGATION_NOT_SUPPORTS:以非事物方式执行操作，如果当前存在事物，就把当前事物挂起。
       PROPAGATION_NEVER:以非事物方式执行，如果当前存在事物，则抛出异常
       PROPAGATION_NEWTES:如果一个活动的事物存在就，就运行在一个嵌套的事物中，如果没有事物，就按照默认模式执行.
   
    七大事物传播行为的使用：
         充值行为
           不论扣款和创建订单只要有一个异常，不允许提交直接混滚：PROPAGATION_MANDATORY
           不管充值是否成功，必须记录日志：PROPAGATION_REQUIRES_NEW
           业务完成后需要统计，统计耗时长不适合事物：PROPAGATION_NEVER
           
         办理银行卡,等级成功与否不影响卡片的创建：新增卡片的行为回滚，登记就没意义了，也需要回滚，但是登记的回滚不影响新增卡片的行为。所以保存银行卡的事物传播行为可以设置为PARPAGATION_REQUIRED,PARPAGATION_MANDATORY.
    Spring中的隔离级别:
         ISOLATION_DEFAULT:使用数据库默认的事物隔离级别
         ISOLATION_READ_UNCOMMITTED:
         ISOLATION_READ_COMMITTED:
         ISOLATION_REPEATABLE_READ:
         ISOLATION_SERIALIZABLE:
  

• Spring 事务底层原理

   Spring的事务管理是基于TransactionManager
  

• Spring事务失效（事务嵌套），JDK动态代理给Spring事务埋下的坑，可参考《JDK动态代理给Spring事务埋下的坑！》

• 如何自定义注解实现功能

   元注解有四个：@Document @Targrt @Retention @Inherited
  

• Spring MVC 运行流程

   1.DispatchServlet前端控制器接收发过来的请求，交给handleMapping处理映射器。
   2.HandleMapping处理映射器，根据请求路径找到相对于的HandlerAdapter处理适配器（拦截器或者）controller
   3.HandleAdapter处理器适配器，处理一些功能请求，返回一个ModelAndView
   4.ViewResolver视图解析器，根据modelAndView中的设置View解析具体视图，
   5.将Model模型中的数据渲染到View上。
  

• Spring MVC 启动流程 需要看的

   SpringMVC启动过程一局两个配置大致分为两个过程
       1.ContextLoaderListener初始化，实例化IoC容器，并将此容器实例注册到ServletContent中
       2.DispatcherServlet初始化，建立上下文，也注册到ServletContext.
  

• Spring 的单例实现原理

   懒汉、饿汉、静态内部类、枚举，这些单例模式的构造方法都是私有的，不可继承，spring为实现单例类可继承，使用的是单例注册表。
       1、使用map实现注册表  2.使用protected修饰构造方法
  

• Spring 框架中用到了哪些设计模式

   1.代理模式——在AOP和remoting中被使用的比较多，同样用到反射
   2.单例模式——单例注册表，在配置文件中定义的bean默认为单例模式
   3.模板方法——用来解决代码重复的问题，比如RestTemplate JmsTemplate
   4.工厂方法——BeanFactory用来创建对象的实例。
   5.适配器——spring aop
   6.装饰器——spring data hashmapper
   7.观察者——spring 时间驱动模型，applicationListener
   8.回调—— spring ResourceLoadAware回调接口
   9.策略模式
  

• Spring 其他产品（Srping Boot、Spring Cloud、Spring Secuirity、Spring Data、Spring AMQP 等）

   1.Srping Boot：
   2.Spring Cloud：
   3.Spring Secuirity：
   4.Spring Data：
   5.Spring AMQP：
  

• 有没有用到Spring Boot，Spring Boot的认识、原理

   自动配置
  

• MyBatis的原理

   mybatis是什么：
       mybatis是一个优秀的持久层框架，对JDBC操作数据库的过程进行了封装，使开发者只需要关注sql本身，不去关注例如注册驱动，加载连接，得到statement ,处理结果集等过程。
       mabatis通过xml或者注解的方式，将需要执行的各种sql语句配置起来，并通过Java对象与statement中的sql语句映射生成最终的sql语句，交给mybatis框架执行sql语句，并将结果映射Java对象返回
   工作原理:
       mybatis通过配置文件创建sqlsessionFactory,根据配置文件来源于1.xml 2.注解 获取sqlSession。sqlSession包含了执行sql语句的所有方法。
       可以通过sqlSession直接运行映射的sql语句，完成对数据的增删改查和事务的提交工作，用完之后关闭sqlsession.
   工作流程：
       mapper接口：
           接口的全类名是xml文件中namespace的值。
               接口的方法名是xml文件中mapperstatement的id值。
               接口中的方法的参数就是传递给sql的参数
               mapper接口是没有实现类的，当调用一个方法时，接口的全类名定位一个配置文件，接口的方法名定位这个配置文件中的一个namestatement,所以mapper的方法名是不能
               是不能被重载的， 因为mapperStatement的保存和寻找策略。
               mapper接口的工作原理，mybatis会使用JDK动态代理接口创建proxy对象，代理对象会拦截接口中的防范，转而执行mapperstatment锁代表的sql语句，然后将捷酷封装返回。
       mybatis解决的问题：
           1.使用数据库连接池管理链接，避免频繁创建、关闭连接带来的性能资源问题。
           2.xml管理sql语句，让Java代码与sql分离，代码更加容易维护。
           3.条件参数，将Java对象颜射到sql语句，通过statement的parameterType定义输入的参数的类型。
           4.将结果集封装成Java对象，通过statement的resyltType定义输出的类型。避免因为sql变化，对结果集厂里麻烦的问题。
  

3.2、Netty

• 为什么选择 Netty

• 说说业务中，Netty 的使用场景

• 原生的 NIO 在 JDK 1.7 版本存在 epoll bug

• 什么是TCP 粘包/拆包

• TCP粘包/拆包的解决办法

• Netty 线程模型

• 说说 Netty 的零拷贝

• Netty 内部执行流程

• Netty 重连实现

3.3、Tomcat

• Tomcat的基础架构（Server、Service、Connector、Container）

• Tomcat如何加载Servlet的

• Pipeline-Valve机制

• 可参考：《四张图带你了解Tomcat系统架构！》