java面试大全;java面试精选 收藏 0

史上最全499道Java面试题：JVM+分布式+算法+锁+MQ+微服务+数据库

1. JAVA中的几种基本数据类型是什么，各自占用多少字节。
2. String类能被继承吗，为什么。
3. String，Stringbuffer，StringBuilder的区别。
4. ArrayList和LinkedList有什么区别。
5. 讲讲类的实例化顺序，比如父类静态数据，构造函数，字段，子类静态数据，构造函数，字段，当new的时候，他们的执行顺序。
6. 用过哪些Map类，都有什么区别，HashMap是线程安全的吗,并发下使用的Map是什么，他们内部原理分别是什么，比如存储方式，hashcode，扩容，默认容量等。
7. JAVA8的ConcurrentHashMap为什么放弃了分段锁，有什么问题吗，如果你来设计，你如何设计。
8. 有没有有顺序的Map实现类，如果有，他们是怎么保证有序的。
9. 抽象类和接口的区别，类可以继承多个类么，接口可以继承多个接口么,类可以实现多个接口么。
10. 继承和聚合的区别在哪。
11. IO模型有哪些，讲讲你理解的nio ，他和bio，aio的区别是啥，谈谈reactor模型。
12. 反射的原理，反射创建类实例的三种方式是什么。
13. 反射中，Class.forName和ClassLoader区别 。
14. 描述动态代理的几种实现方式，分别说出相应的优缺点。
15. 动态代理与cglib实现的区别。
16. 为什么CGlib方式可以对接口实现代理。
17. final的用途。
18. 写出三种单例模式实现 。
19. 如何在父类中为子类自动完成所有的hashcode和equals实现？这么做有何优劣。
20. 请结合OO设计理念，谈谈访问修饰符public、private、protected、default在应用设计中的作用。
21. 深拷贝和浅拷贝区别。
22. 数组和链表数据结构描述，各自的时间复杂度。
23. error和exception的区别，CheckedException，RuntimeException的区别。
24. 请列出5个运行时异常。
25. 在自己的代码中，如果创建一个java.lang.String类，这个类是否可以被类加载器加载？为什么。
26. 说一说你对java.lang.Object对象中hashCode和equals方法的理解。在什么场景下需
27. 要重新实现这两个方法。
28. 在jdk1.5中，引入了泛型，泛型的存在是用来解决什么问题。
29. 这样的a.hashcode() 有什么用，与a.equals(b)有什么关系。
30. 有没有可能2个不相等的对象有相同的hashcode。
31. Java中的HashSet内部是如何工作的。
32. 什么是序列化，怎么序列化，为什么序列化，反序列化会遇到什么问题，如何解决。
33. java8的新特性。

1. 什么情况下会发生栈内存溢出。
2. JVM的内存结构，Eden和Survivor比例。
3. JVM内存为什么要分成新生代，老年代，持久代。新生代中为什么要分为Eden和Survivor。
4. JVM中一次完整的GC流程是怎样的，对象如何晋升到老年代，说说你知道的几种主要的JVM参
5. 数。
6. 你知道哪几种垃圾收集器，各自的优缺点，重点讲下cms和G1，包括原理，流程，优缺点。
7. 垃圾回收算法的实现原理。
8. 当出现了内存溢出，你怎么排错。
9. JVM内存模型的相关知识了解多少，比如重排序，内存屏障，happen-before，主内存，工作
10. 内存等。
11. 简单说说你了解的类加载器，可以打破双亲委派么，怎么打破。
12. 讲讲JAVA的反射机制。
13. 你们线上应用的JVM参数有哪些。
14. g1和cms区别,吞吐量优先和响应优先的垃圾收集器选择。
15. 怎么打出线程栈信息。
16. 请解释如下jvm参数的含义：
17. -server -Xms512m -Xmx512m -Xss1024K
18. -XX:PermSize=256m -XX:MaxPermSize=512m –
19. XX:MaxTenuringThreshold=20XX:CMSInitiatingOccupancyFraction=80 –
20. XX:+UseCMSInitiatingOccupancyOnly。

1. 简单讲讲tomcat结构，以及其类加载器流程，线程模型等。
2. tomcat如何调优，涉及哪些参数 。
3. 讲讲Spring加载流程。
4. Spring AOP的实现原理。
5. 讲讲Spring事务的传播属性。
6. Spring如何管理事务的。
7. Spring怎么配置事务（具体说出一些关键的xml 元素）。
8. 说说你对Spring的理解，非单例注入的原理？它的生命周期？循环注入的原理，aop的实现原
9. 理，说说aop中的几个术语，它们是怎么相互工作的。
10. Springmvc 中DispatcherServlet初始化过程。
11. netty的线程模型，netty如何基于reactor模型上实现的。
12. 为什么选择netty。
13. 什么是TCP粘包，拆包。解决方式是什么。
14. netty的fashwheeltimer的用法，实现原理，是否出现过调用不够准时，怎么解决。
15. netty的心跳处理在弱网下怎么办。
16. netty的通讯协议是什么样的。
17. springmvc用到的注解，作用是什么，原理。
18. springboot启动机制。
19. 点击这里有一套答案版的Spring试题。

1. Linux系统下你关注过哪些内核参数，说说你知道的。
2. Linux下IO模型有几种，各自的含义是什么。
3. epoll和poll有什么区别。
4. 平时用到哪些Linux命令。
5. 用一行命令查看文件的最后五行。
6. 用一行命令输出正在运行的java进程。
7. 介绍下你理解的操作系统中线程切换过程。
8. 进程和线程的区别。
9. top 命令之后有哪些内容，有什么作用。
10. 线上CPU爆高，请问你如何找到问题所在。

1. 多线程的几种实现方式，什么是线程安全。
2. volatile的原理，作用，能代替锁么。
3. 画一个线程的生命周期状态图。
4. sleep和wait的区别。
5. sleep和sleep(0)的区别。
6. Lock与Synchronized的区别 。
7. synchronized的原理是什么，一般用在什么地方(比如加在静态方法和非静态方法的区别，静
8. 态方法和非静态方法同时执行的时候会有影响吗)，解释以下名词：重排序，自旋锁，偏向锁，轻
9. 量级锁，可重入锁，公平锁，非公平锁，乐观锁，悲观锁。
10. 用过哪些原子类，他们的原理是什么。
11. JUC下研究过哪些并发工具，讲讲原理。
12. 用过线程池吗，如果用过，请说明原理，并说说newCache和newFixed有什么区别，构造函
13. 数的各个参数的含义是什么，比如coreSize，maxsize等。
14. 线程池的关闭方式有几种，各自的区别是什么。
15. 假如有一个第三方接口，有很多个线程去调用获取数据，现在规定每秒钟最多有10个线程同
16. 时调用它，如何做到。
17. spring的controller是单例还是多例，怎么保证并发的安全。
18. 用三个线程按顺序循环打印abc三个字母，比如abcabcabc。
19. ThreadLocal用过么，用途是什么，原理是什么，用的时候要注意什么。
20. 如果让你实现一个并发安全的链表，你会怎么做。
21. 有哪些无锁数据结构，他们实现的原理是什么。
22. 讲讲java同步机制的wait和notify。
23. CAS机制是什么，如何解决ABA问题。
24. 多线程如果线程挂住了怎么办。
25. countdowlatch和cyclicbarrier的内部原理和用法，以及相互之间的差别(比如
26. countdownlatch的await方法和是怎么实现的)。
27. 对AbstractQueuedSynchronizer了解多少，讲讲加锁和解锁的流程，独占锁和公平所
28. 加锁有什么不同。
29. 使用synchronized修饰静态方法和非静态方法有什么区别。
30. 简述ConcurrentLinkedQueue和LinkedBlockingQueue的用处和不同之处。
31. 导致线程死锁的原因？怎么解除线程死锁。
32. 非常多个线程（可能是不同机器），相互之间需要等待协调，才能完成某种工作，问怎么设计这种协调方案。
33. 用过读写锁吗，原理是什么，一般在什么场景下用。
34. 开启多个线程，如果保证顺序执行，有哪几种实现方式，或者如何保证多个线程都执行完
35. 再拿到结果。
36. 延迟队列的实现方式，delayQueue和时间轮算法的异同。
37. 点击这里有一套答案版的多线程试题。

1. http1.0和http1.1有什么区别。
2. TCP三次握手和四次挥手的流程，为什么断开连接要4次,如果握手只有两次，会出现什么。
3. TIME_WAIT和CLOSE_WAIT的区别。
4. 说说你知道的几种HTTP响应码，比如200, 302, 404。
5. 当你用浏览器打开一个链接（如：http://www.javastack.cn）的时候，计算机做了哪些工作步骤。
6. TCP/IP如何保证可靠性，说说TCP头的结构。
7. 如何避免浏览器缓存。
8. 如何理解HTTP协议的无状态性。
9. 简述Http请求get和post的区别以及数据包格式。
10. HTTP有哪些method
11. 简述HTTP请求的报文格式。
12. HTTP的长连接是什么意思。
13. HTTPS的加密方式是什么，讲讲整个加密解密流程。
14. Http和https的三次握手有什么区别。
15. 什么是分块传送。
16. Session和cookie的区别。
17. 点击这里有一套答案版的试题。

1. 用java自己实现一个LRU。
2. 分布式集群下如何做到唯一序列号。
3. 设计一个秒杀系统，30分钟没付款就自动关闭交易。
4. 如何使用redis和zookeeper实现分布式锁？有什么区别优缺点，会有什么问题，分别适用什么
5. 场景。（延伸：如果知道redlock，讲讲他的算法实现，争议在哪里）
6. 如果有人恶意创建非法连接，怎么解决。
7. 分布式事务的原理，优缺点，如何使用分布式事务，2pc 3pc 的区别，解决了哪些问题，还有
8. 哪些问题没解决，如何解决，你自己项目里涉及到分布式事务是怎么处理的。
9. 什么是一致性hash。
10. 什么是restful，讲讲你理解的restful。
11. 如何设计一个良好的API。
12. 如何设计建立和保持100w的长连接。
13. 解释什么是MESI协议(缓存一致性)。
14. 说说你知道的几种HASH算法，简单的也可以。
15. 什么是paxos算法， 什么是zab协议。
16. 一个在线文档系统，文档可以被编辑，如何防止多人同时对同
17. 一份文档进行编辑更新。
18. 线上系统突然变得异常缓慢，你如何查找问题。
19. 说说你平时用到的设计模式。
20. Dubbo的原理，有看过源码么，数据怎么流转的，怎么实现集群，负载均衡，服务注册
21. 和发现，重试转发，快速失败的策略是怎样的 。
22. 一次RPC请求的流程是什么。
23. 自己实现过rpc么，原理可以简单讲讲。Rpc要解决什么问题。
24. 异步模式的用途和意义。
25. 编程中自己都怎么考虑一些设计原则的，比如开闭原则，以及在工作中的应用。
26. 设计一个社交网站中的“私信”功能，要求高并发、可扩展等等。 画一下架构图。
27. MVC模式，即常见的MVC框架。
28. 聊下曾经参与设计的服务器架构并画图，谈谈遇到的问题，怎么解决的。
29. 应用服务器怎么监控性能，各种方式的区别。
30. 如何设计一套高并发支付方案，架构如何设计。
31. 如何实现负载均衡，有哪些算法可以实现。
32. Zookeeper的用途，选举的原理是什么。
33. Zookeeper watch机制原理。
34. Mybatis的底层实现原理。
35. 请思考一个方案，实现分布式环境下的countDownLatch。
36. 后台系统怎么防止请求重复提交。
37. 描述一个服务从发布到被消费的详细过程。
38. 讲讲你理解的服务治理。
39. 如何做到接口的幂等性。
40. 如何做限流策略，令牌桶和漏斗算法的使用场景。
41. 什么叫数据一致性，你怎么理解数据一致性。
42. 分布式服务调用方，不依赖服务提供方的话，怎么处理服务方挂掉后，大量无效资源请求
43. 的浪费，如果只是服务提供方吞吐不高的时候该怎么做，如果服务挂了，那么一会重启，该怎
44. 么做到最小的资源浪费，流量半开的实现机制是什么。
45. dubbo的泛化调用怎么实现的，如果是你，你会怎么做。
46. 远程调用会有超时现象，如果做到优雅的控制，JDK自带的超时机制有哪些，怎么实现的。

1. 10亿个数字里里面找最小的10个。
2. 有1亿个数字，其中有2个是重复的，快速找到它，时间和空间要最优。
3. 2亿个随机生成的无序整数,找出中间大小的值。
4. 给一个不知道长度的（可能很大）输入字符串，设计一种方案，将重复的字符排重。
5. 遍历二叉树。
6. 有3n+1个数字，其中3n个中是重复的，只有1个是不重复的，怎么找出来。
7. 写一个字符串（如：www.javastack.cn）反转函数。
8. 常用的排序算法，，归并、冒泡。 的最优时间复杂度，最差复杂度。冒泡排序的
9. 优化方案。
10. 二分查找的时间复杂度，优势。
11. 一个已经构建好的TreeSet，怎么完成倒排序。
12. 什么是B+树，B-树，列出实际的使用场景。
13. 一个单向链表，删除倒数第N个数据。
14. 200个有序的数组，每个数组里面100个元素，找出top20的元素。
15. 单向链表，查找中间的那个元素。

1. 数据库隔离级别有哪些，各自的含义是什么，MYSQL默认的隔离级别是是什么。
2. 什么是幻读。
3. MYSQL有哪些存储引擎，各自优缺点。
4. 高并发下，如何做到安全的修改同一行数据。
5. 乐观锁和悲观锁是什么，INNODB的标准行级锁有哪2种，解释其含义。
6. SQL优化的一般步骤是什么，怎么看执行计划，如何理解其中各个字段的含义。
7. 数据库会死锁吗，举一个死锁的例子，mysql怎么解决死锁。
8. MYsql的索引原理，索引的类型有哪些，如何创建合理的索引，索引如何优化。
9. 聚集索引和非聚集索引的区别。
10. select for update 是什么含义，会锁表还是锁行或是其他。
11. 为什么要用Btree实现，它是怎么分裂的，什么时候分裂，为什么是平衡的。
12. 数据库的ACID是什么。
13. 某个表有近千万数据，CRUD比较慢，如何优化。
14. Mysql怎么优化table scan的。
15. 如何写sql能够有效的使用到复合索引。
16. mysql中in 和exists 区别。
17. 数据库自增主键可能的问题。
18. MVCC的含义，如何实现的。
19. 你做过的项目里遇到分库分表了吗，怎么做的，有用到中间件么，比如sharding jdbc等,他
20. 们的原理知道么。
21. MYSQL的主从延迟怎么解决。

1. 消息队列的使用场景。
2. 消息的重发，补充策略。
3. 如何保证消息的有序性。
4. 用过哪些MQ，和其他mq比较有什么优缺点，MQ的连接是线程安全的吗，你们公司的MQ服务
5. 架构怎样的。
6. MQ系统的数据如何保证不丢失。
7. rabbitmq如何实现集群高可用。
8. kafka吞吐量高的原因。
9. kafka 和其他消息队列的区别，kafka 主从同步怎么实现。
10. 利用mq怎么实现最终一致性。
11. 使用kafka有没有遇到什么问题，怎么解决的。
12. MQ有可能发生重复消费，如何避免，如何做到幂等。
13. MQ的消息延迟了怎么处理，消息可以设置过期时间么，过期了你们一般怎么处理。

1. 常见的缓存策略有哪些，如何做到缓存(比如redis)与DB里的数据一致性，你们项目中用到了
2. 什么缓存系统，如何设计的。
3. 如何防止缓存击穿和雪崩。
4. 缓存数据过期后的更新如何设计。
5. redis的list结构相关的操作。
6. Redis的数据结构都有哪些。
7. Redis的使用要注意什么，讲讲持久化方式，内存设置，集群的应用和优劣势，淘汰策略等。
8. redis2和redis3的区别，redis3内部通讯机制。
9. 当前redis集群有哪些玩法，各自优缺点，场景。
10. Memcache的原理，哪些数据适合放在缓存中。
11. redis和memcached 的内存管理的区别。
12. Redis的并发竞争问题如何解决，了解Redis事务的CAS操作吗。
13. Redis的选举算法和流程是怎样的。
14. redis的持久化的机制，aof和rdb的区别。
15. redis的集群怎么同步的数据的。
16. 知道哪些redis的优化操作。
17. Reids的主从复制机制原理。
18. Redis的线程模型是什么。
19. 请思考一个方案，设计一个可以控制缓存总体大小的自动适应的本地缓存。
20. 如何看待缓存的使用（本地缓存，集中式缓存），简述本地缓存和集中式缓存和优缺点。
21. 本地缓存在并发使用时的注意事项。

1. elasticsearch了解多少，说说你们公司es的集群架构，索引数据大小，分片有多少，以及一些
2. 调优手段 。elasticsearch的倒排索引是什么。
3. elasticsearch 索引数据多了怎么办，如何调优，部署。
4. elasticsearch是如何实现master选举的。
5. 详细描述一下Elasticsearch索引文档的过程。
6. 详细描述一下Elasticsearch搜索的过程。
7. Elasticsearch在部署时，对Linux的设置有哪些优化方法？
8. lucence内部结构是什么。

以上是总结出的最全Java面试题目，以下是最新总结出的BAT面试java必考题目和答案。

2020最新BAT高级java面试题和答案领取方法：

关注+转发后，私信关键词 【面试资料】即可领到答案！

重要的事情说三遍，转发、转发、转发后再发私信，才可以拿到哦！

Java面试题及答案最全总结(2023版)

大家好，我是mikechen

最近很多同学在忙着找工作，给大家整理了一份非常全面的Java面试题及答案。

涉及的内容非常全面，包含：多线程、JVM、Spring、MySQL、Redis、Dubbo…等内容，希望对找工作的同学有所帮助。

文末有题目答案~

Java多线程面试题

1. 并发编程三要素？
2. 同步方法和同步块哪个是更好的选择?
3. 谈谈原子性？哪些使用到了？
4. 谈谈可见性？哪些使用到了？
5. 谈谈有序性？举一个例子？
6. 什么是线程池？
7. 线程池有哪些创建方式？
8. 谈谈四种线程池的创建？
9. newCachedThreadPool？
10. newFixedThreadPool ？
11. newScheduledThreadPool ？
12. newSingleThreadExecutor ？
13. 多线程的优缺点？
14. 创建线程的有哪些方式？
15. 谈谈各种创建线程的优缺点？
16. 对比下你应该选择哪种创建？
17. Runnable和Callable的区别？
18. 线程的状态流转图？有哪些状态？
19. 谈谈Java线程五中基本状态?画一下？
20. 各自的优缺点？
21. 线程池的优点？
22. 常用的并发集合类有哪些？
23. ConcurrentHashMap实现？
24. CopyOnWriteArrayList实现？
25. CopyOnWriteArraySet实现？
26. 谈谈COW?
27. 常用的并发工具类有哪些？
28. CyclicBarrier和CountDownLatch的应用场景？
29. CyclicBarrier和CountDownLatch的区别？
30. Semaphore的应用场景？
31. synchronized的作用？底层如何实现？
32. synchronized和ReentrantLock的区别？
33. volatile关键字的作用？底层如何实现？
34. 什么是CAS？底层如何实现？
35. CAS有哪些问题？
36. synchronized、volatile、CAS比较？
37. 什么是Future？底层如何实现？
38. 什么是FutureTask？
39. 什么是AQS？底层如何实现？
40. ReadWriteLock读写锁应用场景？
41. ReadWriteLock底层实现？
42. ThreadLocal是什么？底层如何实现？
43. 死锁的常见原因有哪些？
44. 如何避免死锁?有哪些解决方案？
45. 怎么唤醒一个阻塞的线程？
46. 什么是多线程的上下文切换？
47. 线程调度算法是什么？
48. 什么是线程调度器和时间分片？
49. 单例模式的线程安全性？
50. Executors是什么？
51. 谈谈ExecutorService，ScheduledExecutorService？

Java虚拟机面试题及答案

1. 谈谈JVM内存模型？
2. JVM内存模型，与Java内存模型的关系？
3. 谈谈堆?
4. 谈谈虚拟机栈？
5. 谈谈方法区？
6. 谈谈程序计数器？
7. 谈谈各自的配置参数？
8. JVM调优过吗？
9. 你使用哪个来调优？
10. JVM调优工具的优劣势？
11. JVM调优的方法，有哪些步骤？
12. JVM有哪些垃圾算法？
13. 标记算法原理？
14. 谈谈复制算法？原理？
15. 标记整理算法？原理？
16. 什么是分代收收集？
17. JVM有哪些垃圾收集器?
18. 串行Serial收集器
19. 并行Parallel收集器
20. CMS收集器
21. G1收集器
22. ZGC收集器
23. G1之前的JVM内存模型？
24. G1之后的JVM内存模型？
25. G1堆内存结构，G1堆内存分配？
26. G1回收流程，会经历哪些阶段？
27. JVM怎么配置参数?
28. 堆栈怎么配置？
29. 垃圾收集器怎么配置?

Spring面试题及答案

1. Spring框架的核心功能？
2. Spring框架的好处是什么？
3. 谈谈IOC控制反转？底层实现？
4. 谈谈面向切面的编程(AOP)？底层实现？
5. 谈谈MVC框架的底层实现？
6. Spring事务管理？
7. Spring异常处理？
8. Spring由哪些模块组成?
9. 谈谈BeanFactory？
10. 谈谈XMLBeanFactory？
11. 谈谈AOP模块？底层是如何实现？
12. JDBC抽象和DAO模块的关系？
13. 为什么说Spring是一个容器？
14. 谈谈Spring配置文件？
15. 谈谈依赖注入？
16. IOC的优缺点是什么？
17. 有哪些不同类型的IOC依赖注入）方式？
18. ApplicationContext实现有哪些？
19. Bean工厂和Applicationcontexts有什么区别？
20. 哪种依赖注入方式你建议使用？
21. 什么是Springbeans?包含什么？
22. 如何给Spring容器提供配置元数据?
23. 你怎样定义类的作用域?
24. 谈谈Spring支持的几种bean的作用域？
25. singleton、prototype、request的区别？
26. Spring框架中的单例bean是线程安全的吗?为什么？
27. Spring框架中bean的生命周期？画出来？
28. 哪些是重要的bean生命周期方法？
29. Spring中如何注入一个java集合？
30. 什么是bean装配?
31. 谈谈不同方式的自动装配？
32. 自动装配有哪些局限性?
33. 你可以在Spring中注入一个null和一个空字符串吗？
34. 谈谈Spring注解？
35. 什么是基于Java的Spring注解配置？
36. 什么是基于注解的容器配置?
37. 怎样开启注解装配？
38. 谈谈@Required注解？
39. 谈谈@Qualifier注解？
40. Spring通过什么方式访问Hibernate?
41. Spring支持的哪些ORM？优缺点？
42. Spring支持的事务管理类型？
43. Spring框架的事务管理有哪些优点？
44. 你更倾向用那种事务管理类型？

MySQL面试题及答案

1. MySQL有哪些常见存储引擎？
2. MySQL默认是哪个存储引擎？
3. MySQL的架构设计？
4. 详细说一下一条 MySQL 语句执行的步骤？
5. 非关系型数据库（NOSQL）的优点？
6. 谈谈数据库设计三大范式？
7. 谈谈MySQL索引？
8. MySQL表可以创建多少列索引？
9. MySQL索引包含哪些？优缺点？
10. 谈谈MySQL主键索引？
11. 谈谈MySQL唯一索引？
12. 谈谈MySQL全文索引？
13. 索引，主键，唯一索引，联合索引的区别？
14. 什么情况下设置了索引但无法使用？
15. 举几个：最典型的例子？
16. MySQL索引的底层原理，是如何实现的？
17. MySQL事务的隔离级别有哪些？区别？
18. MySQL事务的四大特征？
19. MySQL事务原理？
20. 谈谈bin log？
21. 谈谈redo log？
22. 谈谈undo log？
23. 这三种Log在MySQL应用在哪里？
24. SQL常见的查询语句有哪些？
25. 有哪些对SQL语句优化的方法？
26. Mysql中有哪几种锁？
27. 表级锁、行级锁、页面锁区别？
28. 优化数据库的方法有哪些？
29. MySQL主从复制模式？
30. 什么半同步复制？底层实现？
31. 什么是异步复制？底层实现？
32. 什么是全同步复制？底层实现？

Dubbo面试题及答案

1. 谈谈你理解的Dubbo
2. 什么是单一应用架构？
3. 什么是垂直应用架构？
4. 什么是分布式服务架构？
5. Dubbo的主要应用场景？
6. Dubbo的核心功能？
7. Dubbo的核心组件有哪些？
8. Dubbo服务注册？
9. Dubbo发现的流程?
10. Dubbo的架构设计？
11. Dubbo的架构分哪些层？
12. Dubbo服务的调用流程？
13. Dubbo支持哪些协议？
14. Dubbo各种协议的应用场景?
15. Dubbo各种协议的优缺点?
16. Dubbo推荐使用什么协议？
17. Dubbo有哪些注册中心？
18. Dubbo的服务治理？
19. Dubbo的注册中心集群挂掉？
20. Dubbo发布者和订阅者之间还能通信么？
21. Dubbo与Spring的关系？
22. dubbo 和 dubbox 之间的区别？
23. 除了Dubbo还有哪些分布式框架？
24. Dubbo和Spring Cloud的关系？
25. dubbo和spring cloud的区别？
26. Dubbo使用的是什么通信框架?
27. Dubbo提供了哪些负载均衡策略？
28. Dubbo的集群容错方案有哪些？
29. Dubbo的默认集群容错方案？
30. Dubbo支持哪些序列化方式？
31. Dubbo默认使用哪个序列化方式？
32. Dubbo超时时间怎样设置？
33. 服务调用超时问题怎么解决？
34. Dubbo在安全机制方面是如何解决？

Redis面试题及答案

1. Redis主要有哪些功能？
2. 谈谈Redis事务？
3. 谈谈Redis LUA脚本？
4. 谈谈Redis集群？
5. Redis如何做内存优化？
6. Redis回收进程如何工作的？
7. Redis哨兵机制实现原理？
8. Redis支持哪几种数据类型？
9. Redis是单进程单线程的？
10. Redis单线程设计在哪里？
11. Redis快的核心原因？
12. Redis单点吞吐量是多少？
13. 谈谈QPS、TPS？
14. Redis相比memcached有哪些优势？
15. Redis有哪几种数据淘汰策略？
16. Redis集群方案有哪些？
17. Redis各种集群方案的优劣势比较？
18. Redis集群方案应该怎么做？
19. Redis提供了哪几种持久化方式？
20. Redis各种持久化方式的实现？
21. Redis如何选择合适的持久化方式？
22. Redis常见性能问题?
23. Redis性能解决方案？
24. Redis支持的Java客户端都有哪些？
25. Redis哈希槽的概念？
26. Redis集群最大节点个数是多少？
27. Redis集群的主从复制模型是怎样的？
28. Redis集群会有写操作丢失吗？为什么？
29. Redis集群之间是如何复制的？

除此之外，还有中间件架构等面试题及答案，这里我就不一一列举了。

Java并发编程吐血1个月总结最全面的100道面试题

目录

• 一、大部分人对Java并发仍停留在理论阶段
• 二、中间件系统的内核机制：双缓冲机制
• 三、百万并发的技术挑战
• 四、内存数据写入的锁机制以及串行化问题
• 五、片机制 + 分段加锁机制
• 六、缓冲区写满时的双缓冲交换
• 七、且慢！刷写磁盘不是会导致锁持有时间过长吗？
• 八、内存 + 磁盘并行写机制
• 九、为什么必须要用双缓冲机制？
• 十、总结

这篇文章，给大家聊聊一个百万级并发的中间件系统的内核代码里的锁性能优化。

很多同学都对Java并发编程很感兴趣，学习了很多相关的技术和知识。比如volatile、Atomic、synchronized底层、读写锁、AQS、并发包下的集合类、线程池，等等。

很多同学对Java并发编程的知识，可能看了很多的书，也通过不少视频课程进行了学习。

但是，大部分人可能还是停留在理论的底层，主要是了解理论，基本对并发相关的技术很少实践和使用，更很少做过复杂的中间件系统。

实际上，真正把这些技术落地到中间件系统开发中去实践的时候，是会遇到大量的问题，需要对并发相关技术的底层有深入的理解和掌握。

然后，结合自己实际的业务场景来进行对应的技术优化、机制优化，才能实现最好的效果。

因此，本文将从笔者曾经带过的一个高并发中间件项目的内核机制出发，来看看一个实际的场景中遇到的并发相关的问题。

同时，我们也将一步步通过对应的伪代码演进，来分析其背后涉及到的并发的性能优化思想和实践，最后来看看优化之后的效果。

这个中间件项目整体就不做阐述了，因为涉及核心项目问题。我们仅仅拿其中涉及到的一个内核机制以及对应的场景来给大家做一下说明。

其实这个例子是大量的开源中间件系统、大数据系统中都有涉及到的一个场景，就是：核心数据写磁盘文件。

比如，大数据领域里的hadoop、hbase、elasitcsearch，Java中间件领域里的redis、mq，这些都会涉及到核心数据写磁盘文件的问题。

而很多大型互联网公司自研的中年间系统，同样也会有这个场景。只不过不同的中间件系统，他的作用和目标是不一样的，所以在核心数据写磁盘文件的机制设计上，是有一些区别的。

那么我们公司自研的中间件项目，简单来说，需要实现的一个效果是：开辟两块内存空间，也就是经典的内存双缓冲机制。

然后核心数据进来全部写第一块缓冲区，写满了之后，由一个线程进行那块缓冲区的数据批量刷到磁盘文件的工作，其他线程同时可以继续写另外一块缓冲区。

我们想要实现的就是这样的一个效果。这样的话，一块缓冲区刷磁盘的同时，另外一块缓冲区可以接受其他线程的写入，两不耽误。核心数据写入是不会断的，可以持续不断的写入这个中间件系统中。

我们来看看下面的那张图，也来了解一下这个场景。

如上图，首先是很多线程需要写缓冲区1，然后是缓冲区1写满之后，就会由写满的那个线程把缓冲区1的数据刷入磁盘文件，其他线程继续写缓冲区2。

这样，数据批量刷磁盘和持续写内存缓冲，两个事儿就不会耽误了，这是中间件系统设计中极为常用的一个机制，大家看下面的图。

先给大家说一下这个中间件系统的背景：这是一个服务某个特殊场景下的中间件系统，整体是集群部署。

然后每个实例部署的都是高配置机器，定位是单机承载并发达到万级甚至十万级，整体集群足以支撑百万级并发，因此对单机的写入性能和吞吐要求极为高。

在超高并发的要求之下，上图中的那个内核机制的设计就显得尤为重要了。弄的不好，就容易导致写入并发性能过差，达不到上述的要求。

此外在这里多提一句，类似的这种机制在很多其他的系统里都有涉及。比如之前一篇文章：《降级机制设计不当，线上系统瞬间崩溃…》，那里面讲的一个系统也有类似机制。

只不过不同的是，那篇文章是用这个机制来做MQ集群整体故障时的容灾降级机制，跟本文的高并发中间件系统还有点不太一样，所以在设计上考虑的一些细节也是不同的。

而且，之前那篇文章的主题是讲这种内存双缓冲机制的一个线上问题：瞬时超高并发下的系统卡死问题。

首先我们先考虑第一个问题，你多个线程会并发写同一块内存缓冲，这个肯定有问题啊！

因为内存共享数据并发写入的时候，必须是要加锁的，否则必然会有并发安全问题，导致内存数据错乱。

所以在这里，我们写了下面的伪代码，先考虑一下线程如何写入内存缓冲。

好了，这行代码弄好之后，对应着下面的这幅图，大家看一下。

看到这里，就遇到了Java并发的第一个性能问题了，你要知道高并发场景下，大量线程会并发写内存的，你要是直接这样加一个锁，必然会导致所有线程都是串行化。

即一个线程加锁，写数据，然后释放锁。接着下一个线程干同样的事情。这种串行化必然导致系统整体的并发性能和吞吐量会大幅度降低的。

因此在这里必须要对内存双缓冲机制引入分段加锁机制，也就是将内存缓冲切分为多个分片，每个内存缓冲分片就对应一个锁。

这样的话，你完全可以根据自己的系统压测结果，调整内存分片数量，提升锁的数量，进而允许大量线程高并发写入内存。

我们看下面的伪代码，对这块就实现了内存缓冲分片机制：

好！我们再来看看，目前为止的图是什么样子的：

这里因为每个线程仅仅就是加锁，写内存，然后释放锁。

所以，每个线程持有锁的时间是很短很短的，单个内存分片的并发写入经过压测，达到每秒几百甚至上千是没问题的，因此线上系统我们是单机开辟几十个到上百个内存缓冲分片的。

经过压测，这足以支撑每秒数万的并发写入，如果将机器资源使用的极限，每秒十万并发也是可以支持的。

那么当一块缓冲区写满的时候，是不是就必须要交换两块缓冲区？接着需要有一个线程来将写满的缓冲区数据刷写到磁盘文件中？

此时的伪代码，大家考虑一下，是不是如下所示：

同样，我们通过下面的图来看看这个机制的实现：

且慢，各位同学，如果按照上面的伪代码思路，一定会有一个问题：要是一个线程，他获取了锁，开始写内存数据。

然后，发现内存满了，接着直接在持有锁的过程中，还去执行数据刷磁盘的操作，这样是有问题的。

要知道，数据刷磁盘是很慢的，根据数据的多少，搞不好要几十毫秒，甚至几百毫秒。

这样的话，岂不是一个线程会持有锁长达几十毫秒，甚至几百毫秒？

这当然不行了，后面的线程此时都在等待获取锁然后写缓冲区2，你怎么能一直占有锁呢？

一旦你按照这个思路来写代码，必然导致高并发场景下，一个线程持有锁上百毫秒。刷数据到磁盘的时候，后续上百个工作线程全部卡在等待锁的那个环节，啥都干不了，严重的情况下，甚至又会导致系统整体呈现卡死的状态。

所以此时正确的并发优化代码，应该是发现内存缓冲区1满了，然后就交换两个缓冲区。

接着直接就释放锁，释放锁了之后再由这个线程将数据刷入磁盘中，刷磁盘的过程是不会占用锁的，然后后续的线程都可以继续获取锁，快速写入内存，接着释放锁。

大家先看看下面的伪代码的优化：

按照上面的伪代码的优化，此时磁盘的刷写和内存的写入，完全可以并行同时进行。

因为这里核心的要点就在于大幅度降低了锁占用的时间，这是java并发锁优化的一个非常核心的思路。

大家看下面的图，一起来感受一下：

其实看到这里，大家可能或多或少都体会到了一些双缓冲机制的设计思想了，如果只用单块内存缓冲的话，那么从里面读数据刷入磁盘的过程，也需要占用锁，而此时想要获取锁写入内存缓冲的线程是获取不到锁的。

所以假只用单块缓冲，必然导致读内存数据，刷入磁盘的过程，长时间占用锁。进而导致大量线程卡在锁的获取上，无法获取到锁，然后无法将数据写入内存。这就是必须要在这里使用双缓冲机制的核心原因。

最后做一下总结，本文从笔者团队自研的百万并发量级中间件系统的内核机制出发，给大家展示了Java并发中加锁的时候：

• 如何利用双缓冲机制
• 内存缓冲分片机制
• 分段加锁机制
• 磁盘 + 内存并行写入机制
• 高并发场景下大幅度优化多线程对锁的串行化争用问题
• 长时间占用锁的问题

其实在很多开源的优秀中间件系统中，都有很多类似的Java并发优化的机制，主要就是应对高并发的场景下大幅度的提升系统的并发性能以及吞吐量。大家如果感兴趣，也可以去了解阅读一下相关的底层源码。

————- END ————-

另外推荐儒猿课堂的1元系列课程给您，欢迎加入一起学习~

本文作者及来源:Renderbus瑞云渲染农场https://www.renderbus.com