JVM内存结构

程序计数器：当前线程所执行的字节码的行号指示器，用于记录正在执行的虚拟机字节指令地址，线程私有。
Java虚拟栈：存放基本数据类型、对象的引用、方法出口等，线程私有。
Native方法栈：和虚拟栈相似，只不过它服务于Native方法，线程私有。
Java堆：java内存最大的一块，所有对象实例、数组都存放在java堆，GC回收的地方，线程共享。
方法区：存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码数据等。（即永久带），回收目标主要是常量池的回收和类型的卸载，各线程共享

共享内存区划分

共享内存区 = 持久带 + 堆
持久带 = 方法区 + 其他
Java堆 = 老年代 + 新生代
新生代 = Eden + S0 + S1

JVM参数

-Xmx3550m： 最大堆大小为3550m。
-Xms3550m： 设置初始堆大小为3550m。
-Xmn2g： 设置年轻代大小为2g。
-Xss128k： 每个线程的堆栈大小为128k。
-XX:MaxPermSize： 设置持久代大小为16m
-XX:NewRatio=4: 设置年轻代（包括Eden和两个Survivor区）与年老代的比值（除去持久代）。
-XX:SurvivorRatio=4： 设置年轻代中Eden区与Survivor区的大小比值。设置为4，则两个Survivor区与一个Eden区的比值为2:4，一个Survivor区占整个年轻代的1/6
-XX:MaxTenuringThreshold=0： 设置垃圾最大年龄。如果设置为0的话，则年轻代对象不经过Survivor区，直接进入年老代。
-XX:+UseParallelGC： 选择垃圾收集器为并行收集器。
-XX:ParallelGCThreads=20： 配置并行收集器的线程数
-XX:+UseConcMarkSweepGC： 设置年老代为并发收集。
-XX:CMSFullGCsBeforeCompaction：由于并发收集器不对内存空间进行压缩、整理，所以运行一段时间以后会产生“碎片”，使得运行效率降低。此值设置运行多少次GC以后对内存空间进行压缩、整理。
-XX:+UseCMSCompactAtFullCollection： 打开对年老代的压缩。可能会影响性能，但是可以消除碎片

强引用(Object)

new了一个对象就是强引用，例如 Object obj = new Object();即使在内存不足的情况下，JVM宁愿抛出OutOfMemory错误也不会回收这种对象。

软引用(java.lang.ref.SoftReferencev)

如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。

弱引用(java.lang.ref.WeakReference)

具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，
都会回收它的内存。

虚引用(java.lang.ref.PhantomReference)

如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收器回收的活动。

JVM 类加载机制分为五个部分：加载，验证，准备，解析，初始化，

IO/NIO

NIO 主要有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector。传统 IO 基于字节流和字符流进行操作，而 NIO 基于 Channel 和 Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择区)用于监听多个通道的事件（比如：连接打开，数据到达）。因此，单个线程可以监听多个数据通道。
NIO 和传统 IO 之间第一个最大的区别是，IO 是面向流的，NIO 是面向缓冲区的。
字节：InputStream,outputStream；字符：read,write
客户端发送数据时，必须先将数据存入 Buffer 中，然后将 Buffer 中的内容写入通道。服务端这边接收数据必须通过 Channel 将数据读入到 Buffer 中，然后再从 Buffer 中取出数据来处理。

集合

存放于 Java.util 包中，主要有 3 种：set(集）、list(列表包含 Queue）和 map(映射)。

list

ArrayList:有序，可重复，底层数组，增删慢，get和set快，线程不安全，当前容量*1.5+1
Vector:有序，可重复，底层数组，增删慢，线程安全，默认一倍容量
LinkedList:有序，可重复，底层双向链表，查询慢，增删快，线程不安全

set

hashSet:无序，不可重复，底层hash表，存取速度快
Treeset:无序，不可重复，底层二叉树
linkhashSet:hash表存储，双向链表记录插入顺序
queue:两端出入list,数组或链表实现

map

hashMap:键不可重复，值可以重复，底层hash表，线程不安全，允许空的key,value
hashTable:键不可重复，值可以重复，底层hash表，线程安全，不允许空的key,value
treeMap:键不可重复，值可以重复，底层二叉树

java8HashMap

Java8：HashMap由数组+链表+红黑树组成当链表中的元素超过了 8 个以后，会将链表转换为红黑树
HashMap：里面是一个数组，每个元素是一个单向链表：key, value, hash 值和用于单向链表的 next。
java8之前：ConcurrentHashMap-分段锁是一个Segment 数组，Segment通过继承ReentrantLock来进行加锁，
所以每次需要加锁的操作锁住的是一个segment，这样只要保证每个Segment是线程安全的。默认是16个Segment
java8：ConcurrentHashMap引入了红黑树

JAVA多线程并发（JUC）–(原子性，可见性，有序性)

JUCtools:Semaphor、Exchanger、CyclicBarrier、CountDownLatchlock:Condition，ReadWriteLock，ReentrantLockaotimic:AtomicBoolean，AtomicInteger，AtomicIntegerArray，AtomicLong，AtomicLongArraycollections:CopyOnWriteArrayList,CopyOnWriteArraySet,ConcurrentHashMap,ConcurrentSkipListSetexecutor:线程池ThreadPoolExecutor,Future,Callable,FutureTaskSemaphor信号量:通过acquire()和release()获取和释放访问许可CountDownLatch同步计数器:某个任务依赖于其他的两个任务，只有那两个任务执行结束后，它才能执行。CyclicBarrier:一组线程等待至某个状态之后再全部同时执行aotimic：当前值和期望值比较，相同更新（CAS）----ABA问题（部分乐观锁的实现是通过版本号（version）的方式来解决 ABA 问题，乐观锁每次在执行数据的修改操作时，都会带上一个版本号，一旦版本号和数据的版本号一致就可以执行修改操作并对版本号执行+1 操作，否则就执行失败。因为每次操作的版本号都会随之增加，所以不会出现 ABA 问题，因为版本号只会增加不会减少。）AQS（ReentrantLock/Semaphore/CountDownLatch用AQS实现）：Future：get（）方法可以当任务结束后返回一个结果;get（long timeout,TimeUnit unit）做多等待timeout的时间就会返回结果cancel（boolean mayInterruptIfRunning）方法可以用来停止一个任务;isDone（）方法判断当前方法是否完成;isCancel（）方法判断当前方法是否取消Callable：FutureTask：实现了两个接口，Runnable和Future，所以它既可以作为Runnable被线程执行，又可以作为Future得到。继承 Thread 类，实现 Runnable 接口，ExecutorService、Callable<Class>、Future 有返回值线程启动线程的唯一方法就是通过Thread类的start()实例方法，并执行run()方法newSingleThreadExecutor：单个线程的线程池；newFixedThreadExecutor(n)：固定数量的线程池
newCacheThreadExecutor：可缓存线程池；newScheduleThreadExecutor：大小无限制的线程池，支持定时和周期性的执行线程corePoolSize：核心线程数量，会一直存在，除非allowCoreThreadTimeOut设置为true
maximumPoolSize：线程池允许的最大线程池数量
keepAliveTime：线程数量超过corePoolSize，空闲线程的最大超时时间
unit：超时时间的单位
workQueue：工作队列，保存未执行的Runnable 任务
threadFactory：创建线程的工厂类
handler：当线程已满，工作队列也满了的时候，会被调用。被用来实现各种拒绝策略。在线程的生命周期中，它要经过新建(New)、就绪（Runnable）、运行（Running）、阻塞(Blocked)和死亡(Dead)5 种状态

sleep 与 wait 区别

对于 sleep()方法，我们首先要知道该方法是属于 Thread 类中的。而 wait()方法，则是属于Object 类中的。
sleep()方法导致了程序暂停执行指定的时间，让出 cpu 该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。
在调用 sleep()方法的过程中，线程不会释放对象锁。
调用 wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。

start 与 run 区别

start（）方法来启动线程，真正实现了多线程运行。这时无需等待 run 方法体代码执行完毕，可以直接继续执行下面的代码。
通过调用 Thread 类的 start()方法来启动一个线程， 这时此线程是处于就绪状态， 并没有运行。
方法 run()称为线程体，它包含了要执行的这个线程的内容，线程就进入了运行状态，开始运行 run 函数当中的代码。
Run 方法运行结束， 此线程终止。然后 CPU 再调度其它线程。

JAVA 锁

乐观锁：通过 CAS 操作实现的，CAS 是一种更新的原子操作，比较当前值跟传入值是否一样，一样则更新，否则失败。
悲观锁：悲观锁就是Synchronized
自旋锁：减少线程的阻塞
非公平锁:加锁时不考虑排队等待问题，直接尝试获取锁，获取不到自动到队尾等待
公平锁：加锁前检查是否有排队等待的线程，优先排队等待的线程，先来先得
ReadWriteLock读写锁
共享锁:多个线程同时获取锁，并发访问
独占锁:每次只能有一个线程能持有锁
同步锁：使用 synchronized 关键字来取得一个对象的同步锁。
死锁Synchronized 同步锁：属于独占式的悲观锁，同时属于可重入锁，是非公平锁。
ReentantLock 继承接口 Lock，是一种可重入锁，非公平锁，公平锁(ReentrantLock(true/公平锁,false/非公平锁);

ReentrantLock 与 synchronized

ReentrantLock 通过方法 lock()与 unlock()来进行加锁与解锁操作，
与 synchronized 会被 JVM 自动解锁机制不同，ReentrantLock 加锁后需要手动进行解锁。
使用 ReentrantLock 必须在 finally 控制块中进行解锁操作。
ReentrantLock 相比 synchronized 的优势是可中断、公平锁、多个锁。这种情况下需要使用 ReentrantLock。

tryLock 和 lock 和 lockInterruptibly 的区别

1. tryLock 能获得锁就返回 true，不能就立即返回 false，tryLock(long timeout,TimeUnitunit)，可以增加时间限制，如果超过该时间段还没获得锁，返回 false
2. lock 能获得锁就返回 true，不能的话一直等待获得锁
3. lock 和 lockInterruptibly，如果两个线程分别执行这两个方法，但此时中断这两个线程，lock 不会抛出异常，而 lockInterruptibly 会抛出异常。

线程基本方法

1. sleep()：强迫一个线程睡眠Ｎ毫秒。
2. isAlive()： 判断一个线程是否存活。
3. join()： 等待线程终止。
4. activeCount()： 程序中活跃的线程数
5. enumerate()： 枚举程序中的线程。
6. currentThread()： 得到当前线程。
7. isDaemon()： 一个线程是否为守护线
8. setDaemon()： 设置一个线程为守护线程。(用户线程和守护线程的区别在于，是否等待主线程依赖于主线程结束而结束)
9. setName()： 为线程设置一个名称。
10. wait()： 强迫一个线程等待。
11. notify()： 通知一个线程继续运行。
12. setPriority()： 设置一个线程的优先级。
13. getPriority():：获得一个线程的优先级。

Java 中的反射机制是指在运行状态中，对于任意一个类都能够知道这个类所有的属性和方法；并且对于任意一个对象，都能够调用它的任意一个方法；
这种动态获取信息以及动态调用对象方法的功能成为 Java 语言的反射机制。

1. Class 类：反射的核心类，可以获取类的属性，方法等信息。
2. Field 类：Java.lang.reflec 包中的类，表示类的成员变量，可以用来获取和设置类之中的属性值。
3. Method 类： Java.lang.reflec 包中的类，表示类的方法，它可以用来获取类中的方法信息或者执行方法。
4. Constructor 类： Java.lang.reflec 包中的类，表示类的构造方法。

Spring

模块:Spring Core：核心类库，提供IOC服务；Spring Context：提供框架式的Bean访问方式，以及企业级功能（JNDI、定时任务等）；Spring AOP：AOP服务；Spring DAO：对JDBC的抽象，简化了数据访问异常的处理；Spring ORM：对现有的ORM框架的支持；Spring Web：提供了基本的面向Web的综合特性，例如多方文件上传；Spring MVC：提供面向Web应用的Model-View-Controller实现。
AOP:面向切面,用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块AOP中的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理JDK动态代理只提供接口的代理。核心InvocationHandler接口和Proxy类，InvocationHandler通过invoke()方法反射来调用目标类中的代码，动态地将横切逻辑和业务编织在一起；接着，Proxy利用InvocationHandler动态创建一个符合某一接口的的实例,  生成目标类的代理对象。CGLIB来动态代理目标类(没有InvocationHandler接口)如果某个类被标记为final，那么它是无法使用CGLIB做动态代理的。IOC：控制反转，创建对象的控制权的转移Spring容器中，并由容器根据配置文件去创建实例和管理各个实例之间的依赖关系，对象与对象之间松散耦合，也利于功能的复用（使用java的反射机制，根据配置文件在运行时动态的去创建对象以及管理对象，并调用对象的方法的。）注入方式 ：构造器注入、setter方法注入、根据注解注入。

BeanFactory和ApplicationContext区别

    BeanFactory：是Spring里面最底层的接口，包含了各种Bean的定义，读取bean配置文档，管理bean的加载、实例化，控制bean的生命周期，维护bean之间的依赖关系BeanFactroy采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化ApplicationContext，它是在容器启动时，一次性创建了所有的BeanBeanFactory需要手动注册，而ApplicationContext则是自动注册Servlet的生命周期：实例化，初始init，接收请求service，销毁destroy；

bean的生命周期：

    1）实例化Bean：对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。对于ApplicationContext容器，当容器启动结束后，通过获取BeanDefinition对象中的信息，实例化所有的bean。（2）设置对象属性（依赖注入）：实例化后的对象被封装在BeanWrapper对象中，紧接着，Spring根据BeanDefinition中的信息以及 通过BeanWrapper提供的设置属性的接口完成依赖注入。（3）处理Aware接口：Spring会检测该对象是否实现了xxxAware接口，并将相关的xxxAware实例注入给Bean：①如果这个Bean已经实现了BeanNameAware接口，会调用它实现的setBeanName(String beanId)方法，此处传递的就是Spring配置文件中Bean的id值；②如果这个Bean已经实现了BeanFactoryAware接口，会调用它实现的setBeanFactory()方法，传递的是Spring工厂自身。③如果这个Bean已经实现了ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，传入Spring上下文；（4）BeanPostProcessor：对Bean进行一些自定义的处理，那么可以让Bean实现了BeanPostProcessor接口，那将会调用postProcessBeforeInitialization(Object obj, String s)方法。（5）InitializingBean 与 init-method：如果Bean在Spring配置文件中配置了 init-method 属性，则会自动调用其配置的初始化方法。（6）如果这个Bean实现了BeanPostProcessor接口，将会调用postProcessAfterInitialization(Object obj, String s)方法；由于这个方法是在Bean初始化结束时调用的，所以可以被应用于内存或缓存技术；Bean就已经被正确创建了，之后就可以使用这个Bean了。（7）DisposableBean：当Bean不再需要时，会经过清理阶段，如果Bean实现了DisposableBean这个接口，会调用其实现的destroy()方法；（8）destroy-method：如果这个Bean的Spring配置中配置了destroy-method属性，会自动调用其配置的销毁方法。

bean的作用域

    （1）singleton：默认，每个容器中只有一个bean的实例，单例的模式由BeanFactory自身来维护。（2）prototype：为每一个bean请求提供一个实例。（3）request：为每一个网络请求创建一个实例，在请求完成以后，bean会失效并被垃圾回收器回收。（4）session：与request范围类似，确保每个session中有一个bean的实例，在session过期后，bean会随之失效。（5）global-session：全局作用域，global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时，它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量的话，那么这全局变量需要存储在global-session中。全局作用域与Servlet中的session作用域效果相同。

Spring基于xml注入bean的几种方式：

    （1）Set方法注入；（2）构造器注入：①通过index设置参数的位置；②通过type设置参数类型；（3）静态工厂注入；（4）实例工厂；

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

    （1）工厂模式：BeanFactory就是简单工厂模式的体现，用来创建对象的实例；（2）单例模式：Bean默认为单例模式。（3）代理模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术；（4）模板方法：用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate。（5）观察者模式：定义对象键一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知被制动更新，如Spring中listener的实现--ApplicationListener。

Spring事务的实现方式和实现原理

    Spring事务的本质其实就是数据库对事务的支持，没有数据库的事务支持，spring是无法提供事务功能的。真正的数据库层的事务提交和回滚是通过binlog或者redo log实现的编程式事务管理和声明式事务①编程式事务管理使用TransactionTemplate。②声明式事务管理建立在AOP之上的1.获取事务的属性（@Transactional注解中的配置）2.加载配置中的TransactionManager.3.获取收集事务信息TransactionInfo 4.执行目标方法5.出现异常，尝试处理。6.清理事务相关信息7.提交事务

Spring事务中的隔离级别

    ISOLATION_DEFAULT：使用后端数据库默认的隔离级别，Mysql默认采用的REPEATABLE_READ隔离级别；Oracle默认采用的READ_COMMITTED隔离级别。ISOLATION_READ_UNCOMMITTED：最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读。ISOLATION_READ_COMMITTED：允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生ISOLATION_REPEATABLE_READ：对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生。ISOLATION_SERIALIZABLE：最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别

Spring事务中有哪几种事务传播行为

    支持当前事务的情况：PROPAGATION_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。PROPAGATION_SUPPORTS： 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。PROPAGATION_MANDATORY： 如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。（mandatory：强制性）。不支持当前事务的情况：PROPAGATION_REQUIRES_NEW： 创建一个新的事务，如果当前存在事务，则把当前事务挂起。PROPAGATION_NOT_SUPPORTED： 以非事务方式运行，如果当前存在事务，则把当前事务挂起。PROPAGATION_NEVER： 以非事务方式运行，如果当前存在事务，则抛出异常。其他情况：PROPAGATION_NESTED： 如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于PROPAGATION_REQUIRED。

Spring如何处理线程并发问题(有状态就是有数据存储功能。无状态就是不会保存数据。)

无状态的bean,用ThreadLocal的“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，
而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响

SpringMVC

(1) 客户端请求提交到 DispatcherServlet。
(2) 由 DispatcherServlet 控制器查询一个或多个 HandlerMapping
(3) DispatcherServlet 将请求提交到 Controller。
(4)调用业务处理和返回结果：Controller 调用业务逻辑处理后，返回 ModelAndView。
(5)处理视图映射并返回模型： DispatcherServlet 查询一个或多个 ViewResoler 视图解析器，找到 ModelAndView 指定的视图。
(6) Http 响应：视图负责将结果显示到客户端。

SpringBoot

启动类上面的注解是@SpringBootApplication
@SpringBootConfiguration：XML文件配置。
@EnableAutoConfiguration：能够自动配置spring的上下文，试图猜测和配置你想要的bean类，
通常会自动根据你的类路径和你的bean定义自动配置
@ComponentScan：会自动扫描指定包下的全部标有@Component的类，并注册成bean，
当然包括@Component下的子注解@Service,@Repository,@Controller。

SpringCloud

Eureka：服务治理组件，包括服务端的注册中心和客户端的服务发现机制；
Ribbon：负载均衡的服务调用组件，具有多种负载均衡调用策略；
Hystrix：服务容错组件，实现了断路器模式，为依赖服务的出错和延迟提供了容错能力；
Feign：基于Ribbon和Hystrix的声明式服务调用组件；
Zuul：API网关组件，对请求提供路由及过滤功能。

Eureka:

Register: 服务注册服务
将自身注册到注册中心，服务提供者也是一个 Eureka Client。当 Eureka Client 向 Eureka Server 注册时，
它提供自身的元数据，比如 IP 地址、端口，运行状况指示符 URL，主页等。
Renew: 服务续约
Eureka Client 会每隔 30 秒发送一次心跳来续约。 通过续约来告知 Eureka Server 该 Eureka Client 运行正常，没有出现问题。
默认情况下，如果 Eureka Server 在 90 秒内没有收到 Eureka Client 的续约，Server 端会将实例从其注册表中删除，
Eviction 服务剔除
当 Eureka Client 和 Eureka Server 不再有心跳时，Eureka Server 会将该服务实例从服务注册列表中删除，即服务剔除。
Cancel: 服务下线
Eureka Client 在程序关闭时向 Eureka Server 发送取消请求。 发送请求后，
该客户端实例信息将从 Eureka Server 的实例注册表中删除。该下线请求不会自动完成，它需要调用以下内容：

Ribbon：负载均衡策略

IClientConfig	    定义Ribbon管理配置得接口	          DefaultClientConfigImpl
IRule	            定义Ribbon中负载均衡策略的接口	      ZoneAvoidanceRule
IPing	            定义顶起ping服务检查可用性的接口	      DummyPing
ServerList	        定义获取服务列表方法的接口	          ConfigurationBasedServerList
ServerListFilter	定义特定期望获取服务列表方法的接口	  ZonePreferenceServerListFilter
ILoadBalancer	    定义负载均衡选择服务的核心老方法的接口	  ZoneAwareLoadBalancer
ServerListUpdater	为DynamicServerListLoadBalance定义动态更新服务猎鸟的接口

Hystrix：

两种隔离模式：线程池隔离模式、信号量隔离模式。

Feign是在 Ribbon的基础上进行了一次改进，采用接口的方式，将需要调用的其他服务的方法定义成抽象方法即可，不需要自己构建 http 请求
Ribbon 是一个基于 HTTP 和 TCP 客户端 的负载均衡的工具，使用 HttpClient 或 RestTemplate 模拟 http 请求

Nacos：

1.支持AP和CP模型；2.DNS-F客户端使用监听模式push/pull拉取更新信息；3.Raft选举算法性能、可用性、容错性比较好；
4.支持服务端/客户端/关闭检查模式，检查方式有tcp、http、sql。

Eureka：

1.AP模型，2.客户端定时轮询服务端获取其他服务ip信息；3.使用广播同步信息；4.客户端向服务端发送http心跳

MyBatis

1、 创建SqlSessionFactory
2、 通过SqlSessionFactory创建SqlSession
3、 通过sqlsession执行数据库操作
4、 调用session.commit()提交事务
5、 调用session.close()关闭会话

Mybatis都有哪些Executor执行器

SimpleExecutor：每执行一次update或select，就开启一个Statement对象，用完立刻关闭Statement对象。
ReuseExecutor：执行update或select，以sql作为key查找Statement对象，存在就使用，不存在就创建，用完后，不关闭Statement对象，而是放置于Map<String, Statement>内，供下一次使用。简言之，就是重复使用Statement对象。
BatchExecutor：执行update（没有select，JDBC批处理不支持select），将所有sql都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个Statement对象，每个Statement对象都是addBatch()完毕后，等待逐一执行executeBatch()批处理。与JDBC批处理相同。

#{}是占位符，预编译处理，自动加上单引号，防止SQL注入
${}是拼接符，字符串替换，没有预编译处理，不会加上单引号，不能防止SQL 注入

Redis（选举机制）

String,list,hash,set,zset,

AOF和RDB两种持久化方式

AOF:AOF持久化以日志的形式记录服务器所处理的每一个写、删除操作，查询操作不会记录，以文本的方式记录，可以打开文件看到详细的操作记录。
RDB:RDB持久化是指在指定的时间间隔内将内存中的数据集快照写入磁盘，实际操作过程是fork一个子进程，先将数据集写入临时文件，写入成功后，再替换之前的文件，用二进制压缩存储

RDB的优点：1.体积更小：2.恢复更快：3.性能更高：父进程在保存rdb时候只需要fork一个子进程
RDB的缺点：1.故障丢失:服务器死机，造成数据丢失；2.耐久性差:访问量很高的时候，fork的时间也会延长

AOF优点:1.数据保证:设置保存的时间,2.自动缩小：当aof文件大小到达一定程度的时候，后台会自动的去执行aof重写
AOF缺点:1.性能相对较差；2.体积相对更大；3.恢复速度更慢

过期策略

定时过期：每个设置过期时间的key都需要创建一个定时器，到过期时间就会立即清除
惰性过期：只有当访问一个key时，才会判断该key是否已过期，过期则清除
定期过期：每隔一定的时间，会扫描一定数量的数据库的expires字典中一定数量的key，并清除其中已过期的key

Redis中同时使用了惰性过期和定期过期两种过期策略。

Redis集群

集群监控：负责监控 redis master 和 slave 进程是否正常工作。
消息通知：如果某个 redis 实例有故障，那么哨兵负责发送消息作为报警通知给管理员。
故障转移：如果 master node 挂掉了，会自动转移到 slave node 上。
配置中心：如果故障转移发生了，通知 client 客户端新的 master 地址。

Redis 主从复制的核心原理

当从库和主库建立MS关系后，会向主数据库发送SYNC命令
主库接收到SYNC命令后会开始在后台保存快照(RDB持久化过程)，并将期间接收到的写命令缓存起来
当快照完成后，主Redis会将快照文件和所有缓存的写命令发送给从Redis
从Redis接收到后，会载入快照文件并且执行收到的缓存的命令
之后，主Redis每当接收到写命令时就会将命令发送从Redis，从而保证数据的一致

Redis哈希槽的概念

Redis集群没有使用一致性hash,而是引入了哈希槽的概念，Redis集群有16384个哈希槽，
每个key通过CRC16校验后对16384取模来决定放置哪个槽，集群的每个节点负责一部分hash槽。

Redis异常

缓存雪崩缓存雪崩是指缓存同一时间大面积的失效，所以，后面的请求都会落到数据库上，造成数据库短时间内承受大量请求而崩掉。
解决方案缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。一般并发量不是特别多的时候，使用最多的解决方案是加锁排队。给每一个缓存数据增加相应的缓存标记，记录缓存的是否失效，如果缓存标记失效，则更新数据缓存。缓存穿透缓存穿透是指缓存和数据库中都没有的数据，导致所有的请求都落到数据库上，造成数据库短时间内承受大量请求而崩掉。
解决方案接口层增加校验，如用户鉴权校验，id做基础校验，id<=0的直接拦截；从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为key-null，缓存有效时间可以设置短点，如30秒（设置太长会导致正常情况也没法使用）。这样可以防止攻击用户反复用同一个id暴力攻击采用布隆过滤器，将所有可能存在的数据哈希到一个足够大的 bitmap 中，一个一定不存在的数据会被这个 bitmap 拦截掉，从而避免了对底层存储系统的查询压力缓存击穿缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力。和缓存雪崩不同的是，缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。
解决方案设置热点数据永远不过期。加互斥锁，互斥锁缓存预热缓存预热就是系统上线后，将相关的缓存数据直接加载到缓存系统。这样就可以避免在用户请求的时候，先查询数据库，然后再将数据缓存的问题！用户直接查询事先被预热的缓存数据！
解决方案直接写个缓存刷新页面，上线时手工操作一下；数据量不大，可以在项目启动的时候自动进行加载；定时刷新缓存；缓存降级当访问量剧增、服务出现问题（如响应时间慢或不响应）或非核心服务影响到核心流程的性能时，仍然需要保证服务还是可用的，即使是有损服务。系统可以根据一些关键数据进行自动降级，也可以配置开关实现人工降级。缓存降级的最终目的是保证核心服务可用，即使是有损的。而且有些服务是无法降级的（如加入购物车、结算）。在进行降级之前要对系统进行梳理，看看系统是不是可以丢卒保帅；从而梳理出哪些必须誓死保护，哪些可降级；比如可以参考日志级别设置预案：服务降级的目的，是为了防止Redis服务故障，导致数据库跟着一起发生雪崩问题。因此，对于不重要的缓存数据，可以采取服务降级策略，例如一个比较常见的做法就是，Redis出现问题，不去数据库查询，而是直接返回默认值给用户

MySql

MQ

Dubbo

Provider： 暴露服务的提供方。
Consumer：调用远程服务的服务消费方。
Registry： 服务注册中心和发现中心。
Monitor： 统计服务和调用次数，调用时间监控中心。（dubbo的控制台页面中可以显示）
Container：服务运行的容器。

Dubbo 的整体架构设计有哪些分层

接口服务层（Service）：该层与业务逻辑相关，根据 provider 和 consumer 的业务设计对应的接口和实现
配置层（Config）：对外配置接口，以 ServiceConfig 和 ReferenceConfig 为中心
服务代理层（Proxy）：服务接口透明代理，生成服务的客户端 Stub 和 服务端的 Skeleton，以 ServiceProxy 为中心，扩展接口为 ProxyFactory
服务注册层（Registry）：封装服务地址的注册和发现，以服务 URL 为中心，扩展接口为 RegistryFactory、Registry、RegistryService
路由层（Cluster）：封装多个提供者的路由和负载均衡，并桥接注册中心，以Invoker 为中心，扩展接口为 Cluster、Directory、Router 和 LoadBlancce
监控层（Monitor）：RPC 调用次数和调用时间监控，以 Statistics 为中心，扩展接口为 MonitorFactory、Monitor 和 MonitorService
远程调用层（Protocal）：封装 RPC 调用，以 Invocation 和 Result 为中心，扩展接口为 Protocal、Invoker 和 Exporter
信息交换层（Exchange）：封装请求响应模式，同步转异步。以 Request 和Response 为中心，扩展接口为 Exchanger、ExchangeChannel、ExchangeClient 和 ExchangeServer
网络传输层（Transport）：抽象 mina 和 netty 为统一接口，以 Message 为中心，扩展接口为 Channel、Transporter、Client、Server 和 Codec
数据序列化层（Serialize）：可复用的一些工具，扩展接口为 Serialization、ObjectInput、ObjectOutput 和 ThreadPool

默认使用什么序列化框架，你知道的还有哪些？

推荐使用 Hessian 序列化，还有 Duddo、FastJson、Java 自带序列化

服务提供者能实现失效踢出是什么原理？

服务失效踢出基于 zookeeper 的临时节点原理

Dubbo核心配置

<dubbo:service/>	服务配置	用于暴露一个服务，定义服务的元信息，一个服务可以用多个协议暴露，一个服务也可以注册到多个注册中心
<dubbo:reference/>	引用配置	用于创建一个远程服务代理，一个引用可以指向多个注册中心
<dubbo:protocol/>	协议配置	用于配置提供服务的协议信息，协议由提供方指定，消费方被动接受
<dubbo:application/>	应用配置	用于配置当前应用信息，不管该应用是提供者还是消费者
<dubbo:module/>	      模块配置	用于配置当前模块信息，可选
<dubbo:registry/>	注册中心配置	用于配置连接注册中心相关信息
<dubbo:monitor/>	监控中心配置	用于配置连接监控中心相关信息，可选
<dubbo:provider/>	提供方配置	当 ProtocolConfig 和 ServiceConfig 某属性没有配置时，采用此缺省值，可选
<dubbo:consumer/>	消费方配置	当 ReferenceConfig 某属性没有配置时，采用此缺省值，可选
<dubbo:method/>	    方法配置	用于 ServiceConfig 和 ReferenceConfig 指定方法级的配置信息
<dubbo:argument/>	参数配置	用于指定方法参数配置

Dubbo集群容错

Failover Cluster
失败自动切换，自动重试其它服务器（默认）
Failfast Cluster
快速失败，立即报错，只发起一次调用
Failsafe Cluster
失败安全，出现异常时，直接忽略
Failback Cluster
失败自动恢复，记录失败请求，定时重发
Forking Cluster
并行调用多个服务器，只要一个成功即返回
Broadcast Cluster
广播逐个调用所有提供者，任意一个报错则报错

ZooKeeper(Leader选举–过半)

文件系统；通知机制（1）PERSISTENT-持久节点
除非手动删除，否则节点一直存在于 Zookeeper 上
（2）EPHEMERAL-临时节点
临时节点的生命周期与客户端会话绑定，一旦客户端会话失效（客户端与zookeeper 连接断开不一定会话失效），那么这个客户端创建的所有临时节点都会被移除。
（3）PERSISTENT_SEQUENTIAL-持久顺序节点
基本特性同持久节点，只是增加了顺序属性，节点名后边会追加一个由父节点维护的自增整型数字。
（4）EPHEMERAL_SEQUENTIAL-临时顺序节点
基本特性同临时节点，增加了顺序属性，节点名后边会追加一个由父节点维护的自增整型数字。

Zookeeper 的通知机制（watch）

client 端会对某个 znode 建立一个 watcher 事件，当该 znode 发生变化时，这些 client 会收到 zk 的通知，
然后 client 可以根据 znode 变化来做出业务上的改变等

zookeeper是如何保证事务的顺序一致性:采用了全局递增的事务Id来标识(zxid)

SpringCloud在CAP法则上主要满足的是A和P法则，Dubbo和Zookeeper在CAP法则主要满足的是C和P法则
C:一致性 A:可用性 P:分区容错性

Nginx: