一、基础篇（1-2年）

1、Java 三大特性

  • 封装：

    封装也称为信息隐藏，是指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。系统的其他部分只有通过包裹在数据外面的被授权的操作来与这个抽象数据类型交流与交互。也就是说，用户无需知道对象内部方法的实现细节，但可以根据对象提供的外部接口(对象名和参数)访问该对象。

  • 继承：

    一个类继承另一个类，则称继承的类为子类，被继承的类为父类。

  • 多态：

    多态的概念发展出来，是以封装和继承为基础的。

    多态就是在抽象的层面上实施一个统一的行为，到个体（具体）的层面上时，这个统一的行为会因为个体（具体）的形态特征而实施自己的特征行为。（针对一个抽象的事，对于内部个体又能找到其自身的行为去执行。）

    相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不同。

2、ConcurrentHashMap 线程安全？
3、栈（stack）和 队列（queue）的区别？
栈（stack）

栈（stack）是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫做栈顶（top）。它是后进先出（LIFO）的。对栈的基本操作只有 push（进栈）和 pop（出栈）两种，前者相当于插入，后者相当于删除最后的元素

队列（queue）

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

链表（Link）和 散列表（Hash Table） 的区别？
链表（Link）

链表是一种数据结构，和数组同级。比如，Java 中我们使用的 ArrayList，其实现原理是数组。而LinkedList 的实现原理就是链表了。链表在进行循环遍历时效率不高，但是插入和删除时优势明显。

散列表（Hash Table）

散列表（Hash table，也叫哈希表）是一种查找算法，与链表、树等算法不同的是，散列表算法在查找时不需要进行一系列和关键字（关键字是数据元素中某个数据项的值，用以标识一个数据元素）的比较操作。

B-Tree 和 B+Tree 的区别?
用过哪些设计模式（23种），简述你是如何使用的？
什么是 CAS（比较并交换-乐观锁机制-锁自旋）？

CAS（Compare And Swap/Set）比较并交换，CAS 算法的过程是这样：它包含 3 个参数 CAS(V,E,N)。V 表示要更新的变量(内存值)，E 表示预期值(旧的)，N 表示新值。当且仅当 V 值等于 E 值时，才会将 V 的值设为 N，如果 V 值和 E 值不同，则说明已经有其他线程做了更新，则当前线程什么都不做。最后，CAS 返回当前 V 的真实值。

什么是 AQS（抽象的队列同步器）？

AbstractQueuedSynchronizer 类如其名，抽象的队列式的同步器，AQS 定义了一套多线程访问共享资源的同步器框架，许多同步类实现都依赖于它，如常用的ReentrantLock/Semaphore/CountDownLatch。

如何在两个线程之间共享数据？

Java 里面进行多线程通信的主要方式就是共享内存的方式，共享内存主要的关注点有两个：可见性和有序性原子性。Java 内存模型（JMM）解决了可见性和有序性的问题，而锁解决了原子性的问题，理想情况下我们希望做到“同步”和“互斥”。

数据库三范式？

范式是具有最小冗余的表结构。3 范式具体如下：

  • 第一范式(1st NF －列都是不可再分)

第一范式的目标是确保每列的原子性:如果每列都是不可再分的最小数据单元（也称为最小的原子单元），则满足第一范式（1NF）

  • 第二范式(2nd NF－每个表只描述一件事情)

首先满足第一范式，并且表中非主键列不存在对主键的部分依赖。 第二范式要求每个表只描述一件事情。

  • 第三范式(3rd NF－ 不存在对非主键列的传递依赖)

第三范式定义是，满足第二范式，并且表中的列不存在对非主键列的传递依赖。除了主键订单编
号外，顾客姓名依赖于非主键顾客编号。

你是怎么从进行SQL的优化？
分析阶段
设计阶段

1、数据库逻辑设计的规范化

2、合理的冗余

3、主键的设计

4、外键的设计

5、字段的设计

6、 数据库物理存储和环境的设计

7、 系统设计

8、索引的设计

编码阶段
Spring MVC
简述下你对Spring IOC、DI、AOP 的理解？

Spring 通过一个配置文件描述 Bean 及 Bean 之间的依赖关系，利用 Java 语言的反射功能实例化Bean 并建立 Bean 之间的依赖关系。Spring 的 IoC 容器在完成这些底层工作的基础上，还提供了 Bean 实例缓存、生命周期管理、 Bean 实例代理、事件发布、资源装载等高级服务。

AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。

Spring 事务传播属性（Propagation）和隔离级别（Isolation Level）？
  • 事务传播属性（Propagation）

1) REQUIRED（默认属性）

如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。
被设置成这个级别时，会为每一个被调用的方法创建一个逻辑事务域。如果前面的方法已经创建了事务，那么后面的方法支持当前的事务，如果当前没有事务会重新建立事务。

2) MANDATORY

支持当前事务，如果当前没有事务，就抛出异常。

3) NEVER

以非事务方式执行，如果当前存在事务，则抛出异常。

4) NOT_SUPPORTED

以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

5) REQUIRES_NEW

新建事务，如果当前存在事务，把当前事务挂起。

6) SUPPORTS

支持当前事务，如果当前没有事务，就以非事务方式执行。

7) NESTED

支持当前事务，新增Savepoint点，与当前事务同步提交或回滚。
嵌套事务一个非常重要的概念就是内层事务依赖于外层事务。外层事务失败时，会回滚内层事务所做的动作。而内层事务操作失败并不会引起外层事务的回滚。

PROPAGATION_NESTED 与 PROPAGATION_REQUIRES_NEW的区别：

它们非常类似，都像一个嵌套事务，如果不存在一个活动的事务，都会开启一个新的事务。

使用PROPAGATION_REQUIRES_NEW时，内层事务与外层事务就像两个独立的事务一样，一旦内层事务进行了提交后，外层事务不能对其进行回滚。两个事务互不影响。两个事务不是一个真正的嵌套事务。同时它需要JTA 事务管理器的支持。
使用PROPAGATION_NESTED时，外层事务的回滚可以引起内层事务的回滚。而内层事务的异常并不会导致外层事务的回滚，它是一个真正的嵌套事务

  • 事务隔离级别（Isolation Level）
  1. 首先说明一下事务并发引起的三种情况：

1) Dirty Reads 脏读

一个事务正在对数据进行更新操作，但是更新还未提交，另一个事务这时也来操作这组数据，并且读取了前一个事务还未提交的数据，而前一个事务如果操作失败进行了回滚，后一个事务读取的就是错误数据，这样就造成了脏读。

2) Non-Repeatable Reads 不可重复读

一个事务多次读取同一数据，在该事务还未结束时，另一个事务也对该数据进行了操作，而且在第一个事务两次次读取之间，第二个事务对数据进行了更新，那么第一个事务前后两次读取到的数据是不同的，这样就造成了不可重复读。

3) Phantom Reads 幻像读

第一个数据正在查询符合某一条件的数据，这时，另一个事务又插入了一条符合条件的数据，第一个事务在第二次查询符合同一条件的数据时，发现多了一条前一次查询时没有的数据，仿佛幻觉一样，这就是幻像读。

非重复度和幻像读的区别：

  • 非重复读：是指同一查询在同一事务中多次进行，由于其他提交事务所做的修改或删除，每次返回不同的结果集，此时发生非重复读。
  • 幻像读：是指同一查询在同一事务中多次进行，由于其他提交事务所做的插入操作，每次返回不同的结果集，此时发生幻像读。

表面上看，区别就在于非重复读能看见其他事务提交的修改和删除，而幻像能看见其他事务提交的插入。

  1. 隔离级别：

1) DEFAULT （默认）
这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别。另外四个与JDBC的隔离级别相对应。

2) READ_UNCOMMITTED （读未提交）
这是事务最低的隔离级别，它允许另外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。

3) READ_COMMITTED （读已提交）
保证一个事务修改的数据提交后才能被另外一个事务读取，另外一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像读。

4) REPEATABLE_READ （可重复读）
这种事务隔离级别可以防止脏读、不可重复读，但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了不可重复读。

5) SERIALIZABLE（串行化）
这是花费最高代价但是最可靠的事务隔离级别，事务被处理为顺序执行。除了防止脏读、不可重复读外，还避免了幻像读。

隔离级别解决事务并行引起的问题：

Spring Boot

对 Spring Boot 的看法，解决了什么问题？

Spring Boot 大致启动流程是怎么样的？

启动流程主要分为三个部分，第一部分进行SpringApplication的初始化模块，配置一些基本的环境变量、资源、构造器、监听器，第二部分实现了应用具体的启动方案，包括启动流程的监听模块、加载配置环境模块、及核心的创建上下文环境模块，第三部分是自动化配置模块

Druid、HikariCP

你都用过哪些数据库连接池？选择该连接池的考虑是什么？

如果让你基于commons-pool2实现一个连接池，你认为应该怎么做，需要注意哪些事情？

Mybatis

  • MyBatis 初始化过程

    第一步：MyBatis的初始化的过程其实就是解析配置文件和初始化Configuration的过程
    第二步：XMLConfigBuilder对象会进行XML配置文件的解析，实际为configuration节点的解析操作。

  • MyBatis 执行流程

    代理接口 -> DefaultSqlSession -> Excuter -> StatmentHandler -> ParamterHandler -> TypeHandler -> PreparedStatement 执行SQL -> ResultHandler -> TypeHandler

  • Mybatis 拦截器

    是否基于Mybatis 拦截器做过业务逻辑，如果实现的？

MySQL:

B+Tree
回表
优化

HTML、CSS、JQuery、Ajax

对当前 HTML、CSS 环境了解情况，是否会使用 Vue? 会什么移动端开发，如 小程序、Uni-App

Ajax 请求过程：

第一步，创建XMLHttpRequest对象
第二步，注册回调函数
第三步，配置请求信息，open(),get
第四步，发送请求,post请求下，要传递的参数放这
第五步，创建回调函数

二、进阶篇（3-5年）

内存模型

Java 堆从 GC 的角度还可以细分为: 新生代(Eden 区、From Survivor 区和 To Survivor 区)和老年代

  • 是用来存放新生的对象。一般占据堆的 1/3 空间。由于频繁创建对象，所以新生代会频繁触发 MinorGC 进行垃圾回收。新生代又分为 Eden 区、ServivorFrom、ServivorTo 三个区。

    • Eden 区： Java 新对象的出生地（如果新创建的对象占用内存很大，则直接分配到老年代）。当 Eden 区内存不够的时候就会触发 MinorGC，对新生代区进行一次垃圾回收。

    • ServivorFrom：上一次 GC 的幸存者，作为这一次 GC 的被扫描者。

    • ServivorTo：保留了一次 MinorGC 过程中的幸存者。

  • 存放应用程序中生命周期长的内存对象，老年代的对象比较稳定，所以 MajorGC 不会频繁执行。

  • 永久代指内存的永久保存区域，主要存放 Class 和 Meta（元数据）的信息,Class 在被加载的时候被放入永久区域

类加载机制

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

  • 加载

    加载是类加载过程中的一个阶段，这个阶段会在内存中生成一个代表这个类的 java.lang.Class 对 象，作为方法区这个类的各种数据的入口。

  • 验证

    这一阶段的主要目的是为了确保 Class 文件的字节流中包含的信息是否符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。

  • 准备

    准备阶段是正式为类变量分配内存并设置类变量的初始值阶段，即在方法区中分配这些变量所使用的内存空间。

  • 解析

    解析阶段是指虚拟机将常量池中的符号引用替换为直接引用的过程。

  • 初始化

    初始化阶段是类加载最后一个阶段，前面的类加载阶段之后，除了在加载阶段可以自定义类加载器以外，其它操作都由 JVM 主导。到了初始阶段，才开始真正执行类中定义的 Java 程序代码。

垃圾收集器
GC 垃圾收集器有哪些类型，各自工作方式是什么样的？
  • Serial 垃圾收集器（单线程、复制算法）
  • ParNew 垃圾收集器（Serial+多线程）
  • Parallel Scavenge 收集器（多线程复制算法、高效）
  • Serial Old 收集器（单线程标记整理算法 ）
  • Parallel Old 收集器（多线程标记整理算法）
  • CMS 收集器（多线程标记清除算法）
  • G1 收集器
性能优化
JVM 参数优化 ?
参数名称 含义 默认值
-Xms 初始堆大小 物理内存的1/64(<1GB) 默认(MinHeapFreeRatio参数可以调整)空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制.
-Xmx 最大堆大小 物理内存的1/4(<1GB) 默认(MaxHeapFreeRatio参数可以调整)空余堆内存大于70%时，JVM会减少堆直到 -Xms的最小限制
-Xmn 年轻代大小(1.4 or lator) 注意：此处的大小是（eden+ 2 survivor space).与jmap -heap中显示的New gen是不同的。整个堆大小=年轻代大小 + 年老代大小 + 持久代大小. 增大年轻代后,将会减小年老代大小.此值对系统性能影响较大,Sun官方推荐配置为整个堆的3/8
如何对 JVM 进行调优 ？
  • 开启 -XX:+PrintGC 及其相关参数，输出GC日志，跟踪系统 GC 过程
  • 开启远程调试功能，使用 jvisualvm、jstat 等工具可视化的跟踪每个线程

jstack ( 查看jvm线程运行状态，是否有死锁现象等等信息)
jinfo:可以输出并修改运行时的java 进程的opts。
jps:与unix上的ps类似，用来显示本地的java进程，可以查看本地运行着几个java程序，并显示他们的进程号。
jstat:一个极强的监视VM内存工具。可以用来监视VM内存内的各种堆和非堆的大小及其内存使用量。
jmap:打印出某个java进程（使用pid）内存内的所有’对象’的情况（如：产生那些对象，及其数量）。
jconsole:一个java GUI监视工具，可以以图表化的形式显示各种数据。并可通过远程连接监视远程的服务器VM。

NIO、AIO
多线程
线程池的组成
  1. 线程池管理器：用于创建并管理线程池
  2. 工作线程：线程池中的线程
  3. 任务接口：每个任务必须实现的接口，用于工作线程调度其运行
  4. 任务队列：用于存放待处理的任务，提供一种缓冲机制Java 中的线程池是通过 Executor 框架实现的，该框架中用到了Executor，Executors，ExecutorService，ThreadPoolExecutor ，Callable 和 Future、FutureTask 这几个类。
Java 线程池工作过程

  1. 线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。

  2. 当调用 execute() 方法添加一个任务时，线程池会做如下判断：

    a) 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；
    b) 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列；
    c) 如果这时候队列满了，而且正在运行的线程数量小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；
    d) 如果队列满了，而且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会抛出异常 RejectExecutionException。

  3. 当一个线程完成任务时，它会从队列中取下一个任务来执行。

  4. 当一个线程无事可做，超过一定的时间（keepAliveTime）时，线程池会判断，如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

为什么不推荐使用Executors提供的生成线程池的方法呢？

主要是因为这些线程池都存在内存溢出的可能。其实就是构建线程池的几个参数设置的不好，主要原都是最大线程数量设置为Integer.MAX_VALUE,或者使用无界队列。其实根本原因是对线程池的最线程数量没有做一个限制。

http://wiki.hiwepy.com/docs/interview/interview-1c69i125vov6b

ThreadLocal 作用

ThreadLocal，很多地方叫做线程本地变量，也有些地方叫做线程本地存储，ThreadLocal 的作用是提供线程内的局部变量，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或者组件之间一些公共变量的传递的复杂度。

  1. 每个线程中都有一个自己的 ThreadLocalMap 类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。

  2. 将一个共用的 ThreadLocal 静态实例作为 key，将不同对象的引用保存到不同线程的ThreadLocalMap 中，然后在线程执行的各处通过这个静态 ThreadLocal 实例的 get()方法取得自己线程保存的那个对象，避免了将这个对象作为参数传递的麻烦。

  3. ThreadLocalMap 其实就是线程里面的一个属性，它在 Thread 类中定义 ThreadLocal.ThreadLocalMap threadLocals = null;

synchronized 和 ReentrantLock 的区别

  • 两者的共同点：

    都是用来协调多线程对共享对象、变量的访问

    都是可重入锁，同一线程可以多次获得同一个锁

    都保证了可见性和互斥性

  • 两者的不同点：

    ReentrantLock 显示的获得、释放锁，synchronized 隐式获得释放锁

    ReentrantLock 可响应中断、可轮回，synchronized 是不可以响应中断的，为处理锁的不可用性提供了更高的灵活性

    ReentrantLock 是 API 级别的，synchronized 是 JVM 级别的

    ReentrantLock 可以实现公平锁

    ReentrantLock 通过 Condition 可以绑定多个条件

    底层实现不一样， synchronized 是同步阻塞，使用的是悲观并发策略，lock 是同步非阻塞，采用的是乐观并发策略

    Lock 是一个接口，而 synchronized 是 Java 中的关键字，synchronized 是内置的语言实现。

    synchronized 在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而 Lock 在发生异常时，如果没有主动通过 unLock()去释放锁，则很可能造成死锁现象，因此使用 Lock 时需要在 finally 块中释放锁。

    Lock 可以让等待锁的线程响应中断，而 synchronized 却不行，使用 synchronized 时，等待的线程会一直等待下去，不能够响应中断。

    通过 Lock 可以知道有没有成功获取锁，而 synchronized 却无法办到。

    Lock 可以提高多个线程进行读操作的效率，既就是实现读写锁等。

Netty
什么是 RPC？
  • RPC（Remote Procedure Call）远程过程调用，简单的理解是一个节点请求另一个节点提供的服务
  • 本地过程调用：如果需要将本地student对象的age+1，可以实现一个addAge()方法，将student对象传入，对年龄进行更新之后返回即可，本地方法调用的函数体通过函数指针来指定。
  • 远程过程调用：上述操作的过程中，如果addAge()这个方法在服务端，执行函数的函数体在远程机器上，如何告诉机器需要调用这个方法呢？
  1. 首先客户端需要告诉服务器，需要调用的函数，这里函数和进程ID存在一个映射，客户端远程调用时，需要查一下函数，找到对应的ID，然后执行函数的代码。
  2. 客户端需要把本地参数传给远程函数，本地调用的过程中，直接压栈即可，但是在远程调用过程中不再同一个内存里，无法直接传递函数的参数，因此需要客户端把参数转换成字节流，传给服务端，然后服务端将字节流转换成自身能读取的格式，是一个序列化和反序列化的过程。
  3. 数据准备好了之后，如何进行传输？网络传输层需要把调用的ID和序列化后的参数传给服务端，然后把计算好的结果序列化传给客户端，因此TCP层即可完成上述过程，gRPC中采用的是HTTP2协议。
Dubbo

Dubbo：

简述 Dubbo 的实现原理？

Dubbo 是基于Netty的分布式RPC框架，

三、高级篇（5+年）

2PC 和 3PC 的区别？

两阶段提交主要保证了分布式事务的原子性：即所有结点要么全做要么全不做，所谓的两个阶段是指：第一阶段：准备阶段；第二阶段：提交阶段

  • 准备阶段

事务协调者(事务管理器)给每个参与者(资源管理器)发送 Prepare 消息，每个参与者要么直接返回失败(如权限验证失败)，要么在本地执行事务，写本地的 redo 和 undo 日志，但不提交，到达一种“万事俱备，只欠东风”的状态。

  • 提交阶段

如果协调者收到了参与者的失败消息或者超时，直接给每个参与者发送回滚(Rollback)消息；否则，发送提交(Commit)消息；参与者根据协调者的指令执行提交或者回滚操作，释放所有事务处理过程中使用的锁资源。(注意:必须在最后阶段释放锁资源)

  • 缺点

同步阻塞问题

1、执行过程中，所有参与节点都是事务阻塞型的。

单点故障

2、由于协调者的重要性，一旦协调者发生故障。参与者会一直阻塞下去。

数据不一致（脑裂问题）

3、在二阶段提交的阶段二中，当协调者向参与者发送 commit 请求之后，发生了局部网络异常或者在发送 commit 请求过程中协调者发生了故障，导致只有一部分参与者接受到了commit 请求。于是整个分布式系统便出现了数据部一致性的现象(脑裂现象)。

二阶段无法解决的问题（数据状态不确定）

4、协调者再发出 commit 消息之后宕机，而唯一接收到这条消息的参与者同时也宕机了。那么即使协调者通过选举协议产生了新的协调者，这条事务的状态也是不确定的，没人知道事务是否被已经提交。

三阶段提交（ Three-phase commit ），也叫三阶段提交协议（ Three-phase commit protocol），是二阶段提交（2PC）的改进版本。

与两阶段提交不同的是，三阶段提交有两个改动点。

1、引入超时机制。同时在协调者和参与者中都引入超时机制。
2、在第一阶段和第二阶段中插入一个准备阶段。保证了在最后提交阶段之前各参与节点的状态是一致的。也就是说，除了引入超时机制之外，3PC 把 2PC 的准备阶段再次一分为二，这样三阶段提交就有 CanCommit、PreCommit、DoCommit 三个阶段。

  • CanCommit 阶段

协调者向参与者发送 commit 请求，参与者如果可以提交就返回 Yes 响应，否则返回 No 响应。

  • PreCommit 阶段

协调者根据参与者的反应情况来决定是否可以继续进行，有以下两种可能。假如协调者从所有的参与者获得的反馈都是 Yes 响应，那么就会执行事务的预执行假如有任何一个参与者向协调者发送了 No 响应，或者等待超时之后，协调者都没有接到参与者的响应，那么就执行事务的中断。

  • doCommit 阶段

该阶段进行真正的事务提交，主要包含

1.协调这发送提交请求
2.参与者提交事务
3.参与者响应反馈（ 事务提交完之后，向协调者发送 Ack 响应。）
4.协调者确定完成事务。

柔性事务（TCC） ？

在电商领域等互联网场景下，传统的事务在数据库性能和处理能力上都暴露出了瓶颈。在分布式领域基于 CAP 理论以及 BASE 理论，有人就提出了 柔性事务 的概念。CAP（一致性、可用性、分区容忍性）理论大家都理解很多次了，这里不再叙述。说一下 BASE 理论，它是在 CAP 理论的基础之上的延伸。包括 基本可用（Basically Available）、柔性状态（Soft State）、最终一致性（Eventual Consistency）。

通常所说的柔性事务分为：两阶段型、补偿型、异步确保型、最大努力通知型几种。

  • 两阶段型

1、就是分布式事务两阶段提交，对应技术上的 XA、JTA/JTS。这是分布式环境下事务处理的典型模式。

  • 补偿型

2、TCC 型事务（Try/Confirm/Cancel）可以归为补偿型。

WS-BusinessActivity 提供了一种基于补偿的 long-running 的事务处理模型。服务器 A 发起事务，服务器 B 参与事务，服务器 A 的事务如果执行顺利，那么事务 A 就先行提交，如果事务 B 也执行顺利，则事务 B 也提交，整个事务就算完成。但是如果事务 B 执行失败，事务 B 本身回滚，这时事务 A 已经被提交，所以需要执行一个补偿操作，将已经提交的事务 A 执行的操作作反操作，恢复到未执行前事务 A 的状态。这样的 SAGA 事务模型，是牺牲了一定的隔离性和一致性的，但是
提高了 long-running 事务的可用性。

你用过哪些分布式框架，简要说下原理、优缺点？

框架：Hmily（TCC）、Seata（TCC、XA）、Raincat（2PC）、Myth

分库分表
什么是幂等性？

HTTP/1.1中对幂等性的定义是：一次和多次请求某一个资源对于资源本身应该具有同样的结果（网络超时等问题除外）。也就是说，其任意多次执行对资源本身所产生的影响均与一次执行的影响相同。

什么情况下需要幂等？

业务开发中，经常会遇到重复提交的情况，无论是由于网络问题无法收到请求结果而重新发起请求，或是前端的操作抖动而造成重复提交情况。 在交易系统，支付系统这种重复提交造成的问题有尤其明显，比如：

1.用户在APP上连续点击了多次提交订单，后台应该只产生一个订单；

2.向支付宝发起支付请求，由于网络问题或系统BUG重发，支付宝应该只扣一次钱。 很显然，声明幂等的服务认为，外部调用者会存在多次调用的情况，为了防止外部多次调用对系统数据状态的发生多次改变，将服务设计成幂等。

  • 常见产生原因
  1. 点击提交按钮两次;
  2. 点击刷新按钮;
  3. 使用浏览器后退按钮重复之前的操作，导致重复提交表单;
  4. 使用浏览器历史记录重复提交表单;
  5. 浏览器重复的HTTP请;
  6. nginx重发等情况;
  7. 分布式RPC的try重发等;
Spring Cloud
如何构建微服务，都用到哪些组件？
简述下你的微服务架构，并讲述你是如何进行限流、和防止服务雪崩！
为什么需要限流？

  • 1、与用户打交道的服务

    比如web服务、对外API，这种类型的服务有以下几种可能导致机器被拖垮：

    用户增长过快（这是好事）

    因为某个热点事件（微博热搜）

    竞争对象爬虫

    恶意的刷单

    这些情况都是无法预知的，不知道什么时候会有10倍甚至20倍的流量打进来，如果真碰上这种情况，扩容是根本来不及的（弹性扩容都是虚谈，一秒钟你给我扩一下试试）

  • 2、对内的RPC服务

    一个服务A的接口可能被BCDE多个服务进行调用，在B服务发生突发流量时，直接把A服务给调用挂了，导致A服务对CDE也无法提供服务。 这种情况时有发生，解决方案有两种： 1、每个调用方采用线程池进行资源隔离 2、使用限流手段对每个调用方进行限流

Guava RateLimiter 与 Redis RateLimiter 的区别？

Guava RateLimiter只能应用于单进程，多进程间协同控制便无能为力
Guava RateLimiter能够处理突发请求(预消费)，这里rest接口调用频率限制是固定的，不需要更不能使用预消费能力，否则将会导致接口调用失败

微服务中如何保证数据的一致性？

重放请求，请求过滤

Spring Cloud Alibaba

Nacos：一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。

Sentinel：把流量作为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

RocketMQ：开源的分布式消息系统，基于高可用分布式集群技术，提供低延时的、高可靠的消息发布与订阅服务。

Dubbo：这个就不用多说了，在国内应用非常广泛的一款高性能 Java RPC 框架。

Seata：阿里巴巴开源产品，一个易于使用的高性能微服务分布式事务解决方案。

Arthas：开源的Java动态追踪工具，基于字节码增强技术，功能非常强大。

Alibaba Cloud OSS：阿里云对象存储服务（Object Storage Service，简称 OSS），是阿里云提供的云存储服务。

Alibaba Cloud SchedulerX：阿里中间件团队开发的一款分布式任务调度产品，提供秒级、精准的定时（基于 Cron 表达式）任务调度服务。

XXL-JOB 原理

XXL-JOB 以 服务端调度 + 客户端执行 的模式实现分布式的调度，客户端自动注册工作节点，基于jetty实现简单的RPC服务调用、服务端采用quartz定时调度，客户端执行业务；

分布式服务记得加锁！

分布式锁
分布式缓存

1、Redis

什么是缓存击穿？

数据库里面数据存在，缓存数据因某种原因不存在，导致大量请求到数据库获取数据现象。这种现象有可能会导致数据库connections数耗尽，严重会导致数据库服务停止。

分布式锁解决方案

消息队列
Kafka

简述你的Kafka使用经历和遇到的问题，以及你是如何做的优化？

RabbitMQ、

简述你的RabbitMQ使用经历和遇到的问题，以及你是如何做的优化？

ActiveMQ

简述你的ActiveMQ使用经历和遇到的问题，以及你是如何做的优化？

RocketMQ

简述你的RocketMQ使用经历和遇到的问题，以及你是如何做的优化？

RocketMQ 集群概述

RocketMQ 集群原理

RocketMQ 事务原理

配置中心

Nacos

Zookeeper

Elasticsearch

Java DevOps

Docker、K8s

网络运维（扩展）

QPS、TPS
负载均衡

用户什么负载均衡工具，如何实现高可用？

Internet基本协议（如TCP/IP. HTTP等）
K8s 运维

简述你对K8s的理解是使用经验?

作者：Jeebiz  创建时间：2020-10-16 15:59
 更新时间：2024-10-26 16:27