面向面试编程（一）-阿里云开发者社区

欢迎点击主页查看更多内容....

@Service 和@Component 注解的差别？

@Component spring基础的注解,被spring管理的组件或bean,用于将对象实例化到Spring容器中
而@Service源码中是包含@Component注解的,也就是说service实现component的功能,但service用于服务层,处理业务逻辑

各种 Restful 请求格式以及各种 http 请求返回码。

API,英文全称Application Programming Interface,翻译为“应用程序编程接口”。就是将一些功能（逻辑）封装成组件,目的是提供一个应用程序接口给其它程序与开发人员访问,而这些访问人员不需要访问源码以及理解内部工作原理就可以直接使用
RESTFUL是一种网络应用程序的设计风格和开发方式,基于HTTP,可以使用 XML 格式定义或 JSON 格式定义。最常用的数据格式是JSON。由于JSON能直接被JavaScript读取,所以,使用JSON格式的REST风格的API具有简单、易读、易用的特点。
而http返回状态码常见200.400.500等

@Transactional 事务里的事务隔离级别和事务传播机制概念。

定义一个事务受其他并发事务影响程度。事务并发引发的问题。

脏读：一个事务读取到另一个事务修改但还未提交的数据
不可重复读：一个事务读取数据之后,该数据被其他事务修改,此时第一个事务读取到的事务就是错误的（强调修改）
幻读：一个事务读取了某些数据,没提交再读取时数据多了或者少了,类似幻觉（强调增删）
丢失修改：两个事务都读取了数据,其中一个事务修改之后,另一个事务也做了修改,前者的修改丢失

//可以放在 类上 或者 方法上。 
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {

    /**
     * 区别于 transactionManager属性
     * 查看 transactionManager
     */
    @AliasFor("transactionManager")
    String value() default "";

    /**
     * 选定特定的 事务管理器 SpringBoot中默认不用配置 可以是beanName或者特定的值
     */
    @AliasFor("value")
    String transactionManager() default "";

    /**
     * 设置传播级别
     */
    Propagation propagation() default Propagation.REQUIRED;

    /**
     * 设置事务隔离级别
     */
    Isolation isolation() default Isolation.DEFAULT;

    /**
     * 事务超时
     */
    int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;

    /**
     * 事务只读 默认是可以修改的 如果设置为true只能执行查询相关
     */
    boolean readOnly() default false;

    /**
     * 指定错误回滚 当未抛出该类型的错误或者其子类的错误时 不会回滚 默认是任何错误（异常）都会回滚
     */
    Class<? extends Throwable>[] rollbackFor() default {};

    /**
    * 略 
    */
    String[] rollbackForClassName() default {};

    /**
    * 如果配置这个 如果抛出此异常将不会回滚
    */
    Class<? extends Throwable>[] noRollbackFor() default {};

    /**
    * 略 
    */
    String[] noRollbackForClassName() default {};

}

public enum Isolation {

    /**
     * 使用默认的隔离级别
     * 所有其他级别对应于JDBC隔离级别
     * 具体隔离级别 查看 java.sql.Connection
     * Mysql 默认 RR(REPEATABLE_READ)
     * Oracle 默认 RC(READ_COMMITTED)
     */
    DEFAULT(TransactionDefinition.ISOLATION_DEFAULT),

    /**
     * 未提交读 什么问题都不解决
     * @see java.sql.Connection#TRANSACTION_READ_UNCOMMITTED
     */
    READ_UNCOMMITTED(TransactionDefinition.ISOLATION_READ_UNCOMMITTED),

    /**
     * 提交读 解决脏读
     * @see java.sql.Connection#TRANSACTION_READ_COMMITTED
     */
    READ_COMMITTED(TransactionDefinition.ISOLATION_READ_COMMITTED),

    /**
     * 可重复读 解决脏读和不可重复读 不解决幻读
     */
    REPEATABLE_READ(TransactionDefinition.ISOLATION_REPEATABLE_READ),

    /**
     * 串行读 解决所有的事务隔离问题
     */
    SERIALIZABLE(TransactionDefinition.ISOLATION_SERIALIZABLE);


    private final int value;


    Isolation(int value) {
        this.value = value;
    }

    public int value() {
        return this.value;
    }

}

传播行为

public enum Propagation {

    /**
     * Support a current transaction, create a new one if none exists.
     * Analogous to EJB transaction attribute of the same name.
     * <p>This is the default setting of a transaction annotation.
     * 外围有事务则加入形成同一个事务,外围无事务则新开启,内部事务之间相互独立
     */
    REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),

    /**
     * Support a current transaction, execute non-transactionally if none exists.
     * Analogous to EJB transaction attribute of the same name.
     * <p>Note: For transaction managers with transaction synchronization,
     * {@code SUPPORTS} is slightly different from no transaction at all,
     * as it defines a transaction scope that synchronization will apply for.
     * As a consequence, the same resources (JDBC Connection, Hibernate Session, etc)
     * will be shared for the entire specified scope. Note that this depends on
     * the actual synchronization configuration of the transaction manager.
     * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#setTransactionSynchronization
     * 若外围没有事务则非事务执行,有事务则同 REQUIRED
     */
    SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),

    /**
     * Support a current transaction, throw an exception if none exists.
     * Analogous to EJB transaction attribute of the same name.
     * 使用外围事务,若外围无事务则抛出异常
     */
    MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),

    /**
     * Create a new transaction, and suspend the current transaction if one exists.
     * Analogous to the EJB transaction attribute of the same name.
     * <p><b>NOTE:</b> Actual transaction suspension will not work out-of-the-box
     * on all transaction managers. This in particular applies to
     * {@link org.springframework.transaction.jta.JtaTransactionManager},
     * which requires the {@code javax.transaction.TransactionManager} to be
     * made available to it (which is server-specific in standard Java EE).
     * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager
     * 外围有无事务都开启新事务,相互独立,且与外围事务相互独立开 如果当前有事务,就把当前的事务挂起
     */
    REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),

    /**
     * Execute non-transactionally, suspend the current transaction if one exists.
     * Analogous to EJB transaction attribute of the same name.
     * <p><b>NOTE:</b> Actual transaction suspension will not work out-of-the-box
     * on all transaction managers. This in particular applies to
     * {@link org.springframework.transaction.jta.JtaTransactionManager},
     * which requires the {@code javax.transaction.TransactionManager} to be
     * made available to it (which is server-specific in standard Java EE).
     * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager
     * 非事务执行,若外围存在事务则挂起该事务
     */
    NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),

    /**
     * Execute non-transactionally, throw an exception if a transaction exists.
     * Analogous to EJB transaction attribute of the same name.
     * 非事务执行,当外围有事务则抛出异常
     */
    NEVER(TransactionDefinition.PROPAGATION_NEVER),

    /**
     * Execute within a nested transaction if a current transaction exists,
     * behave like {@code REQUIRED} otherwise. There is no analogous feature in EJB.
     * <p>Note: Actual creation of a nested transaction will only work on specific
     * transaction managers. Out of the box, this only applies to the JDBC
     * DataSourceTransactionManager. Some JTA providers might support nested
     * transactions as well.
     * @see org.springframework.jdbc.datasource.DataSourceTransactionManager
     * 外围无事务,则同 REQUIRED 内部开启新事务相互独立。外围有事务,则内部事务是其子事务,主事务回滚则子事务全部回滚,子事务回滚不影响其他子事务和主事务
     */
    NESTED(TransactionDefinition.PROPAGATION_NESTED);


    private final int value;


    Propagation(int value) {
        this.value = value;
    }

    public int value() {
        return this.value;
    }

}

Spring 依赖注入概念和@Autowired 的用法。

概念：实例不再由程序员实例化,而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类。
依赖注入能够让相互协作的软件组件保持松散耦合
@Autowired 注释,它可以对类成员变量、方法及构造函数进行标注,完成自动装配的工作。 通过 @Autowired的使用来消除 set ,get方法。也可作用与集合上
这里授权服务配置类是继承了AuthorizationServerConfigurerAdapter,而AuthorizationServerConfigurerAdapter又实现了AuthorizationServerConfigurer接口！
源码AuthorizationServerConfigurer
@Autowired对List自动注入
//@Autowired注解用在接口的集合上面,所有实现该接口的实现类都会在该集合中
@Autowired(required = false)
private List<IAsynTask> tasks = Collections.emptyList();

Spring Bean 的生命周期。

Bean 的生命周期概括起来就是 4 个阶段：

实例化（Instantiation）
属性赋值（Populate）
初始化（Initialization）
销毁（Destruction）

Spring Boot 启动流程以及底层源码

索引的数据结构（比如 B+树）

B+Tree
B+Tree相对于B-Tree有几点不同：
非叶子节点只存储键值信息。
所有叶子节点之间都有一个链指针。
数据记录都存放在叶子节点中。
查询速度快,但是占用空间
索引结构：B-Tree B+Tree B：balance
B-Tree：平衡二叉树
特点：
1.具有数据节点
2.指向下层指针
3.指向数据指针
缺页查询,产生IO
B+Tree：
特点:
1.具有数据节点
2.指向下层指针
命中数据3层查找后查询数据指针
加载更快,产生更少IO
效率：BTree更高,但从IO角度,Mysql选择B+Tree

Hash 索引的特点


Hash 索引只能够用于使用 = 或者 <=> 运算符的相等比较(但是速度更快)。Hash 索引不能够用于诸如 < 等
用于查找一个范围值的比较运算符。依赖于这种单值查找的系统被称为 “键-值存储”；对于这种系统,尽可能地使用 hash 索引。
优化器不能够使用 hash 索引来加速 ORDER BY 操作。这种类型的索引不能够用于按照顺序查找下一个条目。
MySql 无法使用 hash 索引估计两个值之间有多少行(这种情况由范围优化器来决定使用哪个索引)。如果你将一张 MyISAM 或 InnoDB 表转换成一个 hash 索引的内存表时,一些查询可能会受此影响。
查找某行记录必须进行全键匹配。而 B-tree 索引,任何该键的左前缀都可用以查找记录

索引是为了加速对表中数据行的检索而创建的一种分散的存储结构
建索引的语句

CREATE INDEX idx_xxx USING BTREE ON tablename (字段,字段,字段);

索引的种类尤其是复合索引以及对应的回表和最左匹配原则

普通索引：最基本的索引,没有任何约束限制。
唯一索引：和普通索引类似,但是具有唯一性约束,可以有 null
主键索引：特殊的唯一索引,不允许有 null,一张表最多一个主键索引
组合索引：多列值组成一个索引,用于组合搜索,效率大于索引合并
全文索引：对文本的内容进行分词、搜索
覆盖索引：查询列要被所建的索引覆盖,不必读取数据行
1、复合索引绑定的第一个列,没有出现在查询条件中;
举例说明：为emp表插入索引idx_age_deptid_name(age,deptid,name),但是在查询条件中未使用age,导致复合索引全部失效。

2、复合索引绑定的多个列是有顺序的,某一个列没有出现在查询条件中,存储引擎不能使用索引中该列及其后的所有列。
举例：为emp表插入索引idx_age_deptid_name(age,deptid,name),查询时查询条件里没有deptid列,会导致复合索引中的deptid及其后的索引失效。

3.查询条件中出现某个列是范围查询的,存储引擎不能使用复合索引中该列其后的所有列。
举例：为emp表插入索引idx_age_deptid_name(age,deptid,name),查询时查询条件里deptid列使用到了范围查询,会导致复合索引中的deptid其后的索引失效。

4.查询条件中某列使用否定条件的（!= <> IS NOT NULL）,存储引擎不能使用索引中该列其后的所有列。
举例：为emp表插入索引idx_age_deptid_name(age,deptid,name),查询时查询条件里deptid列使用到了否定条件,会导致复合索引中的deptid其后的索引失效。

5.查询条件中某列使用LIKE条件后的字段是以%开头的（如：’%ABC’）,存储引擎不能使用索引中该列及其后的所有列。
举例：为emp表插入索引idx_age_deptid_name(age,deptid,name),查询时查询条件里name列使用到了like ‘%a’,会导致复合索引中的name及其后的索引失效。

6.查询条件中某列使用函数的,存储引擎不能使用索引中该列及其后的所有列。
举例：为emp表插入索引idx_age_deptid_name(age,deptid,name),查询时查询条件里name列使用到了like ‘%a’,会导致复合索引中的name及其后的索引失效。

7.查询条件中某列使用类型转换的（包括显示的和隐示的）,存储引擎不能使用索引中该列及其后的所有列。
如：字符串类型的列NAME=3,就是隐示的类型转换,将INT型转换为字符串类型。如果写为NAME=’3’,就不是类型转换。
举例：为emp表插入索引idx_age_deptid_name(age,deptid,name),查询时查询条件name=3,会导致复合索引中的name及其后的索引失效。条件写成name=‘3’,索引就不会失效。

回表

如果索引的列在 select 所需获得的列中（因为在 mysql 中索引是根据索引列的值进行排序的,所以索引节点中存在该列中的部分值）或者根据一次索引查询就能获得记录就不需要回表,如果 select 所需获得列中有大量的非索引列,索引就需要到表中找到相应的列的信息,这就叫回表。
使用聚集索引（主键或第一个唯一索引）就不会回表,普通索引就会回表

索引下推优化,

可以在索引遍历过程中,对索引中包含的字段先做判断,过滤掉不符合条件的记录,减少回表字数。
最左匹配原则
带头大哥不能死,中间兄弟不能断

Spring AOP 底层原理

AOP 底层是采用动态代理机制实现的：接口+实现类

如果要代理的对象,实现了某个接口,那么 Spring AOP 会使用 JDK Proxy,去创建代

理对象。

没有实现接口的对象,就无法使用 JDK Proxy 去进行代理了,这时候 Spring AOP 会使用

Cglib 生成一个被代理对象的子类来作为代理。
就是由代理创建出一个和 impl 实现类平级的一个对象,但是这个对象不是一个真正的对象,
只是一个代理对象,但它可以实现和 impl 相同的功能,这个就是 aop 的横向机制原理,这
样就不需要修改源代码。

HashMap在java1.7之前底层数据结构是数组+链表,1.8之后是数组+链表+红黑树,
在1.7以前的put方法采用的是头插法,当hash碰撞次数到达8,且桶内元素到达64个的时候形成链表,但是在极端情况下会造成链表过长,效率变低,并且在rehash的时候,头插法会造成回环链首尾相连,形成死锁,在java1.8以后采用红黑树,除了添加效率都高,是线程不安全的,不安全示例

public class HashMapTest {

    public static void main(String[] args) {
        HashMapThread thread0 = new HashMapThread();
        HashMapThread thread1 = new HashMapThread();
        HashMapThread thread2 = new HashMapThread();
        HashMapThread thread3 = new HashMapThread();
        HashMapThread thread4 = new HashMapThread();
        thread0.start();
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

class HashMapThread extends Thread {
    private static AtomicInteger ai = new AtomicInteger();
    private static Map<Integer, Integer> map = new HashMap<>();

    @Override
    public void run() {
        while (ai.get() < 1000000) {
            map.put(ai.get(), ai.get());
            ai.incrementAndGet();
        }
    }
}

JDK1.8 之前

JDK1.8 之前 HashMap 底层是数组和链表结合在一起使用也就是链表散列。 ## HashMap 通过 key 的 hashCode 经过扰动函数处理过后得到 hash 值,然后通过 (n -
1) & hash 判断当前元素存放的位置（这里的 n 指的是数组的长度）,如果当前位置存在
元素的话,就判断该元素与要存入的元素的 hash 值以及 key 是否相同,如果相同的话,
直接覆盖,不相同就通过拉链法解决冲突。
所谓扰动函数指的就是 HashMap 的 hash 方法。使用 hash 方法也就是扰动函数是为了
防止一些实现比较差的 hashCode() 方法换句话说使用扰动函数之后可以减少碰撞。

JDK1.8 之后

当链表长度大于阈值（默认为 8）时,会首先调用 treeifyBin()方法。这个方法会根据
HashMap 数组来决定是否转换为红黑树。只有当数组长度大于或者等于 64 的情况下,才会
执行转换红黑树操作,以减少搜索时间。否则,就是只是执行 resize() 方法对数组扩容。

1.通常代替HashMap的安全由HashTable代替,但是多线程下他的put.get方法都是synchronized,效率太低,
2.Collections.synchronizedMap(),底层仍是synchronized
3.java9实现Collections.of()
ConcurrentHashMap 与 ConcurrentSkipListMap
ConcurrentHashMap 加锁
ConcurrentSkipListMap 不需要加锁,浪费空间,
4.ConcurrentHashMap
ConcurrentHashMap如何保证线程安全,在1.7以前由划分segment分段锁机制,共计16个并发级别,隔离级别太大,有很多空间就浪费了,太小就段内的元素过多
1.8以后是cas算法C语言写得,无锁算法,put添加的时候,链表+红黑树
put方法（无锁添加）

3、HashMap 的扩容机制是怎样的？

一般情况下,当元素数量超过阈值时便会触发扩容。每次扩容的容量都是之前容量的 2 倍。
HashMap 的容量是有上限的,必须小于 1<<30,即 1073741824。如果容量超出了这个
数,则不再增长,且阈值会被设置为 Integer.MAX_VALUE。
JDK7 中的扩容机制
空参数的构造函数：以默认容量、默认负载因子、默认阈值初始化数组。内部数组是空数
组。
有参构造函数：根据参数确定容量、负载因子、阈值等。
第一次 put 时会初始化数组,其容量变为不小于指定容量的 2 的幂数,然后根据负载因子
确定阈值。
如果不是第一次扩容,则新容量=旧容量 x 2 ,新阈值=新容量 x 负载因子。
JDK8 的扩容机制
空参数的构造函数：实例化的 HashMap 默认内部数组是 null,即没有实例化。第一次调
用 put 方法时,则会开始第一次初始化扩容,长度为 16。 ## 有参构造函数：用于指定容量。会根据指定的正整数找到不小于指定容量的 2 的幂数,将
这个数设置赋值给阈值（threshold）。第一次调用 put 方法时,会将阈值赋值给容量,
然后让阈值 = 容量 x 负载因子。 ## 如果不是第一次扩容,则容量变为原来的 2 倍,阈值也变为原来的 2 倍。（容量和阈值都
变为原来的 2 倍时,负载因子还是不变）。
此外还有几个细节需要注意：
首次 put 时,先会触发扩容（算是初始化）,然后存入数据,然后判断是否需要扩容；
不是首次 put,则不再初始化,直接存入数据,然后判断是否需要扩容；

4、ConcurrentHashMap 的存储结构是怎样的？

Java7 中 ConcurrnetHashMap 使用的分段锁,也就是每一个 Segment 上同时只有一个
线程可以操作,每一个 Segment 都是一个类似 HashMap 数组的结构,它可以扩容,它
的冲突会转化为链表。但是 Segment 的个数一但初始化就不能改变,默认 Segment 的
个数是 16 个。
Java8 中的 ConcurrnetHashMap 使用的 Synchronized 锁加 CAS 的机制。结构也由
Java7 中的 Segment 数组 + HashEntry 数组 + 链表进化成了 Node 数组 + 链表 / 红
黑树,Node 是类似于一个 HashEntry 的结构。它的冲突再达到一定大小时会转化成红
黑树,在冲突小于一定数量时又退回链表。

5、线程池大小如何设置？

CPU 密集型任务(N+1)：这种任务消耗的主要是 CPU 资源,可以将线程数设置为 N （CPU 核心数）+1,比 CPU 核心数多出来的一个线程是为了防止线程偶发的缺页中断,
或者其它原因导致的任务暂停而带来的影响。一旦任务暂停,CPU 就会处于空闲状态,而
在这种情况下多出来的一个线程就可以充分利用 CPU 的空闲时间。
I/O 密集型任务(2N)：这种任务应用起来,系统会用大部分的时间来处理 I/O 交互,而
线程在处理 I/O 的时间段内不会占用 CPU 来处理,这时就可以将 CPU 交出给其它线程
使用。因此在 I/O 密集型任务的应用中,我们可以多配置一些线程,具体的计算方法是
2N。

如何判断是 CPU 密集任务还是 IO 密集任务？

CPU 密集型简单理解就是利用 CPU 计算能力的任务比如你在内存中对大量数据进行排序。单
凡涉及到网络读取,文件读取这类都是 IO 密集型,这类任务的特点是 CPU 计算耗费时间相
比于等待 IO 操作完成的时间来说很少,大部分时间都花在了等待 IO 操作完成上。
6、IO 密集=Ncpu*2 是怎么计算出来？

I/O 密集型任务任务应用起来,系统会用大部分的时间来处理 I/O 交互,而线程在处理
I/O 的时间段内不会占用 CPU 来处理,这时就可以将 CPU 交出给其它线程使用。因此在
I/O 密集型任务的应用中,我们可以多配置一些线程。例如：数据库交互,文件上传下
载,网络传输等。IO 密集型,即该任务需要大量的 IO,即大量的阻塞,故需要多配置线
程数。

7、G1 收集器有哪些特点？

G1 的全称是 Garbage-First,意为垃圾优先,哪一块的垃圾最多就优先清理它。
G1 GC 最主要的设计目标是：将 STW 停顿的时间和分布,变成可预期且可配置的。
被视为 JDK1.7 中 HotSpot 虚拟机的一个重要进化特征。它具备一下特点：
并行与并发：G1 能充分利用 CPU、多核环境下的硬件优势,使用多个 CPU（CPU 或者
CPU 核心）来缩短 Stop-The-World 停顿时间。部分其他收集器原本需要停顿 Java 线程
执行的 GC 动作,G1 收集器仍然可以通过并发的方式让 java 程序继续执行。

分代收集：虽然 G1 可以不需要其他收集器配合就能独立管理整个 GC 堆,但是还是保留

了分代的概念。
空间整合：与 CMS 的“标记-清理”算法不同,G1 从整体来看是基于“标记-整理”算法
实现的收集器；从局部上来看是基于“标记-复制”算法实现的。
可预测的停顿：这是 G1 相对于 CMS 的另一个大优势,降低停顿时间是 G1 和 CMS 共
同的关注点,但 G1 除了追求低停顿外,还能建立可预测的停顿时间模型,能让使用者明
确指定在一个长度为 M 毫秒的时间片段内。
G1 收集器在后台维护了一个优先列表,每次根据允许的收集时间,优先选择回收价值最大的
Region（这也就是它的名字 Garbage-First 的由来）

8、你有哪些手段来排查 OOM 的问题？

增加两个参数 -XX:+HeapDumpOnOutOfMemoryError -
XX:HeapDumpPath=/tmp/heapdump.hprof,当 OOM 发生时自动 dump 堆内存信
息到指定目录。
同时 jstat 查看监控 JVM 的内存和 GC 情况,先观察问题大概出在什么区域。
使用 MAT 工具载入到 dump 文件,分析大对象的占用情况,比如 HashMap 做缓存未
清理,时间长了就会内存溢出,可以把改为弱引用。

9、请你谈谈 MySQL 事务隔离级别,MySQL 的默认隔离级别是什么？

为了达到事务的四大特性,数据库定义了 4 种不同的事务隔离级别：
READ-UNCOMMITTED（读取未提交）：最低的隔离级别,允许脏读,也就是可能读取
到其他会话中未提交事务修改的数据,可能会导致脏读、幻读或不可重复读。
READ-COMMITTED（读取已提交）：只能读取到已经提交的数据。Oracle 等多数数据
库默认都是该级别（不重复读）,可以阻止脏读,但是幻读或不可重复读仍有可能发生。
REPEATABLE-READ（可重复读）：对同一字段的多次读取结果都是一致的,除非数据是
被本身事务自己所修改,可以阻止脏读和不可重复读,但幻读仍有可能发生。
SERIALIZABLE（可串行化）：最高的隔离级别,完全服从 ACID 的隔离级别。所有的事
务依次逐个执行,这样事务之间就完全不可能产生干扰,也就是说,该级别可以防止脏
读、不可重复读以及幻读。
MySQL 默认采用的 REPEATABLE_READ 隔离级别。
## 可重复读解决了哪些问题？
可重复读的核心就是一致性读(consistent read);保证多次读取同一个数据时,其值都和事
务开始时候的内容是一致,禁止读取到别的事务未提交的数据,会造成幻读。
而事务更新数据的时候,只能用当前读。如果当前的记录的行锁被其他事务占用的话,就
需要进入锁等待。
32
查询只承认在事务启动前就已经提交完成的数据。
可重复读解决的是重复读的问题,可重复读在快照读的情况下是不会有幻读,但当前读的
时候会有幻读。

11、对 SQL 慢查询会考虑哪些优化？

分析语句,是否加载了不必要的字段/数据。
分析 SQL 执行计划（explain extended）,思考可能的优化点,是否命中索引等。
查看 SQL 涉及的表结构和索引信息。
如果 SQL 很复杂,优化 SQL 结构。
按照可能的优化点执行表结构变更、增加索引、SQL 改写等操作。
查看优化后的执行时间和执行计划。
如果表数据量太大,考虑分表。
利用缓存,减少查询次数

12、谈一谈缓存穿透、缓存击穿和缓存雪崩,以及解决办法？

缓存穿透
问题：大量并发查询不存在的 KEY,在缓存和数据库中都不存在,同时给缓存和数据库带
来压力。
原因：一般而言,缓存穿透有 2 种可能性：业务数据被误删,导致缓存和数据库中都没有
数据。恶意进行 ddos 攻击。
分析：为什么会多次透传呢？不存在一直为空,需要注意让缓存能够区分 KEY 不存在和
查询到一个空值。
解决办法：缓存空值的 KEY,这样第一次不存在也会被加载会记录,下次拿到有这个
KEY。Bloom 过滤或 RoaingBitmap 判断 KEY 是否存在,如果布隆过滤器中没有查到这
个数据,就不去数据库中查。在处理请求前增加恶意请求检查,如果检测到是恶意攻击,
则拒绝进行服务。完全以缓存为准,使用延迟异步加载的策略（异步线程负责维护缓存的
数据,定期或根据条件触发更新）,这样就不会触发更新。
缓存击穿
问题：某个 KEY 失效的时候,正好有大量并发请求访问这个 KEY。分析：跟穿透其实很像,属于比较偶然的。
解决办法：KEY 的更新操作添加全局互斥锁。完全以缓存为准,使用延迟异步加载的策略
（异步线程负责维护缓存的数据,定期或根据条件触发更新）,这样就不会触发更新。
缓存雪崩
问题：当某一时刻发生大规模的缓存失效的情况,导致大量的请求无法获取数据,从而将
流量压力传导到数据库上,导致数据库压力过大甚至宕机。
原因：一般而言,缓存雪崩有 2 种可能性：大量的数据同一个时间失效：比如业务关系强
相关的数据要求同时失效 Redis 宕机
分析：一般来说,由于更新策略、或者数据热点、缓存服务宕机等原因,可能会导致缓存
数据同一个时间点大规模不可用,或者都更新。所以,需要我们的更新策略要在时间上合
适,数据要均匀分享,缓存服务器要多台高可用。
解决办法：更新策略在时间上做到比较平均。如果数据需要同一时间失效,可以给这批数
据加上一些随机值,使得这批数据不要在同一个时间过期,降低数据库的压力。使用的热
数据尽量分散到不同的机器上。多台机器做主从复制或者多副本,实现高可用。做好主从
的部署,当主节点挂掉后,能快速的使用从结点顶上。实现熔断限流机制,对系统进行负
载能力控制。对于非核心功能的业务,拒绝其请求,只允许核心功能业务访问数据库获取
数据。服务降价：提供默认返回值,或简单的提示信息。

13、LRU 是什么？如何实现？

最近最少使用策略 LRU（Least Recently Used）是一种缓存淘汰算法,是一种缓存淘汰机
制。
使用双向链表实现的队列,队列的最大容量为缓存的大小。在使用过程中,把最近使用的
页面移动到队列头,最近没有使用的页面将被放在队列尾的位置
使用一个哈希表,把页号作为键,把缓存在队列中的节点的地址作为值,只需要把这个页
对应的节点移动到队列的前面,如果需要的页面在内存中,此时需要把这个页面加载到内
存中,简单的说,就是将一个新节点添加到队列前面,并在哈希表中跟新相应的节点地
址,如果队列是满的,那么就从队尾移除一个节点,并将新节点添加到队列的前面。

14、什么是堆内存？参数如何设置？

堆内存是指由程序代码自由分配的内存,与栈内存作区分。
在 Java 中,堆内存主要用于分配对象的存储空间,只要拿到对象引用,所有线程都可
以访问堆内存。
-Xmx, 指定最大堆内存。如 -Xmx4g. 这只是限制了 Heap 部分的最大值为 4g。这个内
存不包括栈内存,也不包括堆外使用的内存。
-Xms, 指定堆内存空间的初始大小。如 -Xms4g。而且指定的内存大小,并不是操作系
统实际分配的初始值,而是 GC 先规划好,用到才分配。专用服务器上需要保持 –Xms
和 –Xmx 一致,否则应用刚启动可能就有好几个 FullGC。当两者配置不一致时,堆内存
扩容可能会导致性能抖动。
34
-Xmn, 等价于 -XX:NewSize,使用 G1 垃圾收集器不应该设置该选项,在其他的某些业
务场景下可以设置。官方建议设置为 -Xmx 的 1/2 ~ 1/4.
-XX：MaxPermSize=size, 这是 JDK1.7 之前使用的。Java8 默认允许的 Meta 空间无限
大,此参数无效。
-XX：MaxMetaspaceSize=size, Java8 默认不限制 Meta 空间, 一般不允许设置该选
项。
-XX：MaxDirectMemorySize=size,系统可以使用的最大堆外内存,这个参数跟 -
Dsun.nio.MaxDirectMemorySize 效果相同。
-Xss, 设置每个线程栈的字节数。例如 -Xss1m 指定线程栈为 1MB,与-
XX:ThreadStackSize=1m 等价

15、栈和队列,举个使用场景例子？

栈（后进先出）可以用于字符匹配,数据反转等场景
队列（先进先出）可以用于任务队列,共享打印机等场景

16、MySQL 为什么 InnoDB 是默认引擎？

MyISAM与InnoDB 的区别（9个不同点）
区别：

InnoDB支持事务,MyISAM不支持,对于InnoDB每一条SQL语言都默认封装成事务,自动提交,这样会影响速度,所以最好把多条SQL语言放在begin和commit之间,组成一个事务；
InnoDB支持外键,而MyISAM不支持。对一个包含外键的InnoDB表转为MYISAM会失败；
InnoDB是聚集索引,使用B+Tree作为索引结构,数据文件是和（主键）索引绑在一起的（表数据文件本身就是按B+Tree组织的一个索引结构）,必须要有主键,通过主键索引效率很高。但是辅助索引需要两次查询,先查询到主键,然后再通过主键查询到数据。因此,主键不应该过大,因为主键太大,其他索引也都会很大。
MyISAM是非聚集索引,也是使用B+Tree作为索引结构,索引和数据文件是分离的,索引保存的是数据文件的指针。主键索引和辅助索引是独立的。
也就是说：InnoDB的B+树主键索引的叶子节点就是数据文件,辅助索引的叶子节点是主键的值；而MyISAM的B+树主键索引和辅助索引的叶子节点都是数据文件的地址指针。
InnoDB不保存表的具体行数,执行select count(*) from table时需要全表扫描。而MyISAM用一个变量保存了整个表的行数,执行上述语句时只需要读出该变量即可,速度很快（注意不能加有任何WHERE条件）；

那么为什么InnoDB没有了这个变量呢？

因为InnoDB的事务特性,在同一时刻表中的行数对于不同的事务而言是不一样的,因此count统计会计算对于当前事务而言可以统计到的行数,而不是将总行数储存起来方便快速查询。InnoDB会尝试遍历一个尽可能小的索引除非优化器提示使用别的索引。如果二级索引不存在,InnoDB还会尝试去遍历其他聚簇索引。
如果索引并没有完全处于InnoDB维护的缓冲区（Buffer Pool）中,count操作会比较费时。可以建立一个记录总行数的表并让你的程序在INSERT/DELETE时更新对应的数据。和上面提到的问题一样,如果此时存在多个事务的话这种方案也不太好用。如果得到大致的行数值已经足够满足需求可以尝试SHOW TABLE STATUS

Innodb不支持全文索引,而MyISAM支持全文索引,在涉及全文索引领域的查询效率上MyISAM速度更快高；PS：5.7以后的InnoDB支持全文索引了
MyISAM表格可以被压缩后进行查询操作
InnoDB支持表、行(默认)级锁,而MyISAM支持表级锁
InnoDB的行锁是实现在索引上的,而不是锁在物理行记录上。潜台词是,如果访问没有命中索引,也无法使用行锁,将要退化为表锁。

例如：

t_user(uid, uname, age, sex) innodb;

uid PK
无其他索引
update t_user set age=10 where uid=1;             命中索引,行锁。

update t_user set age=10 where uid != 1;           未命中索引,表锁。

update t_user set age=10 where name='chackca';    无索引,表锁。

8、InnoDB表必须有唯一索引（如主键）（用户没有指定的话会自己找/生产一个隐藏列Row_id来充当默认主键）,而Myisam可以没有

9、Innodb存储文件有frm、ibd,而Myisam是frm、MYD、MYI

    Innodb：frm是表定义文件,ibd是数据文件

    Myisam：frm是表定义文件,myd是数据文件,myi是索引文件

如何选择：

1. 是否要支持事务,如果要请选择innodb,如果不需要可以考虑MyISAM；

2. 如果表中绝大多数都只是读查询,可以考虑MyISAM,如果既有读也有写,请使用InnoDB。

3. 系统奔溃后,MyISAM恢复起来更困难,能否接受；

4. MySQL5.5版本开始Innodb已经成为Mysql的默认引擎(之前是MyISAM),说明其优势是有目共睹的,如果你不知道用什么,那就用InnoDB,至少不会差。

InnoDB为什么推荐使用自增ID作为主键？

答：自增ID可以保证每次插入时B+索引是从右边扩展的,可以避免B+树和频繁合并和分裂（对比使用UUID）。如果使用字符串主键和随机主键,会使得数据随机插入,效率比较差。

innodb引擎的4大特性

   插入缓冲（insert buffer),二次写(double write),自适应哈希索引(ahi),预读(read ahead)

19、MVCC 是什么？它的底层原理是什么？

MVCC,多版本并发控制,它是通过读取历史版本的数据,来降低并发事务冲突,从而提高并
发性能的一种机制。
事务版本号
表的隐藏列
undo log
read view

20、undo log 具体怎么回滚事务？

举个例子：
对于 insert 类型的 sql,会在 undo log 中记录下方才你 insert 进来的数据的 ID,当你想
roll back 时,根据 ID 完成精准的删除。
对于 delete 类型的 sql,会在 undo log 中记录方才你删除的数据,当你回滚时会将删除
前的数据 insert 进去。
对于 update 类型的 sql,会在 undo log 中记录下修改前的数据,回滚时只需要反向
update 即可。
对于 select 类型的 sql,别费心了,select 不需要回滚。

22、索引失效的情况有哪些？

like 以%开头索引无效,当 like 以&结尾,索引有效。
or 语句前后没有同事使用索引,当且仅当 or 语句查询条件的前后列均为索引时,索引生
效。
组合索引,使用的不是第一列索引时候,索引失效,即最左匹配规则。
数据类型出现隐式转换,如 varchar 不加单引号的时候可能会自动转换为 int 类型,这个
时候索引失效。
在索引列上使用 IS NULL 或者 IS NOT NULL 时候,索引失效,因为索引是不索引空值
得。
在索引字段上使用,NOT、 <>、！= 、时候是不会使用索引的,对于这样的处理只会进
行全表扫描。
对索引字段进行计算操作,函数操作时不会使用索引。
当全表扫描速度比索引速度快的时候不会使用索引。
索引失效场景一：带头大哥不能死,中间兄弟不能断

索引失效场景二：在索引列上做操作

索引失效场景三：范围条件右边全失效

索引低效场景四：select * 会降低索引的效率

索引失效场景五：使用!=或<>会导致索引失效

索引失效场景六、isnull和is not null字段无法使用索引

索引失效场景七、%like%查询时的索引失效问题

索引失效场景八、字符串不加单引号索引失效

索引失效场景九、少用or,用or连接索引会失效

Spring Bean 容器的生命周期是什么样的？

Bean 容器找到配置文件中 Spring Bean 的定义。
Bean 容器利用 Java Reflection API 创建一个 Bean 的实例。
如果涉及到一些属性值利用 set()方法设置一些属性值。
如果 Bean 实现了 BeanNameAware 接口,调用 setBeanName()方法,传入 Bean 的名
字。
如果 Bean 实现了 BeanClassLoaderAware 接口,调用 setBeanClassLoader()方法,传
入 ClassLoader 对象的实例。
如果 Bean 实现了 BeanFactoryAware 接口,调用 setBeanFactory()方法,传入
BeanFactory 对象的实例。
与上面的类似,如果实现了其他 *.Aware 接口,就调用相应的方法。
如果有和加载这个 Bean 的 Spring 容器相关的 BeanPostProcessor 对象,执行
postProcessBeforeInitialization() 方法
39
如果 Bean 实现了 InitializingBean 接口,执行 afterPropertiesSet()方法。
如果 Bean 在配置文件中的定义包含 init-method 属性,执行指定的方法。
如果有和加载这个 Bean 的 Spring 容器相关的 BeanPostProcessor 对象,执行
postProcessAfterInitialization() 方法
当要销毁 Bean 的时候,如果 Bean 实现了 DisposableBean 接口,执行 destroy() 方
法。
当要销毁 Bean 的时候,如果 Bean 在配置文件中的定义包含 destroy-method 属性,执
行指定的方法。

Redis 数据结构压缩列表和跳跃表的区别

压缩列表（ziplist）本质上就是一个字节数组,是 Redis 为了节约内存而设计的一种线性
数据结构,可以包含多个元素,每个元素可以是一个字节数组或一个整数。
跳跃表（skiplist）是一种有序数据结构,它通过在每个节点中维持多个指向其他节点的指
针,从而达到快速访问节点的目的。跳跃表支持平均 O（logN）、最坏 O（N）复杂度的
节点查找,还可以通过顺序性操作来批量处理节点

1.redis的hash怎么实现的？(实现原理)rehash过程

redis初始创建hash表,有序集合,链表时, 存储结构采用一种ziplist的存储结构, 这种结构内存排列更紧密, 能提高访存性能.
hash_max_ziplist_entries和hash_max_ziplist_value值作为阀值,hash_max_ziplist_entries表示一旦ziplist中元素数量超过该值,则需要转换为dict结构；hash_max_ziplist_value表示一旦ziplist中数据长度大于该值,则需要转换为dict结构。
哈希等价于Java语言的HashMap或者是Python语言的字典（Dict）
redis hash 的内部结构.第一维是数组,第二维是链表.组成一个 hashtable.
在 Java 中 HashMap 扩容是个很耗时的操作,需要去申请新的数组,为了追求高性能,Redis 采用了渐进式 rehash 策略.这也是 hash 中最重要的部分.
在扩容的时候 rehash 策略会保留新旧两个 hashtable 结构,查询时也会同时查询两个 hashtable.Redis会将旧 hashtable 中的内容一点一点的迁移到新的 hashtable 中,当迁移完成时,就会用新的 hashtable 取代之前的.当 hashtable 移除了最后一个元素之后,这个数据结构将会被删除.
https://juejin.im/post/5cfe6383e51d45599e019d8f
与java的hashmap的rehash区别
个人理解：hashmap的rehash是一次性拷贝的,不同的是,Redis的字典只能是字符串,另外他们rehash的方式不一样,因为Java的HashMap的字典很大时,rehash是个耗时的操作,需要一次全部rehash。Redis为了追求高性能,不能堵塞服务,所以采用了渐进式rehash策略。
rehash的详细步骤
https://www.cnblogs.com/meituantech/p/9376472.html
与ConcurrentHashMap扩容的策略比较？
ConcurrentHashMap采用的扩容策略为： “多线程协同式rehash“。
1.扩容所花费的时间对比：一个单线程渐进扩容,一个多线程协同扩容。在平均的情况下,是ConcurrentHashMap 快。这也意味着,扩容时所需要花费的空间能够更快的进行释放。
2.读操作,两者性能相差不多。
3.写操作,Redis的字典返回更快些,因为它不像ConcurrentHashMap那样去帮着扩容(当要写的桶位已经搬到了newTable时),等扩容完才能进行操作。
4.删除操作,与写一样。
http://xytschool.com/resource/236.html

面向面试编程（一）

@Service 和@Component 注解的差别？

各种 Restful 请求格式以及各种 http 请求返回码。

@Transactional 事务里的事务隔离级别和事务传播机制概念。

传播行为

Spring 依赖注入概念和@Autowired 的用法。

Spring Bean 的生命周期。

Spring Boot 启动流程以及底层源码

索引的数据结构（比如 B+树）

回表

索引下推优化,

Spring AOP 底层原理

如果要代理的对象,实现了某个接口,那么 Spring AOP 会使用 JDK Proxy,去创建代

没有实现接口的对象,就无法使用 JDK Proxy 去进行代理了,这时候 Spring AOP 会使用

JDK1.8 之前

JDK1.8 之后

3、HashMap 的扩容机制是怎样的？

4、ConcurrentHashMap 的存储结构是怎样的？

5、线程池大小如何设置？

如何判断是 CPU 密集任务还是 IO 密集任务？

7、G1 收集器有哪些特点？

分代收集：虽然 G1 可以不需要其他收集器配合就能独立管理整个 GC 堆,但是还是保留

8、你有哪些手段来排查 OOM 的问题？

9、请你谈谈 MySQL 事务隔离级别,MySQL 的默认隔离级别是什么？

11、对 SQL 慢查询会考虑哪些优化？

12、谈一谈缓存穿透、缓存击穿和缓存雪崩,以及解决办法？

13、LRU 是什么？如何实现？

14、什么是堆内存？参数如何设置？

15、栈和队列,举个使用场景例子？

16、MySQL 为什么 InnoDB 是默认引擎？

19、MVCC 是什么？它的底层原理是什么？

20、undo log 具体怎么回滚事务？

22、索引失效的情况有哪些？

Spring Bean 容器的生命周期是什么样的？

Redis 数据结构压缩列表和跳跃表的区别

1.redis的hash怎么实现的？(实现原理)rehash过程

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

面向面试编程（一）

@Service 和@Component 注解的差别？

各种 Restful 请求格式以及各种 http 请求返回码。

@Transactional 事务里的事务隔离级别和事务传播机制概念。

传播行为

Spring 依赖注入概念和@Autowired 的用法。

Spring Bean 的生命周期。

Spring Boot 启动流程以及底层源码

索引的数据结构（比如 B+树）

回表

索引下推优化,

Spring AOP 底层原理

如果要代理的对象,实现了某个接口,那么 Spring AOP 会使用 JDK Proxy,去创建代

没有实现接口的对象,就无法使用 JDK Proxy 去进行代理了,这时候 Spring AOP 会使用

JDK1.8 之前

JDK1.8 之后

3、HashMap 的扩容机制是怎样的？

4、ConcurrentHashMap 的存储结构是怎样的？

5、线程池大小如何设置？

如何判断是 CPU 密集任务还是 IO 密集任务？

7、G1 收集器有哪些特点？

分代收集：虽然 G1 可以不需要其他收集器配合就能独立管理整个 GC 堆,但是还是保留

8、你有哪些手段来排查 OOM 的问题？

9、请你谈谈 MySQL 事务隔离级别,MySQL 的默认隔离级别是什么？

11、对 SQL 慢查询会考虑哪些优化 ？

12、谈一谈缓存穿透、缓存击穿和缓存雪崩,以及解决办法？

13、LRU 是什么？如何实现？

14、什么是堆内存？参数如何设置？

15、栈和队列,举个使用场景例子？

16、MySQL 为什么 InnoDB 是默认引擎？

19、MVCC 是什么？它的底层原理是什么？

20、undo log 具体怎么回滚事务 ？

22、索引失效的情况有哪些？

Spring Bean 容器的生命周期是什么样的？

Redis 数据结构 压缩列表和跳跃表的区别

1.redis的hash怎么实现的？(实现原理)rehash过程

热门文章

最新文章

相关课程

相关电子书

11、对 SQL 慢查询会考虑哪些优化？

20、undo log 具体怎么回滚事务？

Redis 数据结构压缩列表和跳跃表的区别