# 线程池的核心参数有哪些？它们之间的关系是什么？（转载）

一、corePoolSize 线程池核心线程大小

   `线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会被销毁，除非设置了allowCoreThreadTimeOut。这里的最小线程数量即是corePoolSize。任务提交到线程池后，首先会检查当前线程数是否达到了corePoolSize，如果没有达到的话，则会创建一个新线程来处理这个任务`

二、maximumPoolSize 线程池最大线程数量

`  当前线程数达到corePoolSize后，如果继续有任务被提交到线程池，会将任务缓存到工作队列（后面会介绍）中。如果队列也已满，则会去创建一个新线程来出来这个处理。线程池不会无限制的去创建新线程，它会有一个最大线程数量的限制，这个数量即由maximunPoolSize指定。  `

三、keepAliveTime 空闲线程存活时间

`  一个线程如果处于空闲状态，并且当前的线程数量大于corePoolSize，那么在指定时间后，这个空闲线程会被销毁，这里的指定时间由keepAliveTime来设定  `

四、unit 空闲线程存活时间单位

    keepAliveTime 的单位（如秒、毫秒）。

五、workQueue 工作队列

``` 
新任务被提交后，会先进入到此工作队列中，任务调度时再从队列中取出任务。jdk中提供了四种工作队列：
①ArrayBlockingQueue
基于数组的有界阻塞队列，按FIFO排序。新任务进来后，会放到该队列的队尾，有界的数组可以防止资源耗尽问题。当线程池中线程数量达到corePoolSize后，再有新任务进来，则会将任务放入该队列的队尾，等待被调度。如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略。
②LinkedBlockingQueue
基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。由于该队列的近似无界性，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列，而基本不会去创建新线程直到maxPoolSize（很难达到Interger.MAX这个数），因此使用该工作队列时，参数maxPoolSize其实是不起作用的。
③SynchronousQueue
一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。
④PriorityBlockingQueue
具有优先级的无界阻塞队列，优先级通过参数Comparator实现。

```

六、threadFactory 线程工厂

`创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程等等`

七、handler 拒绝策略
    
    `当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来，该如何处理呢。这里的拒绝策略，就是解决这个问题的，jdk中提供了4中拒绝策略`

原文链接：https://blog.csdn.net/ye17186/article/details/89467919

#  线程池常见的拒绝策略有哪些？

①CallerRunsPolicy

该策略下，在调用者线程中直接执行被拒绝任务的run方法，除非线程池已经shutdown，则直接抛弃任务。

②AbortPolicy

该策略下，直接丢弃任务，并抛出RejectedExecutionException异常。

③DiscardPolicy

该策略下，直接丢弃任务，什么都不做。

④DiscardOldestPolicy

该策略下，抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列

# HashMap 底层实现

在 JDK1.8 之前，HashMap 的底层是数组 + 链表；JDK1.8 对其进行了重大优化，升级为数组 + 链表 + 红黑树的混合结构，彻底解决了链表过长导致查询效率退化的问题，我们重点讲解 JDK1.8 及以后的实现。



面试八股汇总

## 1.互斥锁解决缓存击穿问题（setnx简单实践）




数据一致性高，并发能力弱

![image.png](/static/img/8481a20b40b2a9c5b22c079fb25e6702.image.webp)

代码实践

```java
    /**
     * 加redis分布式锁
     * @param key
     * @return
     */
    private boolean tryLock(String key){
        Boolean status = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10L, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(status);
    }

    /**
     * 释放redis分布式锁
     * @param key
     */
    private void unlock(String key){
        stringRedisTemplate.delete(key);
    }
```


```java
    /**
     *  互斥锁解决缓存击穿
     * @param id
     * @return
     */
    private Shop queryWithMutex(Long id) {
        String lockKey = RedisConstants.LOCK_SHOP_KEY+id;
        Shop shop = null;
        // 查询redis是否有数据
        String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        // 判断是否存在
        if (StrUtil.isNotBlank(shopJson)){
            // 获取shop对象
            // 直接返回商铺信息
            return JSONUtil.toBean(shopJson, Shop.class);
        }
        try {
            // 缓存未命中获取互斥锁
            // 互斥锁获取成功
            boolean isLock = tryLock(lockKey);
            if (!isLock){
                // 互斥锁获取失败休眠并重试
                Thread.sleep(50);
                return queryWithMutex(id);
            }
            // 不存在查询数据库
            shop = getById(id);
            if (shop == null){
                // 存储空值避免缓存穿透
                stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, "", RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
                return null;
            }
            // 写入redis
            stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop),RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            // 释放锁
            unlock(lockKey);
        }
        // 返回店铺信息
        return shop;
    }
```

## 2.逻辑过期解决缓存击穿

数据一致性低，并发能力强

![image.png](/static/img/a743a0288d54cdd75fc05cfb02b160aa.image.webp)


```java
/**
     * reids逻辑过期方案
     * @param id
     * @return
     */
    public Shop queryWithLogicalExpire( Long id){
        // 查询redis是否有数据
        String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        // 判断是否存在
        if (StrUtil.isBlank(shopJson)){
            // 未命中缓存直接返回空
            return null;
        }
        // 命中需要将json反序列化为对象
        RedisData bean = JSONUtil.toBean(shopJson, RedisData.class);
        Shop shop = JSONUtil.toBean((JSONObject) bean.getData(), Shop.class);
        LocalDateTime expireTime = bean.getExpireTime();
        // 判断是否过期
        if (expireTime.isAfter(LocalDateTime.now())){
            // 未过期
            return shop;
        }
        // 已过期开启缓存重建

        // 获取互斥锁
        String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
        boolean isLock = tryLock(lockKey);
        if (isLock){
            // 获取锁成功开启独立线程缓存重建
            CACHE_REBUID_EXECUTOR.submit(()->{
                try {
//                重建缓存
                    this.saveShop2Redis(id,20L);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }finally {
                    // 释放锁
                    unlock(lockKey);
                }
            });
        }
        // 返回旧数据
        return shop;
    }

```

## 3.商品秒杀业务

代码实践

```java
/**
     * 优惠券秒杀实现
     *
     * @param voucherId
     * @return
     */
    @Override
    public Result seckillVoucher(Long voucherId) {
        // 查询优惠券
        SeckillVoucher seckillVoucher = seckillVoucherService.getById(voucherId);
        // 判断是否开始秒杀
        if (seckillVoucher.getBeginTime().isAfter(LocalDateTime.now())){
            return Result.fail("优惠券秒杀尚未开始");
        }
        // 判断秒杀是否结束
        if (seckillVoucher.getEndTime().isBefore(LocalDateTime.now())){
            return Result.fail("优惠券秒杀已经结束");
        }
        // 判断库存是否充足
        if (seckillVoucher.getStock() < 1){
            return Result.fail("优惠券库存不足");
        }


        Long userId = UserHolder.getUser().getId();

        //        悲观锁实现一人一券
        synchronized (userId.toString().intern()) {

            // 防止事务失效使用代理对象
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        }
    }

    @Transactional
    public  Result createVoucherOrder(Long voucherId) {
        // 一人一单判断
        // 查询id
        Long id = UserHolder.getUser().getId();
            int count = query().eq("user_id", id).eq("voucher_id", voucherId).count();
            if (count > 0){
                // 说明用户已经购买过
                return Result.fail("用户已经购买过一张");
            }
        // 扣减库存 乐观锁
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherId)
                .gt("stock",0) // 如果stock和之前未修改时一样说明不存在数据被修改
                .update();
        if (!success){
            return Result.fail("优惠券库存不足");
        }
        // 创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        // 订单id
        long orderId = redisIdWorker.nextId("order");
        voucherOrder.setId(orderId);
        // 用户id
        voucherOrder.setUserId(UserHolder.getUser().getId());
        // 订单id
        voucherOrder.setVoucherId(voucherId);
        // 保存订单
        save(voucherOrder);
        return Result.ok(orderId);
    }
```
使用乐观锁实现扣减库存 使用悲观锁实现一人一单的判断

## 4.集群模式下的分布式锁

![image.png](/static/img/4a19423c22531ed0c0192a69fdf2985f.image.webp)

redis实现分布式锁

![image.png](/static/img/039b5cd8bc9d728c21a10b765b2fa62f.image.webp)

初级版本

```java
package com.hmdp.utils;

import org.springframework.data.redis.core.StringRedisTemplate;

import java.util.concurrent.TimeUnit;


public class SimpleRedisLock implements ILock{

    private String name;

    private StringRedisTemplate stringRedisTemplate;

    private static final String KEY_PREFIX = "lock:";


    public SimpleRedisLock(StringRedisTemplate stringRedisTemplate, String name) {
        this.stringRedisTemplate = stringRedisTemplate;
        this.name = name;
    }

    /**
     * 尝试上锁
     *
     * @param timeout
     * @return
     */
    @Override
    public boolean tryLock(long timeout) {
        // 获取线程显示
        long id = Thread.currentThread().getId();
        // 获取锁
        Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFIX + name,id+"",timeout, TimeUnit.SECONDS); // 如果不存在才执行
        return Boolean.TRUE.equals(success);
    }

    /**
     * 释放锁
     */
    @Override
    public void unlock() {
        stringRedisTemplate.delete(KEY_PREFIX + name);
    }
}

```

redis锁误删问题

![image.png](/static/img/a297274f8c57b53a2db4b24491ad616c.image.webp)

当线程获取锁后业务阻塞执行超时 锁触发超时释放 其他线程获取到锁 但阻塞线程执行完毕执行解锁 将后来线程的锁解除 导致多个线程同时获取到锁

在释放锁时进行锁标识符（UUID 线程id）判断

## 5.Lua脚本实现多条命令的原子性问题

使用lua脚本实现redis命令的原子性


```lua
--比较线程标示与锁中的标示是否一致
if (redis.call('get',KEYS[1] == ARGV[1])) then
    --释放锁
    return redis.call('del',KEYS[1])
end
return 0
```


```java
    private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;
    // 初始化文件中的lua脚本
    static {
        UNLOCK_SCRIPT = new DefaultRedisScript<>();
        UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
    }
```

```java
    /**
     * 解锁
     */
    @Override
    public void unlock() {
        stringRedisTemplate.execute(
                UNLOCK_SCRIPT,
                Collections.singletonList(KEY_PREFIX+name),
                ID_PREFIX+Thread.currentThread().getId()
        );
    }
```
## 6.Redisson实现的分布式锁

setnx实现的分布式锁的问题

![image.png](/static/img/478e56147cadef0c843f4c6898d32ca2.image.webp)

![image.png](/static/img/7946c1a25b47f2d82aaf10c7dd87eeb3.image.webp)

导入redisson

配置redisson

```java
package com.hmdp.config;


import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RedisConfig {



    @Bean
    public RedissonClient redissonClient(){
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.42.20:6379").setPassword("123456");
        return Redisson.create(config);
    }

}

```

修改业务

```java
RLock lock = redissonClient.getLock("order" + userId);
//        SimpleRedisLock simpleRedisLock = new SimpleRedisLock(stringRedisTemplate, "order" + userId);
        // 获取锁
        boolean isLock = lock.tryLock();
        // 判断获取锁是否成功
        if (!isLock){
            // 获取锁失败,返回错误或重试
            return Result.fail("不允许重复下单");
        }
        try {
            // 防止事务失效使用代理对象
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        }finally {
            lock.unlock();
        }
```

可重入锁原理

![image.png](/static/img/180103eb3be2354e1fa65b9d2aa6ad69.image.webp)

lua脚本实践

![image.png](/static/img/da6645caf56bb87f16e00ae5870d153c.image.webp)

## redisson的multiLock (分布式锁的主从一致性问题)


![image.png](/static/img/b99d2a564d269100a0cb80e26b55e96d.image.webp)

配置3个redis

添加联锁

```java
redissonClient.getMultiLock(redissonClient,redissonClient2,redissonClient3);
```

## redis秒杀优化

![image.png](/static/img/96cd211db121a611bb916f465bfad7ba.image.webp)

编写lua脚本实现购票判断

```lua
--1.参数列表
--1.1优惠券id
local voucherId = ARGV[1]
--用户id
local userId = ARGV[2]

local stockKey = 'seckill:stock:'..voucherId
local orderKey = 'seckill:order:'..voucherId

if (tonumber(redis.call('get',stockKey))<=0) then
    --库存不足
    return 1;
end
--判断用户是否下单
if (redis.call('sismember',orderKey,userId) == 1) then
    return 2
end
--扣减库存
redis.call('incrby',stockKey,-1)
--下单
redis.call('sadd',orderKey,userId)

return 0
```

使用阻塞队列实现异步添加订单

```java
    /**
     * 优惠券秒杀实现
     *
     * @param voucherId
     * @return
     */
    @Override
    public Result seckillVoucher(Long voucherId) {
        SeckillVoucher seckillVoucher = seckillVoucherService.getById(voucherId);
        // 判断是否开始秒杀
        if (seckillVoucher.getBeginTime().isAfter(LocalDateTime.now())){
            return Result.fail("优惠券秒杀尚未开始");
        }
        // 判断秒杀是否结束
        if (seckillVoucher.getEndTime().isBefore(LocalDateTime.now())){
            return Result.fail("优惠券秒杀已经结束");
        }
//        使用redis优化秒杀逻辑

        // 执行lua脚本
        Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT
                , Collections.emptyList()
                , voucherId.toString()
                , UserHolder.getUser().getId().toString()
        );
        // 判断返回值
        int r = result.intValue();
        if (r != 0){
            // 不为0代表没有购买资格
            return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
        }
        // 为0有购买资格
        VoucherOrder voucherOrder = new VoucherOrder();
        long orderId = redisIdWorker.nextId("order");
        // 保存到阻塞队列
        // 用户id
        voucherOrder.setId(orderId);
        // 代金券id
        voucherOrder.setVoucherId(voucherId);
        // 放入到阻塞队列中
        orderTasks.add(voucherOrder);
        // 获取代理对象
        proxy = (IVoucherOrderService) AopContext.currentProxy();
        // 返回订单id
        return Result.ok(orderId);
    }
```
## redis实现消息队列

### 基于list实现消息队列

使用redis中的brpop和lpush实现

![image.png](/static/img/07267c6cbd8ecbefe6f02986ab548cee.image.webp)

### 基于PubSub实现的消息队列

![image.png](/static/img/49ec9bf5e9f09e86961f6892a6299610.image.webp)

### 基于Stream的消息队列 消费者组

![image.png](/static/img/9fc9c583de6cf67f18423c9d60bd6ab0.image.webp)

![image.png](/static/img/2119d39615bb7a1383f17062d79e90eb.image.webp)

![image.png](/static/img/bb0bf0372a1b4da81dc55bc43b1a1575.image.webp)

### 基于stream的异步秒杀

1 创建xgroup
`xgroup create stream.orders g1 0 mkstream
`
修改lua脚本实现判断购买资格后加入消息队列

```lua

--1.参数列表
--1.1优惠券id
local voucherId = ARGV[1]
--用户id
local userId = ARGV[2]
--订单id
local orderId = ARGV[3]

local stockKey = 'seckill:stock:'..voucherId
local orderKey = 'seckill:order:'..voucherId

if (tonumber(redis.call('get',stockKey))<=0) then
    --库存不足
    return 1;
end
--判断用户是否下单
if (redis.call('sismember',orderKey,userId) == 1) then
    return 2
end
--扣减库存
redis.call('incrby',stockKey,-1)
--下单
redis.call('sadd',orderKey,userId)
--发送消息到队列中
redis.call('xadd','stream.orders','*','userId',userId,'voucherId',voucherId,'id',orderId)
return 0
```

2 修改读取队列代码


```java
private class VoucherOrderHandler implements Runnable {
        private String queueName = "stream.orders";

        @Override
        public void run() {
            while (true) {
                try {
                    // 获取redis消息队列中的订单信息
                    List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
                            Consumer.from("g1", "c1")
                            , StreamReadOptions.empty()
                                    .count(1).block(Duration.ofSeconds(2))
                            , StreamOffset.create(queueName, ReadOffset.lastConsumed())
                    );
                    if (list == null || list.isEmpty()) {
                        continue;
                    }
                    // 创建订单
                    // 解析消息中的订单
                    MapRecord<String, Object, Object> entries = list.get(0);
                    Map<Object, Object> value = entries.getValue();
                    VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
                    handleVoucherOrder(voucherOrder);
                    // ack确认
                    stringRedisTemplate.opsForStream().acknowledge(queueName, "g1", entries.getId());
                } catch (Exception e) {
                    log.error("处理订单异常", e);
                    handlePendingList();
                }
            }
        }

        private void handlePendingList() {
            while (true) {
                try {
                    // 获取pending-list消息队列中的订单信息
                    List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
                            Consumer.from("g1", "c1")
                            , StreamReadOptions.empty()
                                    .count(1).block(Duration.ofSeconds(2))
                            , StreamOffset.create(queueName, ReadOffset.from("0"))
                    );
                    if (list == null || list.isEmpty()) {
//                        获取不到pendinglist中的异常数据结束循环
                        return;
                    }
                    // 创建订单
                    // 解析消息中的订单
                    MapRecord<String, Object, Object> entries = list.get(0);
                    Map<Object, Object> value = entries.getValue();
                    VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
                    handleVoucherOrder(voucherOrder);
                    // ack确认
                    stringRedisTemplate.opsForStream().acknowledge(queueName, "g1", entries.getId());
                } catch (Exception e) {
                    log.error("处理订单异常", e);
                }
            }

        }
    }
```

java中redis企业级实践

## 相关问题概览



![image.png](/static/img/bd4dd6dfe4564120df5e41a20356857d.image.webp)

## (1)Spring中的单例bean是线程安全的吗

![image.png](/static/img/46aede189a4e9ce7a5025a489e00a749.image.webp)

面试话术

![image.png](/static/img/1f95e9439dfb3211d9fdb34e1b618938.image.webp)

`1. Spring框架中的单例bean是线程安全的吗？
候选人：
不是线程安全的。当多用户同时请求一个服务时，容器会给每个请求分配一个线程，这些线程会并发执行业务逻辑。如果处理逻辑中包含对单例状态的修改，比如修改单例的成员属性，就必须考虑线程同步问题。Spring框架本身并不对单例bean进行线程安全封装，线程安全和并发问题需要开发者自行处理。
通常在项目中使用的Spring bean是不可变状态（如Service类和DAO类），因此在某种程度上可以说Spring的单例bean是线程安全的。如果bean有多种状态（如ViewModel对象），就需要自行保证线程安全。最简单的解决办法是将单例bean的作用域由“singleton”变更为“prototype”。`

## (2)什么是AOP

![image.png](/static/img/2a1e88eca97be07c4fdadb7b5f3ef9d1.image.webp)


![image.png](/static/img/e5f403b1a8aa1b5067fb8ceb01592ceb.image.webp)

面试话术

`2. 什么是AOP？
候选人：
AOP，即面向切面编程，在Spring中用于将那些与业务无关但对多个对象产生影响的公共行为和逻辑抽取出来，实现公共模块复用，降低耦合。常见的应用场景包括公共日志保存和事务处理。`

`3. 你们项目中有没有使用到AOP？
候选人：
我们之前在后台管理系统中使用AOP来记录系统操作日志。主要思路是使用AOP的环绕通知和切点表达式，找到需要记录日志的方法，然后通过环绕通知的参数获取请求方法的参数，例如类信息、方法信息、注解、请求方式等，并将这些参数保存到数据库。`

## (3)Spring框架中事务失效的情况

### 1.异常捕获处理

![image.png](/static/img/3ced25ce1fcc1825b66dacc2a39aae41.image.webp)

需要在catch中抛出异常

### 2.抛出检查异常

![image.png](/static/img/b5793447aa481a2b45cbd37b6188513f.image.webp)

需要添加注释

![image.png](/static/img/5f8bc9c93530339b6ce2e41340b249ac.image.webp)

### 3.非public方法导致事务失效

![image.png](/static/img/337f8b1e04ba5ee1acf761e31a6c2c49.image.webp)

面试话术

![image.png](/static/img/66857af689e65ed8a066ffa6210d82c0.image.webp)

`4. Spring中的事务是如何实现的？
候选人：
Spring实现事务的本质是利用AOP完成的。它对方法前后进行拦截，在执行方法前开启事务，在执行完目标方法后根据执行情况提交或回滚事务。`

`5. Spring中事务失效的场景有哪些？
候选人：
在项目中，我遇到过几种导致事务失效的场景
;1. 如果方法内部捕获并处理了异常，没有将异常抛出，会导致事务失效。因此，处理异常后应该确保异常能够被抛出。
;2. 如果方法抛出检查型异常（checked exception），并且没有在@Transactional注解上配置rollbackFor属性为Exception，那么异常发生时事务可能不会回滚。
;3. 如果事务注解的方法不是公开（public）修饰的，也可能导致事务失效。`

## (4)Spring Bean的生命周期

![image.png](/static/img/19bf0af139855d5270757f63baed01cb.image.webp)

面试话术

`6. Spring的bean的生命周期？
候选人：
Spring中bean的生命周期包括以下步骤：
；1. 通过BeanDefinition获取bean的定义信息。
；2. 调用构造函数实例化bean。
；3. 进行bean的依赖注入，例如通过setter方法或@Autowired注解。
；4. 处理实现了Aware接口的bean。
；5. 执行BeanPostProcessor的前置处理器。
；6. 调用初始化方法，如实现了InitializingBean接口或自定义的init-method。
；7. 执行BeanPostProcessor的后置处理器，可能在这里产生代理对象。
；8. 最后是销毁bean。`

## (5)Spring中的循环引用问题

问题产生原因

![image.png](/static/img/6c35a80f44503d3568b7f6ec73ca785c.image.webp)

三级缓存解决循环依赖

![image.png](/static/img/13ea0e5b22467fead74bb6cb0585f3ba.image.webp)

构造方法出现循环依赖的问题

![image.png](/static/img/da57bc9158390130e0e6268baee9d205.image.webp)

面试话术

`7. Spring中的循环引用？
候选人：
循环依赖发生在两个或两个以上的bean互相持有对方，形成闭环。Spring框架允许循环依赖存在，并通过三级缓存解决大部分循环依赖问题：
；1. 一级缓存：单例池，缓存已完成初始化的bean对象。
；2. 二级缓存：缓存尚未完成生命周期的早期bean对象。
；3. 三级缓存：缓存ObjectFactory，用于创建bean对象。`

`8. 那具体解决流程清楚吗？
候选人：
解决循环依赖的流程如下：
；1. 实例化A对象，并创建ObjectFactory存入三级缓存。
；2. A在初始化时需要B对象，开始B的创建逻辑。
；3. B实例化完成，也创建ObjectFactory存入三级缓存。
；4. B需要注入A，通过三级缓存获取ObjectFactory生成A对象，存入二级缓存。
；5. B通过二级缓存获得A对象后，B创建成功，存入一级缓存。
；6. A对象初始化时，由于B已创建完成，可以直接注入B，A创建成功存入一级缓存。
；7. 清除二级缓存中的临时对象A。`

`9. 构造方法出现了循环依赖怎么解决？
候选人：
由于构造函数是bean生命周期中最先执行的，Spring框架无法解决构造方法的循环依赖问题。可以使用@Lazy懒加载注解，延迟bean的创建直到实际需要时。`

## (6)Spring MVC的执行流程

视图阶段

![image.png](/static/img/7b3b11ea8800fc9a35e296126fb256ff.image.webp)

前后端分离阶段

![image.png](/static/img/324bf262343dbf6a7418b5eb3992a666.image.webp)

面试话术

![image.png](/static/img/acaa98e5ee05cd95f39219e1de51fc42.image.webp)

`10. SpringMVC的执行流程？
候选人：
SpringMVC的执行流程包括以下步骤：
；1. 用户发送请求到前端控制器DispatcherServlet。
；2. DispatcherServlet调用HandlerMapping找到具体处理器。
；3. HandlerMapping返回处理器对象及拦截器（如果有）给DispatcherServlet。
；4. DispatcherServlet调用HandlerAdapter。
；5. HandlerAdapter适配并调用具体处理器（Controller）。
；6. Controller执行并返回ModelAndView对象。
；7. HandlerAdapter将ModelAndView返回给DispatcherServlet。
；8. DispatcherServlet传给ViewResolver进行视图解析。
；9. ViewResolver返回具体视图给DispatcherServlet。
；10. DispatcherServlet渲染视图并响应用户。`

## (7)SpringBoot自动配置原理

![image.png](/static/img/25a11f20b7b6a347e9e015c9bbfff8ce.image.webp)

面试话术

`11. Springboot自动配置原理？
候选人：
Spring Boot的自动配置原理基于@SpringBootApplication注解，它封装了@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan。@EnableAutoConfiguration是核心，它通过@Import导入配置选择器，读取META-INF/spring.factories文件中的类名，根据条件注解决定是否将配置类中的Bean导入到Spring容器中。`

## (8)SpringBoot常见的注解

spring

![image.png](/static/img/5dda2beade3103eade4a65ec38a418ff.image.webp)

springMVC

![image.png](/static/img/e929350a96df85ccf6aa9fd3146a0712.image.webp)

SpringBoot

![image.png](/static/img/266860ce298a5501237a594fc8564c48.image.webp)

框架篇

## （1）如何定位慢查询

出现原因：

聚合查询

多表查询

表数据过大

深度分页查询

### 1.开源工具

Arthas Prometheus Skywalking

![image.png](/static/img/b24b69523d480b09365adbb8c00516dc.image.webp)

### 2.Mysql自带的慢日志

![image.png](/static/img/f60e1d8a3767f85b168b89b83fe9b091.image.webp)

面试话术

![image.png](/static/img/0c57893423ba4b40645827e01174c171.image.webp)

![image.png](/static/img/02de93ed8f20c83497e2b90e5866dc93.image.webp)

## （2）如何优化SQL

聚合查询 新增临时表

多表查询 优化SQL语句结构                     SQL执行计划(找到慢的原因)

表数据过大查询 添加索引

深度分页查询

![image.png](/static/img/82eacd3eee7c58a02e0f16cd5a2dfa32.image.webp)

![image.png](/static/img/e99c1acf2a72f9638a17bfe49774807b.image.webp)

![image.png](/static/img/1f843779fc4d03efa34c884ea186225a.image.webp)

面试话术

![image.png](/static/img/f931a0187af5af92f01792f734ffa2c4.image.webp)

## （3）索引

话术

![image.png](/static/img/c62ef96d8bea7130c1a024816a4e6d2c.image.webp)

![image.png](/static/img/9544d7e5a043821808b94d5e53681a7c.image.webp)

![image.png](/static/img/96837575a24345465d5a5a0ae070b58e.image.webp)

## （4）聚集索引，二级索引(聚簇索引，非聚簇索引)回表查询

### 1.聚集索引

![image.png](/static/img/fbf6cedd683ba1d59523c651623e22a0.image.webp)

### 2.回表查询

![image.png](/static/img/93e5dd9abf5cc86de2bb6f8ca0beedfa.image.webp)

面试话术

![image.png](/static/img/e5920646b57574c2e29385cb60db3811.image.webp)

![image.png](/static/img/12c9965addf8c6139707df91942722e7.image.webp)

## （5）覆盖索引，超大分页优化

### 1.覆盖索引

![image.png](/static/img/8d24298c83d075b5558c06aab4b9136f.image.webp)

![image.png](/static/img/f5bbdce603cbe8b6c8f56935500ddd1f.image.webp)

覆盖索引没有回表查询

面试话术

![image.png](/static/img/2a619ea56af53c04012aae0d7af5a53f.image.webp)

![image.png](/static/img/775231c87abc119f3a2f51a4822d384f.image.webp)
### 2.Mysql超大分页

![image.png](/static/img/5e42e7854c609559bd1ee1d6a0387e7a.image.webp)

![image.png](/static/img/73fe114ac9d9470ef4a71ef68b9f88bd.image.webp)

![image.png](/static/img/2db9a0197f211a267e44fba9dd85732a.image.webp)

## （6）创建索引的原则

![image.png](/static/img/142f0937182ae29d5a2d95323fc684af.image.webp)

面试话术

![image.png](/static/img/681256e06e9c0d48d6002bdc6dd35ecb.image.webp)

![image.png](/static/img/0728897b251b6a2dc4e0ec165a5ea4e6.image.webp)

## （7）索引失效

**失效情况**
 
 ### 1.违反最短前缀法则
 
![image.png](/static/img/f842ffea93eda8c758af52c2eaed95e7.image.webp)

![image.png](/static/img/bc858fee39f39b42151f324518d83886.image.webp)

### 2.范围查询右边的列不能使用索引

![image.png](/static/img/d4c99c3526a9f2dab5888bc9bba9cdaf.image.webp)

### 3.不要在索引列上进行运算操作

![image.png](/static/img/350539394f13945c3e3d9b0ad95129c6.image.webp)

### 4.字符串不加单引号，造成索引失效

![image.png](/static/img/68b9e2bf37973c65feb2fc6630909615.image.webp)

### 5.以%开头的like模糊查询，索引失效。如果仅仅是尾部匹配模糊查询索引不会失效。

![image.png](/static/img/aa179db68df1e011e375633d095e1858.image.webp)

面试话术

![image.png](/static/img/edc38d72e2db808739d3d7bbee1bb0b1.image.webp)

![image.png](/static/img/10707343269e24b5c5541bab2716c4e6.image.webp)

## (8)SQL优化

表设计的优化

索引优化

sql语句优化

主从复制，读写分离

分库分表

![image.png](/static/img/ee5448ad5861326ca01798c2585d6da8.image.webp)

![image.png](/static/img/18407798437c582cd8d7b6ad8dc6d9c9.image.webp)

面试话术

![image.png](/static/img/a6db11ab8c57defb2d92451870212bd5.image.webp)

## (9)事务特性

ACID

![image.png](/static/img/16dbbc36cc7a37822174088654ddc676.image.webp)

![image.png](/static/img/62b4a508a13a27b0313d10689735b170.image.webp)

原子性 隔离性 持久性 一致性

面试话术

![image.png](/static/img/71438f878aa06e42c51380f0c3d59569.image.webp)

## (10)并发事务带来的问题,如何解决,mysql的默认隔离级别

### 1.并发事务带来的问题

![image.png](/static/img/27b41532d11d0cb5fe6cd494ba20f40a.image.webp)
 
### 2.如何解决

对事务进行隔离

![image.png](/static/img/68fa7c7351190c7a94a8172dc0c583e8.image.webp)

面试话术

![image.png](/static/img/d1ebd6708dc2eef6eab9a6def56ce21c.image.webp)

## (11)undo log和redo log的区别

redo log

![image.png](/static/img/33df93e260cad6abbe4cdca2bc613177.image.webp)

undo log

![image.png](/static/img/0ca175797f28197badf9f06a020901b5.image.webp)

面试话术

![image.png](/static/img/feb0fce8885fa1d356b51e0f3e2c4ce0.image.webp)

## (12)mvcc

![image.png](/static/img/d29dbad569552429a276a17ba444c308.image.webp)

面试话术

![image.png](/static/img/e4d915bf74f54658e462ae4e22c97572.image.webp)

## (13)主从同步原理

主从同步核心是二进制文件

![image.png](/static/img/d1e7347c511339a01f55fd09eb116ae0.image.webp)

面试话术

![image.png](/static/img/dee828059c18530feffbbb225b6186a2.image.webp)

## (14)分库分表

![image.png](/static/img/45ccdacfd8d26d1842f8a406c8adc2f2.image.webp)

拆分策略

### 1.垂直分库

![image.png](/static/img/1f57d688834025b681ded7511a29467c.image.webp)

### 2.水平分库

![image.png](/static/img/f4d12e68f30e9581caac6c4baab97b05.image.webp)

分库分表策略

![image.png](/static/img/39613398243636a5886264595bfb9814.image.webp)


![image.png](/static/img/9b72ccf047b710890f00eee24818582a.image.webp)




Mysql篇

# 1.redis常见面试题

## （1）redis缓存穿透





![image.png](/static/img/78044e91fa212a3424e1e34e5931d2ae.image.webp)

使用不存在的id发送请求 不直接访问redis而是直接访问mysql

![image.png](/static/img/ff40159c8d19aaf6c4482bbd9c51ad26.image.webp)

**解决方案:**

### 1.缓存空数据,查询结果为空仍把这个空结果进行缓存
优点：简单
缺点：消耗内存，可能发生不一致的问题

### 2.布隆过滤器

![image.png](/static/img/268aa004c978781cd4b70adce9b5b9ad.image.webp)

优点：内存占用较小，没有多余的key
缺点：实现较为复杂，存在误判

创建一个bitmap 初始全为空 预热布隆过滤器对传入id进行多次hash计算 由计算结果bitmap的对应位置该为1 如果传入idhash计算后在bitmap中不全为1就拦截

![image.png](/static/img/25ce76d07a6f9c26ffb03b08dd9cf4c0.image.webp)

## （2）缓存击穿

![image.png](/static/img/65a1f4c6d3b04624a34354089d82dce7.image.webp)

![image.png](/static/img/192be4d88f55dc01131c3a73ffce8302.image.webp)

**解决方案:**

### 1.互斥锁

![image.png](/static/img/8b1bedda11d6f01f5ef351bbe59fa803.image.webp)

强一致 性能差

![image.png](/static/img/0329965fbfd1bbe68708bb6922e7d476.image.webp)

### 2.逻辑过期

![image.png](/static/img/b75e594e7956b08ca8c1ab065dd5faa8.image.webp)

高可用 性能优

![image.png](/static/img/edb4362b6446db8cd4e2e935b0cffed6.image.webp)

##  （3）缓存雪崩

![image.png](/static/img/961bbed3743bac4287d75c0517e39561.image.webp)

![image.png](/static/img/c449e6a26eb5256a67679e88b2477311.image.webp)

**解决方案**

![image.png](/static/img/e269057dce9cc531109f29834d4fafd3.image.webp)

![image.png](/static/img/59528bd685662234e6257219e0ff7b90.image.webp)

## （4）双写一致性

![image.png](/static/img/ff09fd0e0281c1ca2bc9003a672e008f.image.webp)

强一致

![image.png](/static/img/3ead054c08a3bc4474993c8a517a390a.image.webp)

读写锁

![image.png](/static/img/4440007991641b651962b5398f30a26d.image.webp)

延时双删

![image.png](/static/img/6714028a1c52350ee149320dac20e834.image.webp)

总结

![image.png](/static/img/614da7fad2ea3f813ab24f942bc82da7.image.webp)

## （5）redis数据持久化

### 1.RDB

![image.png](/static/img/d06bc50fc2a9fee697d59a0970d0d9af.image.webp)

执行原理

![image.png](/static/img/7c062d617595b705eb9eef88b8e102c5.image.webp)

### 2.AOF

![image.png](/static/img/73202da1de69fd5bd16c064e28bdcc20.image.webp)

RDB和AOF对比

![image.png](/static/img/5308f6af0e6f1a6d6f64006ca67eda46.image.webp)

![image.png](/static/img/0f57477042d1356642a57a622cf87efd.image.webp)

## （6）数据过期策略

### 1.惰性删除

设置该key过期后，我们不去管他，当需要该key时我们再检查其是否过期，如果过期，我们就删除它，反之则返回key。

![image.png](/static/img/15ee1ce590afe4ee1ab31d35ee371401.image.webp)

### 2.定期删除

每隔一段时间我们就对一些key进行检查，删除里面过期的key

![image.png](/static/img/8b6b499e85c753e0dc8c7e6dd8872d8f.image.webp)

![image.png](/static/img/1d1f3136191b7d58cf7145ac10250b59.image.webp)

![image.png](/static/img/8a5161b893c6cd9ca64f7b44bafeb738.image.webp)

## （7）redis数据淘汰策略

![image.png](/static/img/d7a8716844b7b9d959942bd712cd2538.image.webp)

数据淘汰策略推荐

![image.png](/static/img/7cc91663a4da79a5b6ebcd58d41b7e7a.image.webp)

其他问题

![image.png](/static/img/ccac6e8f31f0eab23112e607327b4bc2.image.webp)

![image.png](/static/img/b6cce873ae3abaf2a255852e0715d62a.image.webp)

## （8）redis分布式锁

### 1.setnx

![image.png](/static/img/bfdf6287071ca17a6d78f91719bdc11c.image.webp)

给锁续期

### 2.redisson实现的分布式锁

执行流程

![image.png](/static/img/6fa4461e67be4995a903064fe193c6ee.image.webp)

![image.png](/static/img/374ad521853ab1c66d9ab95945fe7751.image.webp)

同一线程中可重入

**主从一致性**
 
 当主节点redis在获取锁时宕机会导致其他进程也获取锁成功
 
![image.png](/static/img/20ce392bd795e6d8bd746a51739ba82b.image.webp)

红锁

![image.png](/static/img/a97c7fa5ef6e22f9165040e474a5d4e7.image.webp)

面试话术

![image.png](/static/img/db11e8cc2e84904555f5081d331217c7.image.webp)

![image.png](/static/img/a0d94e1791c504bce780a90a689c1cb4.image.webp)

![image.png](/static/img/b0a96400c5e2ae2b0071e87f781bfe7d.image.webp)

## （9）redis集群方案

**主从复制**

**哨兵模式**

**分片集群**

### 1.主从复制

全量同步：

![image.png](/static/img/925311aebda91cc53789ca82c7254f81.image.webp)

增量同步：

![image.png](/static/img/5d3336c9c29c2eff16afce1d23e6e11a.image.webp)

面试话术

![image.png](/static/img/3f87d72b71418e779e082ebd883af830.image.webp)

![image.png](/static/img/b85d3710296d75890a5010759bc7929e.image.webp)

### 2.哨兵模式

**哨兵作用: 监控 自动故障恢复 通知**

![image.png](/static/img/2afa91b8d7fe9ed87a3482a1717afac1.image.webp)

服务状态监控

![image.png](/static/img/42a6f69761580a884aa2d510afa29b2d.image.webp)

脑裂问题

![image.png](/static/img/5bb7c880b21f21e9da2e31f72f517b03.image.webp)

面试话术

![image.png](/static/img/efebfddc9c6d5cdfa8301d2e0fb20e91.image.webp)

![image.png](/static/img/b5e011af8dd5a2a0c315fe6890c9e053.image.webp)

### 3.分片集群

![image.png](/static/img/f364eda1dbbe2dcc25b77ff16314348b.image.webp)

数据读写

![image.png](/static/img/1ba0db13cbeb2744038a12ce65cfae3b.image.webp)

面试话术

![image.png](/static/img/80ae5c8de917c97d16492f16db881e19.image.webp)

![image.png](/static/img/51b7e26f37410cf672338a57f03b9ca4.image.webp)

## （9）redis其他面试问题

### 1.redis是单线程的为什么还这么快

reids是纯内存操作，执行速度非常快

采用单线程，避免不必要的上下文切换可竞争条件，多线程还要考虑线程安全问题

使用i/o多路复用模型，非阻塞io

![image.png](/static/img/f724a415f8f3b69a469802103243dfc8.image.webp)

### 2.解释一下i/o多路复用模型

![image.png](/static/img/15adf0a435f96228b4b2aff8a8620d04.image.webp)

![image.png](/static/img/08958a8b380aaab617772aeeeafc17f0.image.webp)

![image.png](/static/img/123e1cc3070b8a1e42e866d1c9ed7352.image.webp)