月半.
搜索/
JAVA INTERVIEW / 学习索引

Java 八股文.

从一个问题开始，把知识点慢慢串起来。

分类
24 个
题目
350 道
阅读方式
回到原文，深入理解

题目目录

点击题目，前往原文 ↗

显示 350 / 350 道题 · 24 个分类

Java 基础面试题

21 道题
  1. 第 1 题： String 为什么设计成 final 不可变的？ （新标签页打开原文）
  2. 第 2 题： String、StringBuilder 和 StringBuffer 的区别？ （新标签页打开原文）
  3. 第 3 题： String str = new String("abc") 创建了几个对象？ （新标签页打开原文）
  4. 第 4 题： 接口和抽象类的区别是什么？怎么选择？ （新标签页打开原文）
  5. 第 5 题： while(true) 和 for(;;) 哪个性能更好？ （新标签页打开原文）
  6. 第 6 题： 什么是反射机制？为什么反射慢？ （新标签页打开原文）
  7. 第 7 题： 什么是泛型？为什么要使用它？ （新标签页打开原文）
  8. 第 8 题： 如何理解 Java 中的多态？ （新标签页打开原文）
  9. 第 9 题： 为什么 Java 不支持多继承？ （新标签页打开原文）
  10. 第 10 题： final、finally、finalize 的区别？ （新标签页打开原文）
  11. 第 11 题： finally 中代码一定会被执行吗？ （新标签页打开原文）
  12. 第 12 题： BigDecimal 和 Long 哪个表示金额更合适，怎么选择？ （新标签页打开原文）
  13. 第 13 题： AIO、BIO 和 NIO 的区别？ （新标签页打开原文）
  14. 第 14 题： 什么是 SPI，和 API 有啥区别？ （新标签页打开原文）
  15. 第 15 题： 为什么不能用浮点数表示金额？ （新标签页打开原文）
  16. 第 16 题： 深拷贝和浅拷贝的区别？ （新标签页打开原文）
  17. 第 17 题： 什么是序列化与反序列化？ （新标签页打开原文）
  18. 第 18 题： 为什么重写 equals 时一定要重写 hashCode？ （新标签页打开原文）
  19. 第 19 题： 什么是 UUID，能保证唯一性吗？ （新标签页打开原文）
  20. 第 20 题： Java 中异常分哪两类，有什么区别？ （新标签页打开原文）
  21. 第 21 题： 为什么不能用 BigDecimal 的 equals 方法做等值比较？ （新标签页打开原文）

Java 集合面试题

14 道题
  1. 第 22 题： ArrayList、LinkedList 与 Vector 的区别？ （新标签页打开原文）
  2. 第 23 题： HashMap、Hashtable 和 ConcurrentHashMap 的区别？ （新标签页打开原文）
  3. 第 24 题： Java中的集合类有哪些？如何分类的？ （新标签页打开原文）
  4. 第 25 题： 说说 HashMap 的扩容机制？如何扩容的？ （新标签页打开原文）
  5. 第 26 题： 为什么 HashMap 的默认负载因子要设置成 0.75？ （新标签页打开原文）
  6. 第 27 题： 为什么在 Jdk 8 中 HashMap 要转成红黑树？ （新标签页打开原文）
  7. 第 28 题： HashMap 用在并发场景中会出现什么问题？ （新标签页打开原文）
  8. 第 29 题： HashMap 的 remove 方法是如何实现的？ （新标签页打开原文）
  9. 第 30 题： HashMap 在 get 和 put 时，底层流程是怎样的？ （新标签页打开原文）
  10. 第 31 题： HashMap 的 hash 方法是如何实现的？ （新标签页打开原文）
  11. 第 32 题： Set 如何保证元素不重复的？ （新标签页打开原文）
  12. 第 33 题： 什么是 fail-fast？什么是 fail-safe？ （新标签页打开原文）
  13. 第 34 题： ConcurrentHashMap 是如何保证线程安全的？ （新标签页打开原文）
  14. 第 35 题： ConcurrentHashMap 为什么在 JDK 1.8 中废弃分段锁？ （新标签页打开原文）

MySQL 面试题

24 道题
  1. 第 36 题： char 和 varchar 的区别？ （新标签页打开原文）
  2. 第 37 题： InnoDB 和 MyISAM 有什么区别？ （新标签页打开原文）
  3. 第 38 题： MySQL 深度分页如何优化？ （新标签页打开原文）
  4. 第 39 题： 什么是回表查询？如何避免？ （新标签页打开原文）
  5. 第 40 题： 自增主键用完了怎么办? （新标签页打开原文）
  6. 第 41 题： 为什么不推荐使用外键？ （新标签页打开原文）
  7. 第 42 题： 唯一索引和主键索引的区别？ （新标签页打开原文）
  8. 第 43 题： count(1)、count(*) 与 count(列名) 的区别？ （新标签页打开原文）
  9. 第 44 题： InnoDB 中索引类型有哪些？ （新标签页打开原文）
  10. 第 45 题： truncate、delete、drop 的区别？ （新标签页打开原文）
  11. 第 46 题： 慢查询怎么排查？ （新标签页打开原文）
  12. 第 47 题： 脏读、幻读、不可重复读是什么？ （新标签页打开原文）
  13. 第 48 题： 什么是数据库死锁，怎么解决？ （新标签页打开原文）
  14. 第 49 题： 用了索引还是很慢，可能是什么原因？ （新标签页打开原文）
  15. 第 50 题： 如何进行 SQL 调优？ （新标签页打开原文）
  16. 第 51 题： binlog、redolog 和 undolog 的区别？ （新标签页打开原文）
  17. 第 52 题： 设计索引时应遵循哪些原则？ （新标签页打开原文）
  18. 第 53 题： 为什么不建议使用存储过程？ （新标签页打开原文）
  19. 第 54 题： 为什么互联网大厂不推荐使用多表 JOIN？ （新标签页打开原文）
  20. 第 55 题： 什么是数据库范式，为什么要反范式化设计？ （新标签页打开原文）
  21. 第 56 题： 什么是最左前缀匹配？为什么要遵守？ （新标签页打开原文）
  22. 第 57 题： 乐观锁与悲观锁怎么实现？ （新标签页打开原文）
  23. 第 58 题： 谈谈 InnoDB 中的表级锁、页级锁、行级锁？ （新标签页打开原文）
  24. 第 59 题： InnoDB 加索引，这个时候会锁表吗? （新标签页打开原文）

Redis 面试题

26 道题
  1. 第 60 题： Redis 数据类型有哪几种？ （新标签页打开原文）
  2. 第 61 题： Redis 和 Memcached 的区别？ （新标签页打开原文）
  3. 第 62 题： Redis 和 Caffeine 的区别是什么？ （新标签页打开原文）
  4. 第 63 题： Redis 是单线程还是多线程？ （新标签页打开原文）
  5. 第 64 题： Redis 单线程，为什么还这么快？ （新标签页打开原文）
  6. 第 65 题： Redis Key 和 Value 的设计原则有哪些？ （新标签页打开原文）
  7. 第 66 题： 谈谈 Redis 的持久化机制：RDB 与 AOF 的区别？ （新标签页打开原文）
  8. 第 67 题： Redis 分布式锁如何实现？ （新标签页打开原文）
  9. 第 68 题： Redis 锁是并发安全的吗？怎么保证不被抢夺？ （新标签页打开原文）
  10. 第 69 题： 怎么解决 Redis 缓存和数据库的一致性问题？ （新标签页打开原文）
  11. 第 70 题： Redis 如何实现发布、订阅？ （新标签页打开原文）
  12. 第 71 题： 谈谈 Redis 5.0 中的 Stream 消息队列？ （新标签页打开原文）
  13. 第 72 题： Redis 如何实现延迟消息？ （新标签页打开原文）
  14. 第 73 题： 谈谈 Redis 的过期策略？ （新标签页打开原文）
  15. 第 74 题： 谈谈 Redis 的内存淘汰策略？ （新标签页打开原文）
  16. 第 75 题： Redis 事务和 Lua 脚本的区别？ （新标签页打开原文）
  17. 第 76 题： Redis 为什么要自定义 SDS？ （新标签页打开原文）
  18. 第 77 题： Redis 如何高效安全的遍历所有 Key？ （新标签页打开原文）
  19. 第 78 题： 什么是缓存击穿、缓存穿透、缓存雪崩？ （新标签页打开原文）
  20. 第 79 题： 什么是大 Key 问题，如何解决？ （新标签页打开原文）
  21. 第 80 题： 什么是热点 Key 问题，如何解决？ （新标签页打开原文）
  22. 第 81 题： 谈谈 ZSet 底层实现？ （新标签页打开原文）
  23. 第 82 题： 谈谈 Redis 集群模式? （新标签页打开原文）
  24. 第 83 题： 什么是 Redis 集群脑裂问题，怎么解决？ （新标签页打开原文）
  25. 第 84 题： 什么是 Redis 的数据分片？ （新标签页打开原文）
  26. 第 85 题： 为什么 Redis 不支持回滚？ （新标签页打开原文）

RocketMQ 面试题

8 道题
  1. 第 86 题： 为什么项目要选择 RocketMQ？ （新标签页打开原文）
  2. 第 87 题： RocketMQ 的架构是怎么样的？ （新标签页打开原文）
  3. 第 88 题： RocketMQ 有几种集群部署方式？ （新标签页打开原文）
  4. 第 89 题： RocketMQ 消息堆积了怎么处理？ （新标签页打开原文）
  5. 第 90 题： RocketMQ 的消息是推模式，还是拉模式？ （新标签页打开原文）
  6. 第 91 题： 谈谈 RocketMQ 的事务消息？ （新标签页打开原文）
  7. 第 92 题： RocketMQ 怎么保证消息的顺序性？ （新标签页打开原文）
  8. 第 93 题： RocketMQ 怎么保证消息不丢失？ （新标签页打开原文）

MyBatis 面试题

13 道题
  1. 第 94 题： MyBatis 和 Hibernate 有什么区别？ （新标签页打开原文）
  2. 第 95 题： #{} 和 ${} 的区别？ （新标签页打开原文）
  3. 第 96 题： 说说 Mybatis 的缓存机制？ （新标签页打开原文）
  4. 第 97 题： Mybatis 是怎么实现字段映射的？ （新标签页打开原文）
  5. 第 98 题： 说说 Mybatis 插件的运行原理？ （新标签页打开原文）
  6. 第 99 题： MyBatis 支持动态 SQL 吗？ （新标签页打开原文）
  7. 第 100 题： 谈谈 Mybatis 的工作原理？ （新标签页打开原文）
  8. 第 101 题： Mybatis 是否支持延迟加载？实现原理是什么？ （新标签页打开原文）
  9. 第 102 题： MyBatis 如何执行批量操作？ （新标签页打开原文）
  10. 第 103 题： MyBatis 是如何进行分页的？分页插件的原理是什么？ （新标签页打开原文）
  11. 第 104 题： 为什么 Mapper 接口不需要写实现类？ （新标签页打开原文）
  12. 第 105 题： Mybatis 都有哪些 Executor 执行器？ （新标签页打开原文）
  13. 第 106 题： 说说 JDBC 的执行步骤？ （新标签页打开原文）

Spring Cloud 面试题

11 道题
  1. 第 107 题： 什么是微服务？它带来哪些挑战？ （新标签页打开原文）
  2. 第 108 题： 什么是 Spring Cloud，它有哪些组件？ （新标签页打开原文）
  3. 第 109 题： 为什么需要 Gateway 网关，它有什么作用？ （新标签页打开原文）
  4. 第 110 题： Zuul、Gateway 和 Nginx 有什么区别？ （新标签页打开原文）
  5. 第 111 题： Dubbo 和 Feign 有什么区别？ （新标签页打开原文）
  6. 第 112 题： 说说 HTTP 和 RPC 的区别？ （新标签页打开原文）
  7. 第 113 题： LoadBalancer 和 Ribbon 的区别是什么？为什么用它替代 Ribbon？ （新标签页打开原文）
  8. 第 114 题： Feign 第一次调用为什么会很慢？怎么解决？ （新标签页打开原文）
  9. 第 115 题： Nacos 与 Eureka、ZooKeeper 的区别？ （新标签页打开原文）
  10. 第 116 题： Nacos 如何实现服务注册与发现的？ （新标签页打开原文）
  11. 第 117 题： Hystrix 和 Sentinel 的区别？ （新标签页打开原文）

Java 并发面试题

31 道题
  1. 第 118 题： Java 线程池有几种创建方式？ （新标签页打开原文）
  2. 第 119 题： 线程池的拒绝策略有哪些？ （新标签页打开原文）
  3. 第 120 题： 线程数设置多少合适？ （新标签页打开原文）
  4. 第 121 题： 说说动态线程池实现原理？ （新标签页打开原文）
  5. 第 122 题： 任务特别多，线程池队列满了怎么办？不能拒绝！ （新标签页打开原文）
  6. 第 123 题： 多线程上下文切换是什么意思？ （新标签页打开原文）
  7. 第 124 题： 什么是守护线程，和普通线程有什么区别？ （新标签页打开原文）
  8. 第 125 题： 线程有几种状态，状态之间是怎样流转的？ （新标签页打开原文）
  9. 第 126 题： 创建线程有几种方式？ （新标签页打开原文）
  10. 第 127 题： 并发和并行的区别？ （新标签页打开原文）
  11. 第 128 题： Java 中常见的锁有哪些？ （新标签页打开原文）
  12. 第 129 题： 什么是线程死锁，如何排查？如何解决？ （新标签页打开原文）
  13. 第 130 题： 线程、进程、协程的区别？ （新标签页打开原文）
  14. 第 131 题： 什么是 ThreadLocal，如何实现的？ （新标签页打开原文）
  15. 第 132 题： ThreadLocal 为什么会导致内存泄漏？怎么解决？ （新标签页打开原文）
  16. 第 133 题： ThreadLocal 使用场景有哪些？ （新标签页打开原文）
  17. 第 134 题： ThreadLocalMap 和 HashMap 的区别？ （新标签页打开原文）
  18. 第 135 题： volatile 可以保证原子性吗？ （新标签页打开原文）
  19. 第 136 题： volatile 是如何保证可见性和有序性的？ （新标签页打开原文）
  20. 第 137 题： synchronized 是怎么实现的？ （新标签页打开原文）
  21. 第 138 题： synchronized 锁升级过程是怎样的？ （新标签页打开原文）
  22. 第 139 题： synchronized 和 ReentrantLock 的区别？ （新标签页打开原文）
  23. 第 140 题： LongAdder 和 AtomicLong 的区别？ （新标签页打开原文）
  24. 第 141 题： 公平锁和非公平锁的区别？ （新标签页打开原文）
  25. 第 142 题： 父子线程之间如何共享、传递数据？ （新标签页打开原文）
  26. 第 143 题： 什么是 CAS？存在什么问题？ （新标签页打开原文）
  27. 第 144 题： AQS 是什么？它存在什么问题？ （新标签页打开原文）
  28. 第 145 题： CountDownLatch、CyclicBarrier、Semaphore 的区别？ （新标签页打开原文）
  29. 第 146 题： 什么是 Java 内存模型（JMM）？ （新标签页打开原文）
  30. 第 147 题： 什么是 happens-before 原则？ （新标签页打开原文）
  31. 第 148 题： 什么是可重入锁，如何实现可重入锁？ （新标签页打开原文）

设计模式面试题

12 道题
  1. 第 149 题： 什么是设计模式？它能带来哪些好处？ （新标签页打开原文）
  2. 第 150 题： 设计模式的 7 大基本原则有哪些？ （新标签页打开原文）
  3. 第 151 题： 单例模式有几种写法？ （新标签页打开原文）
  4. 第 152 题： 什么是代理模式？应用场景有哪些？ （新标签页打开原文）
  5. 第 153 题： 什么是责任链模式？应用场景有哪些？ （新标签页打开原文）
  6. 第 154 题： 什么是观察者模式？应用场景有哪些？ （新标签页打开原文）
  7. 第 155 题： 什么是状态模式？应用场景有哪些？ （新标签页打开原文）
  8. 第 156 题： 什么是模板方法模式？应用场景有哪些？ （新标签页打开原文）
  9. 第 157 题： 什么是工厂模式？3种实现方式的区别和特点？ （新标签页打开原文）
  10. 第 158 题： 什么是享元模式？应用场景有哪些？ （新标签页打开原文）
  11. 第 159 题： 策略模式和工厂模式的区别？ （新标签页打开原文）
  12. 第 160 题： 策略模式和 if-else 相比有什么好处？ （新标签页打开原文）

Spring 面试题

22 道题
  1. 第 161 题： SpringBoot 和 Spring 的区别是什么？ （新标签页打开原文）
  2. 第 162 题： Spring 中创建 Bean 有几种方式？ （新标签页打开原文）
  3. 第 163 题： Spring 中的 Bean 是线程安全的吗？ （新标签页打开原文）
  4. 第 164 题： Spring 中 Bean 的作用域有哪些？ （新标签页打开原文）
  5. 第 165 题： @Autowired 和 @Resource 注解的区别？ （新标签页打开原文）
  6. 第 166 题： Spring Bean 的生命周期是怎么样的？ （新标签页打开原文）
  7. 第 167 题： 谈谈 Spring 的 AOP？ （新标签页打开原文）
  8. 第 168 题： 谈谈 Spring 的 IOC？ （新标签页打开原文）
  9. 第 169 题： Spring 的 AOP 在什么场景下会失效？ （新标签页打开原文）
  10. 第 170 题： Spring 中用到了哪些设计模式？ （新标签页打开原文）
  11. 第 171 题： BeanFactory 和 FactroyBean 的关系？ （新标签页打开原文）
  12. 第 172 题： 什么是 Spring 的三级缓存？ （新标签页打开原文）
  13. 第 173 题： 什么是 Spring 的循环依赖问题？ （新标签页打开原文）
  14. 第 174 题： Spring 的事务传播机制有哪些？ （新标签页打开原文）
  15. 第 175 题： Spring 事务失效可能是哪些原因？ （新标签页打开原文）
  16. 第 176 题： 如何在 Spring 启动过程中做缓存预热？ （新标签页打开原文）
  17. 第 177 题： 什么是 Spring MVC 三层架构？ （新标签页打开原文）
  18. 第 178 题： SpringBoot 的启动流程是怎样的？ （新标签页打开原文）
  19. 第 179 题： SpringBoot 如何实现 main 方法启动 Web 容器的？ （新标签页打开原文）
  20. 第 180 题： SpringBoot 自动配置是如何实现的？ （新标签页打开原文）
  21. 第 181 题： SpringMVC 处理请求的流程是怎样的？ （新标签页打开原文）
  22. 第 182 题： Spring Boot Controller 层怎么实现并发安全的？ （新标签页打开原文）

Tomcat 面试题

5 道题
  1. 第 183 题： 过滤器和拦截器的区别是什么？ （新标签页打开原文）
  2. 第 184 题： 介绍一下 Tomcat 的 IO 模型？ （新标签页打开原文）
  3. 第 185 题： Tomcat 的类加载机制是怎样的？ （新标签页打开原文）
  4. 第 186 题： Tomcat 中有哪些类加载器？ （新标签页打开原文）
  5. 第 187 题： 为什么 Tomcat 默认最大线程数是 200，而不是 N+1？ （新标签页打开原文）

Zookeeper 面试题

9 道题
  1. 第 188 题： Zookeeper 是干什么的？ （新标签页打开原文）
  2. 第 189 题： Zookeeper 是 CP 的还是 AP 的？ （新标签页打开原文）
  3. 第 190 题： Zookeeper 的典型应用场景有哪些？ （新标签页打开原文）
  4. 第 191 题： Zookeeper 的数据结构是怎样的？ （新标签页打开原文）
  5. 第 192 题： Zookeeper 的 watch 机制是如何工作的？ （新标签页打开原文）
  6. 第 193 题： 如何通过 Zookeeper 实现服务注册与发现？ （新标签页打开原文）
  7. 第 194 题： 如何用 Zookeeper 实现分布式锁？ （新标签页打开原文）
  8. 第 195 题： Zookeeper 脑裂是什么？怎么解决？ （新标签页打开原文）
  9. 第 196 题： Zookeeper 是如何保证创建的节点是唯一的？ （新标签页打开原文）

RabbitMQ 面试题

9 道题
  1. 第 197 题： RabbitMQ 的整体架构是怎样的？ （新标签页打开原文）
  2. 第 198 题： RabbitMQ 是如何保证高可用的？ （新标签页打开原文）
  3. 第 199 题： RabbitMQ 如何防止重复消费？ （新标签页打开原文）
  4. 第 200 题： RabbitMQ 如何保证消息不丢失？ （新标签页打开原文）
  5. 第 201 题： RabbitMQ 怎么实现延迟消息？ （新标签页打开原文）
  6. 第 202 题： 什么是 RabbitMQ 的死信队列？ （新标签页打开原文）
  7. 第 203 题： 说说 RabbitMQ 的事务机制？ （新标签页打开原文）
  8. 第 204 题： RabbitMQ 如何实现消费端限流？ （新标签页打开原文）
  9. 第 205 题： 怎么保证消息一定能发送到 RabbitMQ？ （新标签页打开原文）

JVM 面试题

26 道题
  1. 第 206 题： 有哪些常用的 JVM 启动参数？ （新标签页打开原文）
  2. 第 207 题： Java 是编译型还是解释型语言？ （新标签页打开原文）
  3. 第 208 题： Java 类加载的过程是怎样的？ （新标签页打开原文）
  4. 第 209 题： JVM 如何判断对象是否存活的？ （新标签页打开原文）
  5. 第 210 题： JVM 垃圾回收算法有哪些？ （新标签页打开原文）
  6. 第 211 题： 内存泄漏和内存溢出的区别是什么？ （新标签页打开原文）
  7. 第 212 题： 新生代和老年代的 GC 算法有哪些？ （新标签页打开原文）
  8. 第 213 题： 什么是强引用、软引用、弱引用和虚引用？ （新标签页打开原文）
  9. 第 214 题： 什么是双亲委派？怎么破坏？ （新标签页打开原文）
  10. 第 215 题： 项目中是如何选择垃圾回收器的？为啥选择这个？ （新标签页打开原文）
  11. 第 216 题： FullGC 多久一次正常？ （新标签页打开原文）
  12. 第 217 题： JVM 中一次完整的 GC 流程是怎样的？ （新标签页打开原文）
  13. 第 218 题： YoungGC 和 FullGC 的触发条件是什么？ （新标签页打开原文）
  14. 第 219 题： 什么情况会导致 JVM 退出？ （新标签页打开原文）
  15. 第 220 题： 什么是 Class 常量池，和运行时常量池区别是什么？ （新标签页打开原文）
  16. 第 221 题： 什么是 AOT 编译？和 JIT 有什么区别？ （新标签页打开原文）
  17. 第 222 题： JVM 运行时内存区域如何划分的？ （新标签页打开原文）
  18. 第 223 题： OOM 引起原因以及如何排查？ （新标签页打开原文）
  19. 第 224 题： CMS 和 G1 垃圾回收器的区别是什么？ （新标签页打开原文）
  20. 第 225 题： CMS 的底层原理是什么？优势在哪？ （新标签页打开原文）
  21. 第 226 题： 满足什么条件时，一个 Java 类会被卸载？ （新标签页打开原文）
  22. 第 227 题： JVM 对 Synchronized 关键字的实现是怎样的？ （新标签页打开原文）
  23. 第 228 题： Spring 第一次启动执行慢，从 JVM 角度讲讲？ （新标签页打开原文）
  24. 第 229 题： 线上 Full GC 频繁，如何排查解决？ （新标签页打开原文）
  25. 第 230 题： JVM 类加载器如何保证核心类库不被覆盖？ （新标签页打开原文）
  26. 第 231 题： 运行时常量池和字符串常量池的关系是什么？ （新标签页打开原文）

计算机网络面试题

14 道题
  1. 第 232 题： 什么是 TCP 三次握手、四次挥手？ （新标签页打开原文）
  2. 第 233 题： Cookie、Session、Token 的区别是什么？ （新标签页打开原文）
  3. 第 234 题： TCP 是怎么保证可靠传输的？ （新标签页打开原文）
  4. 第 235 题： HTTPS 和 HTTP 的区别是什么？ （新标签页打开原文）
  5. 第 236 题： 对称加密和非对称加密有什么区别？ （新标签页打开原文）
  6. 第 237 题： TCP 和 UDP 的区别是什么？ （新标签页打开原文）
  7. 第 238 题： 什么是跨域访问问题，怎么解决？ （新标签页打开原文）
  8. 第 239 题： 什么是 TCP 的粘包、拆包问题？ （新标签页打开原文）
  9. 第 240 题： 什么是网络分区？ （新标签页打开原文）
  10. 第 241 题： 什么是正向代理和反向代理？ （新标签页打开原文）
  11. 第 242 题： 什么是 IPv6？和 IPv4 有什么区别？ （新标签页打开原文）
  12. 第 243 题： 什么是 CDN？为什么它可以做缓存？ （新标签页打开原文）
  13. 第 244 题： 路由器与交换机的区别是什么？ （新标签页打开原文）
  14. 第 245 题： 浏览器输入 www.quanxiaoha.com，回车之后发生了什么？ （新标签页打开原文）

操作系统面试题

21 道题
  1. 第 246 题： GPU 和 CPU 的区别？为什么挖矿、大模型都用 GPU？ （新标签页打开原文）
  2. 第 247 题： 什么是操作系统的多级缓存？ （新标签页打开原文）
  3. 第 248 题： 什么是用户态、内核态？如何切换的？ （新标签页打开原文）
  4. 第 249 题： 同步、异步、阻塞、非阻塞怎么理解？ （新标签页打开原文）
  5. 第 250 题： 操作系统的 IO 模型有哪些？ （新标签页打开原文）
  6. 第 251 题： 什么是 CPU 利用率？怎么算的？ （新标签页打开原文）
  7. 第 252 题： 什么是时间片？ （新标签页打开原文）
  8. 第 253 题： 什么是 Load（负载）？ （新标签页打开原文）
  9. 第 254 题： 负载（Load）和 CPU 利用率之间有什么区别？ （新标签页打开原文）
  10. 第 255 题： 什么是 IO 密集，什么是 CPU 密集？ （新标签页打开原文）
  11. 第 256 题： 进程、线程和协程的区别是什么？ （新标签页打开原文）
  12. 第 257 题： 进程间通信方式有哪些？ （新标签页打开原文）
  13. 第 258 题： 什么是 PageCache？它的读写过程是怎么样的？有什么优缺点？ （新标签页打开原文）
  14. 第 259 题： 什么是全双工和半双工？ （新标签页打开原文）
  15. 第 260 题： 什么是零拷贝？ （新标签页打开原文）
  16. 第 261 题： 什么是分段和分页？ （新标签页打开原文）
  17. 第 262 题： 为什么按位与运算要比取模运算高效？ （新标签页打开原文）
  18. 第 263 题： IO 多路复用和多线程有什么区别？ （新标签页打开原文）
  19. 第 264 题： 如何理解 select、poll、epoll？ （新标签页打开原文）
  20. 第 265 题： 什么是 MESI 缓存一致性协议？ （新标签页打开原文）
  21. 第 266 题： 你掌握哪些 Linux 常用命令？ （新标签页打开原文）

Dubbo 面试题

12 道题
  1. 第 267 题： Dubbo 的整体架构是怎样的？ （新标签页打开原文）
  2. 第 268 题： Dubbo 服务发现与路由的概念有什么不同？ （新标签页打开原文）
  3. 第 269 题： Dubbo 的 SPI 和 JDK 的 SPI 有什么区别？ （新标签页打开原文）
  4. 第 270 题： 为什么 RPC 要比 HTTP 更快？ （新标签页打开原文）
  5. 第 271 题： Dubbo 如何实现像本地方法一样调用远程方法的？ （新标签页打开原文）
  6. 第 272 题： Dubbo 的服务调用过程是什么样的？ （新标签页打开原文）
  7. 第 273 题： 什么是 Dubbo 的优雅停机，怎么实现的？ （新标签页打开原文）
  8. 第 274 题： Dubbo 支持哪些序列化方式？ （新标签页打开原文）
  9. 第 275 题： Dubbo 支持哪些负载均衡策略？ （新标签页打开原文）
  10. 第 276 题： Dubbo 支持哪些调用协议？ （新标签页打开原文）
  11. 第 277 题： 有用过 Dubbo 的异步调用吗？ （新标签页打开原文）
  12. 第 278 题： Dubbo 的缓存机制了解吗？ （新标签页打开原文）

RAG 面试题

17 道题
  1. 第 279 题： 什么是 RAG？为什么需要 RAG？ （新标签页打开原文）
  2. 第 280 题： RAG 的完整流程是什么？ （新标签页打开原文）
  3. 第 281 题： 为什么 RAG 要用向量数据库？其他数据库不行吗？ （新标签页打开原文）
  4. 第 282 题： Embedding 是什么？1536 维什么意思？ （新标签页打开原文）
  5. 第 283 题： 你是怎么做分块的？块大小怎么选的？ （新标签页打开原文）
  6. 第 284 题： 固定大小分块有什么问题？ （新标签页打开原文）
  7. 第 285 题： RAG vs 微调 vs 提示工程，什么时候用哪个？ （新标签页打开原文）
  8. 第 286 题： 混合检索是什么？为什么要用混合检索而不是纯向量检索？ （新标签页打开原文）
  9. 第 287 题： 什么是重排序（Rerank）？为什么检索之后还要重排序？ （新标签页打开原文）
  10. 第 288 题： 递归分块和语义分块的区别？ （新标签页打开原文）
  11. 第 289 题： RAG 系统常见的失败模式有哪些？检索质量差怎么排查和优化？ （新标签页打开原文）
  12. 第 290 题： 什么是 RAG 查询改写（Query Rewriting）？它怎么提升检索效果的？ （新标签页打开原文）
  13. 第 291 题： RAG 中的幻觉问题怎么处理？ （新标签页打开原文）
  14. 第 292 题： 常用向量数据库怎么选型？ （新标签页打开原文）
  15. 第 293 题： 什么是假设性文档嵌入（ HyDE）？它的工作原理是什么？ （新标签页打开原文）
  16. 第 294 题： 如何评估 RAG 系统的效果？常用的评估指标有哪些？ （新标签页打开原文）
  17. 第 295 题： 什么是 Self-RAG？它如何通过自我反思提升回答质量？ （新标签页打开原文）

AI Agent 面试题

12 道题
  1. 第 296 题： 什么是 Agent？与大模型有什么本质不同？ （新标签页打开原文）
  2. 第 297 题： Agent 的基本架构由哪些核心组件构成？ （新标签页打开原文）
  3. 第 298 题： Workflow、Agent、Tools 这三个的概念和区别介绍一下？ （新标签页打开原文）
  4. 第 299 题： ReAct、Plan-and-Execute、Reflection 三种范式有什么核心区别？实际项目怎么选型？ （新标签页打开原文）
  5. 第 300 题： 请介绍一下 AI Agent 的记忆机制？实际开发中怎么设计记忆模块？ （新标签页打开原文）
  6. 第 301 题： Agent 的长短期记忆系统怎么做的？记忆怎么存？粒度是多少？怎么用？ （新标签页打开原文）
  7. 第 302 题： Agent 推理模式有哪些？ReAct 具体是怎么实现的？ （新标签页打开原文）
  8. 第 303 题： Agent 记忆压缩通常有哪些方法？ （新标签页打开原文）
  9. 第 304 题： 什么是 Multi-Agent？Single-Agent 和 Multi-Agent 的设计方案？ （新标签页打开原文）
  10. 第 305 题： 讲讲 Agent 的反思机制？为什么要用反思？具体怎么实现？ （新标签页打开原文）
  11. 第 306 题： 复杂任务怎么做的任务拆分？为什么要拆分？效果如何提升？ （新标签页打开原文）
  12. 第 307 题： 如何设计多 Agent 的协作与动态切换机制？ （新标签页打开原文）

Netty 面试题

10 道题
  1. 第 308 题： 为什么 Netty 适合做网络编程？ （新标签页打开原文）
  2. 第 309 题： Netty 性能好的原因是什么？ （新标签页打开原文）
  3. 第 310 题： Netty 如何解决 TCP 粘包、拆包的问题？ （新标签页打开原文）
  4. 第 311 题： Netty 有哪些序列化协议？ （新标签页打开原文）
  5. 第 312 题： Netty 的零拷贝是怎么实现的？ （新标签页打开原文）
  6. 第 313 题： Netty 的线程模型是怎么样的？ （新标签页打开原文）
  7. 第 314 题： Netty 的 ByteBuf 为什么好用？ （新标签页打开原文）
  8. 第 315 题： 说说 Netty 的对象池技术？ （新标签页打开原文）
  9. 第 316 题： 谈谈 Netty 的无锁化设计？ （新标签页打开原文）
  10. 第 317 题： Netty 中用了哪些设计模式？ （新标签页打开原文）

分库分表面试题

14 道题
  1. 第 318 题： 什么是分库？分表？分库分表？ （新标签页打开原文）
  2. 第 319 题： 分库分表后会带来哪些问题？ （新标签页打开原文）
  3. 第 320 题： 什么是数据倾斜，会带来哪些问题？如何解决？ （新标签页打开原文）
  4. 第 321 题： 分区和分表有什么区别？ （新标签页打开原文）
  5. 第 322 题： 分表字段如何选择？ （新标签页打开原文）
  6. 第 323 题： 分库分表的数量为什么一般选择 2 的幂？ （新标签页打开原文）
  7. 第 324 题： 分表后全局 ID 如何生成？ （新标签页打开原文）
  8. 第 325 题： 分库分表后如何进行分页查询？ （新标签页打开原文）
  9. 第 326 题： 分表算法都有哪些？ （新标签页打开原文）
  10. 第 327 题： 分库分表的取模算法策略，怎么避免数据倾斜？ （新标签页打开原文）
  11. 第 328 题： 分库分表之后怎么进行 Join 操作？ （新标签页打开原文）
  12. 第 329 题： 分库分表中，如何预估需要分多少个库？多少张表？ （新标签页打开原文）
  13. 第 330 题： 分库分表后，怎么设计，可以降低数据迁移的难度？ （新标签页打开原文）
  14. 第 331 题： ShardingJDBC 有哪些分片策略,你用的哪个? （新标签页打开原文）

高并发面试题

8 道题
  1. 第 332 题： 高并发场景中，乐观锁和悲观锁哪个更适合？ （新标签页打开原文）
  2. 第 333 题： 漏桶和令牌桶有啥区别？ （新标签页打开原文）
  3. 第 334 题： 什么是熔断？ （新标签页打开原文）
  4. 第 335 题： 什么是预热？它有什么作用？ （新标签页打开原文）
  5. 第 336 题： 什么是服务降级？ （新标签页打开原文）
  6. 第 337 题： 什么是限流？常见的限流算法有哪些？ （新标签页打开原文）
  7. 第 338 题： 什么是自适应限流？ （新标签页打开原文）
  8. 第 339 题： 单机限流和集群限流的区别是什么? （新标签页打开原文）

高可用面试题

2 道题
  1. 第 340 题： 什么是异地多活？ （新标签页打开原文）
  2. 第 341 题： 什么是冷备、热备，暖备？ （新标签页打开原文）

Elasticsearch 面试题

9 道题
  1. 第 342 题： 为什么要使用 ElasticSearch？和传统关系数据库（如 MySQL）有什么不同？ （新标签页打开原文）
  2. 第 343 题： ElasticSearch 为什么快？ （新标签页打开原文）
  3. 第 344 题： ES 支持哪些数据类型，和 MySQL 之间的映射关系是怎么样的？ （新标签页打开原文）
  4. 第 345 题： 倒排索引是什么？ （新标签页打开原文）
  5. 第 346 题： ES 不支持 decimal，如何避免丢失精度？ （新标签页打开原文）
  6. 第 347 题： Elasticsearch 支持事务吗？为什么？ （新标签页打开原文）
  7. 第 348 题： 什么是 Elasticsearch 的深度分页问题？如何解决？ （新标签页打开原文）
  8. 第 349 题： 如何优化 ElasticSearch 搜索性能？ （新标签页打开原文）
  9. 第 350 题： 如何保证 ES 和数据库的数据一致性？ （新标签页打开原文）
回到顶部 ↑