技术面试题 3000 题

涵盖 Java、数据库、分布式、算法等核心技术栈

共 2167 道题目

Go

76

道题目

Java

310

道题目

数据库

194

道题目

其他

1263

道题目

运维

9

道题目

算法

62

道题目

消息队列

114

道题目

网络

68

道题目

分布式

71

道题目

Go (76 题)

golang 实现发布订阅模式，使用事件机制和go channel实现
#1
golang 如何确定一个channel 关闭 代码实现
#2
十个goroutine 打印 0 到 1000 后缀不同
#3
golang实现三层go routine context cancel
#4
golang 零到99输出 使用发布订阅模式 全部发布完成后再消费如此循环
#5
Channel的作用是什么?
#6
go与其他语言的不同
#7
Go 实现面向对象编程的三大特性（封装、继承、多态）分别是如何实现的？
#8
Go语言和Python的区别有哪些？
#9
为什么选择golang？
#10
Go 是面向对象的语言吗？
#11
Go 与 Node.js 有哪些区别？
#12
golang 中 make 和 new 的区别？
#13
golang 有哪些缺点？
#14
go defer，多个 defer 的顺序，defer 在什么时机会修改返回值？
#15
golang 中解析 tag 是怎么实现的？反射原理是什么？
#16
goroutine什么情况下会阻塞？
#17
go出现panic的场景有哪些？
#18
go是否支持while循环，如何实现这种机制？
#19
go里面如何实现set？
#20
go里面的 _ 有哪些用法？
#21
goroutine创建的时候如果要传一个参数进去有什么要注意的点？
#22
写go单元测试的规范？
#23
导入一个go的工程，有些依赖找不到，改怎么办？
#24
Go 语言中不同的类型如何比较是否相等？
#25
Go中init 函数的特征?
#26
Go 多返回值怎么实现的？
#27
Go中 uintptr和 unsafe.Pointer 的区别？
#28
什么是goroutine？
#29
golang中数组和slice作为参数的区别？slice作为参数传递有什么问题？
#30
Go的切片新旧扩容策略分别是什么？
#31
Go 语言与鸭子类型的关系是什么？
#32
Go 接口与 C++ 接口有何异同？
#33
context在go中一般可以用来做什么？
#34
channel 是否线程安全？锁用在什么地方？
#35
nil、关闭的 channel、有数据的 channel，再进行读、写、关闭会怎么样？
#36
向 channel 发送数据和从 channel 读数据的流程是什么样的？
#37
channel 在什么情况下会引起资源泄漏？
#38
有缓存channel和无缓存channel的区别？
#39
Go 如何实现原子操作？
#40
go里面怎么实现一个自旋锁？
#41
goroutine 的自旋占用资源如何解决？
#42
Go 中主协程如何等待其余协程退出?
#43
多个 goroutine 对同一个 map 写会 panic，异常是否可以用 defer 捕获？
#44
如何优雅的实现一个 goroutine 池？
#45
golang实现多并发请求有哪些方式？
#46
Go 垃圾回收机制的演变过程？
#47
混合写屏障规则是（GoV1.8 ）？
#48
golang 的内存逃逸吗？什么情况下会发生内存逃逸？
#49
请简述 Go 是如何分配内存的？
#50
Channel 分配在栈上还是堆上？哪些对象分配在堆上，哪些对象分配在栈上？
#51
GoRoot 和 GoPath 有什么用？
#52
Go 编译链接过程概述？
#53
Go 编译相关的命令详解？
#54
Go 程序启动过程是怎样的？
#55
go-zero 框架的特点？
#56
CloudWeGo 框架的特点？
#57
GORM 的特点与适用场景？
#58
GORM Gen 的特点与适用场景？
#59
我怎么查看Mongo正在使用的链接?
#60
三个channel使用：ServerSocketChannel，SocketChannel，FileChannel。
#61
如何打开FileChannel？
#62
如何从FileChannel读取数据？
#63
如何向FileChannel写数据？
#64
如何关闭FileChannel？
#65
FileChannel的size方法有什么用？
#66
FileChannel的truncate方法有什么用？
#67
FileChannel的force方法有什么用？
#68
如何打开SocketChannel？
#69
如何关闭SocketChannel？
#70
如何从SocketChannel读取数据？
#71
如何写入SocketChannel？
#72
SocketChannel的非阻塞模式是什么？
#73
如何打开ServerSocketChannel？
#74
如何关闭ServerSocketChannel？
#75
ServerSocketChannel的非阻塞模式是什么？
#76

Java (310 题)

golang GMP 协程调度原理，对比 java 的线程调度
#1
java 类加载器的必要性，为啥其他语言没有类加载器
#2
JVM 内存区域
#3
spring框架如何解决循环依赖
#4
JVM内存区域
#5
JVM如何判断一个对象可以被回收
#6
JVM性能优化，内存方面和 GC 优化
#7
JVM是如何处理异常的？
#8
Java常见异常有哪些？
#9
Java异常处理最佳实践是什么？
#10
Tomcat有哪几种Connector运行模式（优化）？
#11
Tomcat的缺省端口是多少，怎么修改？
#12
Tomcat有几种部署方式？
#13
Tomcat是什么？
#14
Tomcat容器是如何创建`servlet`类实例的？用到了什么原理？
#15
Tomcat工作模式是什么？
#16
Tomcat顶层架构是什么？
#17
说一下JVM的主要组成部分及其作用？
#18
说一下JVM运行时数据区。
#19
内存溢出异常：Java会存在内存泄漏吗？请简单描述。
#20
JVM内存模型、GC机制和原理是什么？
#21
JVM里有几种`classloader`，为什么会有多种？
#22
常见的JVM调优方法有哪些？可以具体到调整哪个参数，调成什么值？
#23
JVM虚拟机内存划分、类加载器、垃圾收集算法、垃圾收集器、class文件结构是如何解析的？
#24
JVM内存模型与GC算法。
#25
Java的内存模型以及GC算法是什么？
#26
Java虚拟机栈（线程私有）是什么？
#27
Java堆（Heap-线程共享）-运行时数据区是什么？
#28
JVM性能调优都做了什么？
#29
Java`classload`机制详解。
#30
`java.lang.ClassLoader`类介绍。
#31
JVM如何分配直接内存，`new`对象如何不分配在堆而是栈上，常量池解析？
#32
触摸Java常量池。
#33
数组多大放在JVM老年代（不只是设置`PretenureSizeThreshold`，问通常多大，没做过一问便知）？
#34
深入理解JVM：Java对象内存分配策略。
#35
Java JVM：垃圾回收（GC在什么时候，对什么东西，做了什么事情）。
#36
JVM源码分析之`SystemGC`完全解读。
#37
JVM选项`-XX:+UseCompressedOops`有什么作用？为什么要使用？
#38
写代码分别使得JVM的堆、栈和持久代发生内存溢出（栈溢出）。
#39
JVM内存溢出详解（栈溢出，堆溢出，持久代溢出以及无法创建本地线程）。
#40
堆溢出（OutOfMemoryError:java heap space）是什么？
#41
Java堆内存的影响是什么？
#42
JDK/JVM里DirectByteBuffer的实现是怎样的？
#43
JVM源码分析之堆外内存完全解读。
#44
JVM老年代和新生代的比例是多少？
#45
JVM-堆学习之新生代老年代持久带的使用关系。
#46
Java中的参数传递是传值呢？还是传引用？
#47
Spring AMQP中消息怎么封装? 用什么转换?
#48
Java中四种引用类型（对象的强、软、弱和虚引用）是什么？
#49
Java对象的创建过程是怎样的？
#50
管中窥豹——从对象的生命周期梳理JVM内存结构、GC、类加载、AOP编程及性能监控。
#51
JVM调优。
#52
JVM源码分析之String.intern()导致的YGC不断变长。
#53
JVM调优常用参数配置。
#54
JVM中最大堆大小有没有限制？
#55
JVM调优总结是什么？
#56
JVM调优方法有哪些？
#57
如何进行JVM调优？有哪些方法？
#58
如何合理的规划一次jvm性能调优？
#59
JVM调优流程是怎样的？
#60
JVM内存分配及参数是怎样的？
#61
JVM内存分哪几个区，每个区的作用是什么？
#62
简述java垃圾回收机制。
#63
Java中垃圾收集的方法有哪些？
#64
Java内存模型是什么？
#65
Java类加载过程是什么？
#66
简述Java类加载机制。
#67
简述Java内存分配与回收策略以及Minor GC和Major GC。
#68
JVM内存区域。
#69
JAVA8与元数据。
#70
JAVA四种引用类型是什么？
#71
JAVA IO/NIO。
#72
JAVA IO包。
#73
JVM类加载机制。
#74
JAVA NIO。
#75
详解Java内存泄露和如何避免内存泄漏。
#76
Java多线程安全机制是什么？
#77
Java线程池如何合理的设置大小？
#78
Java并发和并行。
#79
Java阻塞队列ArrayBlockingQueue和LinkedBlockingQueue实现原理分析。
#80
Java并发编程：volatile关键字解析。
#81
Java内存模型是什么？
#82
Java线程池与五种常用线程池策略使用与解析。
#83
Java提供的四种常用线程池解析。
#84
Java线程池主线程等待子线程执行完成。
#85
Java如何等待子线程执行结束？
#86
Java并发编程的类、接口和方法。
#87
JAVA多线程并发。
#88
JAVA线程实现/创建方式。
#89
JAVA后台线程。
#90
JAVA锁。
#91
Java中的锁--偏向锁、轻量级锁、自旋锁、重量级锁。
#92
Java线程阻塞的代价是什么？
#93
Java中的锁。
#94
共享锁和独占锁java。
#95
JAVA阻塞队列原理。
#96
Java中用到的线程调度。
#97
Spring如何实现事务？
#98
Spring原理？
#99
Spring特点？
#100
Spring核心组件？
#101
Spring常用模块？
#102
Spring主要包？
#103
Spring常用注解？
#104
JVM内存模型以及分区，需要详细到每个区放什么？
#105
JVM的堆区和栈区，还有方法区，初始化的对象放在哪里？引用放在哪里？class类信息常量池（static常量和static变量）等放在哪里？
#106
Java内存模型（JMM）是什么？
#107
Java类加载需要经历哪7个过程？
#108
虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验，解析和初始化，最终形成可以被虚拟机直接使用的java类型，这个过程是什么？
#109
简述Java内存分配与回收策略以及Minor GC和Major GC。
#110
Java 语言有哪些特点
#111
关于 JVM JDK和JRE 最详细通俗的解答
#112
Java 和C++的区别
#113
什么是 Java 程序的主类应用程序和小程序的主类有何不同
#114
Java 应用程序与小程序之间有那些差别
#115
Java 面向对象编程三大特性:封装继承多态
#116
在Java 中定义一个不做事且没有参数的构造方法的作用
#117
import java 和javax 有什么区别
#118
为什么 Java中只有值传递
#119
Java 中的异常处理
#120
Java 序列化中如果有些字段不想进行序列化怎么办
#121
Java获取反射的三种方法
#122
Java反射机制
#123
什么是Java内存模型（JMM）？
#124
什么是Java对象头？其中包含哪些信息？
#125
在Java中 Lock 接口比 synchronized 块的优势是什么?你需要实现一个高效的缓存,它允许许多个用户读,但只允许一个用户写,以此来保持它的完整性,你会怎样去实现它?
#126
在java中 wait 和sleep方法的不同?
#127
用Java实现阻塞队列。
#128
用Java写代码来解决生产者———————消费者问题。
#129
用Java编程一个会导致死锁的程序,你将怎么解决?
#130
什么是原子操作,Java中的原子操作是什么?
#131
Java 中的 volatile 关键是什么作用?怎样使用它?在Java中它跟 synchronized 方法有什么不同?
#132
Java 中你怎样唤醒一个阻塞的线程?
#133
在Java中 CycliBarriar 和 CountdownLatch 有什么区别?
#134
JVM 对 Java 的原生锁做了哪些优化?
#135
如何让 Java 的线程彼此同步?你了解过哪些同步器?请分别介绍下。
#136
Java 中的线程池是如何实现的?
#137
Java 中默认实现好的线程池又有哪些呢?请比较它们的异同。
#138
如何在 Java 线程池中提交线程?
#139
什么是Java 的内存模型,Java 中各个线程是怎么彼此看到对方的变量的?
#140
Java实现的锁类型有哪些？自己实现一个锁要考虑哪些问题？
#141
JVM中哪些对象可以作为GC Root？
#142
JVM的垃圾回收算法？垃圾回收期？
#143
在Spring Cloud中，限流和降级的常见使用场景和实现方式有哪些？
#144
Go语言和Java有什么区别?
#145
go如何实现类似于java当中的继承机制？
#146
Redis支持的Java客户端都有哪些？官方推荐用哪个
#147
java 的阻塞队列和golang 的 channel有啥区别，都能实现发布订阅模式，和异步编程？
#148
ps -ef | grep java
#149
ps aux | grep java
#150
redis过期策略都有哪些？LRU算法知道吗？写一下java代码实现？
#151
Java中什么叫单例设计模式？请用Java写出线程安全的单例模式。
#152
在Java中，什么叫观察者设计模式（observer design pattern）？
#153
举一个用Java实现的装饰模式（decorator design pattern）？它是作用于对象层次还是类层次？
#154
在Java中，为什么不允许从静态方法中访问非静态变量？
#155
在Java中，什么时候用重载，什么时候用重写？
#156
Java中的synchronized关键字底层实现原理是什么？它在不同版本的JDK下有何优化？
#157
Tomcat的缺省端口是多少，怎么修改？
#158
tomcat有哪几种Connector运行模式(优化)
#159
Tomcat有几种部署方式
#160
tomcat容器是如何创建servlet类实例？用到了什么原理
#161
tomcat如何优化
#162
监视Tomcat的内存使用情况
#163
关于Tomcat的session数目
#164
Tomcat一个请求的完整过程
#165
Tomcat工作模式
#166
什么是 SpringMvc？
#167
Spring MVC 的优点
#168
SpringMVC 工作原理？
#169
SpringMVC 流程？
#170
SpringMvc 的控制器是不是单例模式,如果是,有什么问题,怎么解决？
#171
springMVC 和 struts2 的区别有哪些?
#172
SpringMvc 中函数的返回值是什么？
#173
SpringMVC 怎么样设定重定向和转发的？
#174
SpringMvc 用什么对象从后台向前台传递数据的？
#175
SpringMvc 中有个类把视图和数据都合并的一起的,叫什么？
#176
SpringMvc 怎么和 AJAX 相互调用的？
#177
SpringMvc 里面拦截器是怎么写的
#178
什么是 Spring Cloud？
#179
讲下 SpringMvc 的执行流程
#180
使用 Spring Cloud 有什么优势？
#181
服务注册和发现是什么意思？Spring Cloud 如何实现？
#182
什么是 Spring Cloud Bus？我们需要它吗？
#183
什么是 Spring Boot？
#184
什么是 JavaConfig？
#185
Spring Boot 有哪些优点？
#186
如何重新加载 Spring Boot 上的更改，而无需重新启动服务器？
#187
如何在 Spring Boot 中禁用 Actuator 端点安全性？
#188
Spring Boot 中的监视器是什么？
#189
如何在自定义端口上运行 Spring Boot 应用程序？
#190
如何实现 Spring Boot 应用程序的安全性？
#191
如何使用 Spring Boot 实现分页和排序？
#192
如何集成 Spring Boot 和 ActiveMQ？
#193
什么是 Swagger？你用 Spring Boot 实现了它吗？
#194
什么是 Spring Profiles？
#195
如何使用 Spring Boot 实现异常处理？
#196
什么是 Spring Batch？
#197
我们如何监视所有 Spring Boot 微服务？
#198
使用 Spring 框架能带来哪些好处？
#199
请解释下 Spring 框架中的 IoC？
#200
Spring 有几种配置方式？
#201
什么是 Spring 框架？Spring 框架有哪些主要模块？
#202
如何用基于 XML 配置的方式配置 Spring？
#203
如何用基于 Java 配置的方式配置 Spring？
#204
怎样用注解的方式配置 Spring？
#205
请解释 Spring Bean 的生命周期？
#206
Spring Bean 的作用域之间有什么区别？
#207
什么是 Spring inner beans？
#208
Spring 框架中的单例 Beans 是线程安全的么？
#209
请举例说明如何在 Spring 中注入一个 Java Collection？
#210
请解释 Spring Bean 的自动装配？
#211
如何向 Spring Bean 中注入一个 Java.util.Properties？
#212
Spring 框架中都用到了哪些设计模式？
#213
Spring 框架中有哪些不同类型的事件？
#214
开发中主要使用Spring的什么技术?
#215
在Spring中如何配置Bean
#216
什么是 MyBatis？
#217
讲下 MyBatis 的缓存
#218
Mybatis 是如何进行分页的？分页插件的原理是什么？
#219
简述 Mybatis 的插件运行原理，以及如何编写一个插件？
#220
Mybatis 动态 sql 是做什么的？都有哪些动态 sql？能简述一下动态 sql 的执行原理不？
#221
为什么说 Mybatis 是半自动 ORM 映射工具？它与全自动的区别在哪里？
#222
Mybatis 是否支持延迟加载？如果支持，它的实现原理是什么？
#223
MyBatis 与 Hibernate 有哪些不同？
#224
MyBatis 的好处是什么？
#225
简述 Mybatis 的 Xml 映射文件和 Mybatis 内部数据结构之间的映射关系？
#226
什么是 MyBatis 的接口绑定,有什么好处？
#227
MyBatis 实现一对一有几种方式?具体怎么操作的？
#228
Mybatis 能执行一对一、一对多的关联查询吗？都有哪些实现方式，以及它们之间的区别？
#229
MyBatis 里面的动态 Sql 是怎么设定的?用什么语法?
#230
Mybatis 是如何将 sql 执行结果封装为目标对象并返回的？都有哪些映射形式？
#231
Mybatis 映射文件中，如果 A 标签通过 include 引用了 B 标签的内容，请问，B 标签能否定义在 A 标签的后面，还是说必须定义在 A 标签的前面？
#232
Mybatis 的 Xml 映射文件中，不同的 Xml 映射文件，id 是否可以重复？
#233
Mybatis 中如何执行批处理？
#234
Mybatis 都有哪些 Executor 执行器？它们之间的区别是什么？
#235
Mybatis 中如何指定使用哪一种 Executor 执行器？
#236
Mybatis 执行批量插入，能返回数据库主键列表吗？
#237
Mybatis 是否可以映射 Enum 枚举类？
#238
使用 MyBatis 的 mapper 接口调用时有哪些要求？
#239
Mybatis 比 IBatis 比较大的几个改进是什么？
#240
IBatis 和 MyBatis 在核心处理类分别叫什么？
#241
Dubbo 与 Spring 的关系？
#242
Dubbo 和 Spring Cloud 的关系？
#243
Dubbo 和 Spring Cloud 的区别？
#244
Spring Bean 的生命周期
#245
Spring IOC 如何实现
#246
说说 Spring AOP
#247
Spring AOP 实现原理
#248
Spring 事务实现方式
#249
Spring 事务底层原理
#250
Spring MVC 运行流程
#251
Spring MVC 启动流程
#252
Spring 的单例实现原理
#253
Spring 框架中用到了哪些设计模式
#254
JVM、JRE和JDK的关系是什么？
#255
什么是Java？
#256
Java语言有哪些特点？
#257
什么是Java程序的主类？应用程序和小程序的主类有何不同？
#258
Java应用程序与小程序之间有哪些差别？
#259
Java和C++的区别是什么？
#260
Java有哪些数据类型？
#261
Java语言采用何种编码方案？有何特点？
#262
Java注释的分类有哪些？
#263
Java注释的定义是什么？
#264
什么是Java注释？
#265
Java注释的作用是什么？
#266
Java有没有goto？
#267
在Java中，如何跳出当前的多重嵌套循环？
#268
什么是多态机制？Java语言是如何实现多态的？
#269
在Java中定义一个不做事且没有参数的构造方法的作用是什么？
#270
为什么Java中只有值传递？
#271
import java和javax有什么区别？
#272
Java中IO流分为几种？
#273
Java获取反射的三种方法是什么？
#274
Java集合的快速失败机制“fail-fast”是什么？
#275
遍历一个List有哪些不同的方式？每种方法的实现原理是什么？Java中List遍历的最佳实践是什么？
#276
说说你知道的几个Java集合类：list、set、queue、map实现类。
#277
Java中的队列都有哪些，有什么区别？
#278
Java IO流详解（二）——IO流的框架体系是什么？
#279
Java NIO系列教程 FileChannel。
#280
Java NIO系列教程 SocketChannel。
#281
Java NIO系列教程 ServerSocketChannel。
#282
关于JVM, JDK和JRE最详细通俗的解答是什么？
#283
JVM是什么？
#284
Java面向对象编程三大特性是什么：封装、继承、多态？
#285
Java序列化中如果有些字段不想进行序列化怎么办？
#286
JAVA异常分类及处理是什么？
#287
JAVA反射是什么？
#288
JAVA注解是什么？
#289
JAVA内部类是什么？
#290
JAVA泛型是什么？
#291
JAVA序列化（创建可复用的Java对象）是什么？
#292
JAVA复制是什么？
#293
Java9比Java8改进了什么？
#294
JAVA8十大新特性详解。
#295
Lambda表达式在Java 8中有什么特点？
#296
接口的默认方法在Java 8中有什么特点？
#297
函数式接口在Java 8中有什么特点？
#298
方法与构造函数引用在Java 8中有什么特点？
#299
Lambda作用域在Java 8中有什么特点？
#300
访问局部变量在Java 8中有什么特点？
#301
访问对象字段与静态变量在Java 8中有什么特点？
#302
访问接口的默认方法在Java 8中有什么特点？
#303
Date API在Java 8中有什么特点？
#304
Annotation注解在Java 8中有什么特点？
#305
Java 9逆天的十大新特性是什么？
#306
Java异常架构与异常关键字是什么？
#307
Java异常简介。
#308
Java异常关键字有哪些？
#309
Java异常处理方式有哪些？
#310

数据库 (194 题)

mysql索引什么时候会失效
#1
Redis数据类型
#2
redis 字符串存储（实现）原理
#3
为什么要对底层数据结构用redisObject包装一层？
#4
redis多线程已经支持多线程了，是否会有线程安全问题？Redis多线程模型怎么理解？
#5
redis存在线程安全问题吗？为什么？
#6
为什么要使用数据库？
#7
SQL是什么？
#8
MySQL是什么？
#9
数据库三大范式是什么？
#10
MySQL有关权限的表都有哪几个？
#11
MySQL的`binlog`有几种录入格式？分别有什么区别？
#12
MySQL有哪些数据类型？
#13
MySQL存储引擎`MyISAM`与`InnoDB`区别？
#14
数据库为什么使用B+树而不是B树？
#15
什么是数据库事务？
#16
对MySQL的锁了解吗？
#17
什么是事务的隔离级别？MySQL的默认隔离级别是什么？
#18
按照锁的粒度分数据库锁有哪些？锁机制与`InnoDB`锁算法？
#19
从锁的类别上分MySQL都有哪些锁呢？
#20
MySQL中`InnoDB`引擎的行锁是怎么实现的？
#21
数据库的乐观锁和悲观锁是什么？怎么实现的？
#22
MySQL中都有哪些触发器？
#23
SQL语句主要分为哪几类？
#24
SQL约束有哪几种？
#25
MySQL中`in`和`exists`区别？
#26
MySQL为什么这么设计？
#27
MySQL中`int(10)`和`char(10)`以及`varchar(10)`的区别？
#28
如何定位及优化SQL语句的性能问题？
#29
SQL的生命周期？
#30
MySQL分页。
#31
关心过业务系统里面的sql耗时吗？统计过慢查询吗？对慢查询都怎么优化过？
#32
数据库优化。
#33
MySQL数据库cpu飙升到500%的话他怎么处理？
#34
MySQL的复制原理以及流程？
#35
备份计划，`mysqldump`以及`xtranbackup`的实现原理？
#36
MySQL记录`binlog`的方式主要包括三种模式？每种模式的优缺点是什么？
#37
MySQL `InnoDB`中，乐观锁、悲观锁、共享锁、排它锁、行锁、表锁、死锁概念的理解？
#38
MySQL锁，悲观锁、乐观锁、排它锁、共享锁、表级锁、行级锁？
#39
数据库事务隔离级别，MySQL默认的隔离级别？
#40
SQL的整个解析、执行过程原理、SQL行转列？
#41
MySql的存储引擎的不同？
#42
Mysql优化系列--`Innodb`引擎下mysql自身配置优化。
#43
Mysql怎么分表，以及分表后如果想按条件分页查询怎么办（如果不是按分表字段来查询的话，几乎效率低下，无解）？
#44
MySQL大数据量使用`limit`分页，随着页码的增大，查询效率越低下。
#45
MySQL分表自增ID解决方案。
#46
MySql的主从实时备份同步的配置，以及原理（从库读主库的binlog），读写分离？
#47
MySQL索引背后的数据结构及算法原理。
#48
MySQL中的MVCC？
#49
MySQL索引原理之聚簇索引。
#50
关系型和非关系型数据库区别？
#51
我的Mysql死锁排查过程（案例分析）。
#52
MySQL的架构和引擎相关问题有哪些？
#53
MySQL连接器、分析器、执行器、引擎分别是什么？
#54
MySQL引擎的分类有哪些？
#55
MySQL事务隔离级别有哪些？
#56
MySQL的主从复制是如何实现的？
#57
Redis常见数据结构有哪些？
#58
SDS是什么？数字类型的自增自减在Redis中如何实现？
#59
Redis持久化方式有哪些？
#60
Redis的hashTable是什么？
#61
Redis如何做故障恢复？
#62
Redis分布式锁的实现方式有哪些？setnx会带来哪些问题？
#63
如何避免Redis分布式锁的死锁问题？
#64
在Redis集群模式下如何防止多个进程同时获取到锁？
#65
Redlock Redis的读写锁是什么？
#66
MySQL的执行计划如何查看？遇到问题如何通过执行计划进行SQL优化？
#67
MySQL RC和RR、行锁、临建锁、间隙锁、索引最左匹配原则、连表查询、小表驱动大表在事务场景中如何应用？
#68
SQL分组业务场景是什么？学生按生源地分组如何实现？
#69
Redis的Reactor和Netty的Reactor有什么区别？
#70
Redis的LRU算法原理是什么？
#71
Redis压缩表是什么？
#72
Redis的多路复用是什么？
#73
什么是Redis？简述它的优缺点？
#74
mysql今天那个业务场景 A方法指定事务RR，B方法指定事务RC，B事务新增了一条数据，A事务 能看到吗
#75
分库分表 中分表 当时出了个场景题，说如果分表的维度是A和B两个字段，联查sql,两个场景 A1+B1、A2+B2的两类的数据，怎么写sql
#76
Redis与memcached相比有哪些优势？
#77
我今天 也问了我 mysql和pg的区别
#78
sql 分组业务场景，学生按生源地分组，当时问分组，如果只答group by 就不加分了，还得加个子查询，因为不同数据库，group by用法不一样
#79
redis 6.0之前是单线程reactor模型， 6.0之后是多线程reactor模型， netty是 多线程多reactor模型
#80
MySQL 使用唯一索引进行 UPDATE 操作时加锁范围会缩小，这种优化的原理是什么？
#81
MySQL 在执行 UPDATE 语句时，会对哪些记录加锁？是否一定只加一条行锁？
#82
Redis支持哪几种数据类型？
#83
MySQL 的意向锁在 UPDATE 中起什么作用？是否会影响其他事务的加锁判断？
#84
Redis主要消耗什么物理资源？
#85
Redis有哪几种数据淘汰策略？
#86
redis的数据类型，在项目中的应用
#87
Redis单线程为什么快？
#88
Redis RDB和AOF
#89
Redis RDB是异步的吗？
#90
Redis官方为什么不提供Windows版本？
#91
Redis NIO 多路复用模型？Select模型、poll模型、Epoll模型区别？
#92
如何保证数据库和缓存的一致性？
#93
请聊一聊MySQL的存储引擎，它们之间有什么区别？
#94
MySQL事务的实现原理是什么？原子性和隔离性是如何保证的？
#95
MySQL和PostgreSQL数据库之间有什么区别？
#96
为什么Redis需要把所有数据放到内存中？
#97
Redis集群方案应该怎么做？都有哪些方案？
#98
Redis集群方案什么情况下会导致整个集群不可用？
#99
MySQL里有2000w数据，redis中只存20w的数据，如何保证redis中的数据都是热点数据？
#100
Redis有哪些适合的场景
#101
Redis和Redisson有什么关系
#102
Jedis与Redisson对比有什么优缺点
#103
说说Redis哈希槽的概念
#104
Redis集群的主从复制模型是怎样的
#105
Redis集群会有写操作丢失吗？为什么
#106
Redis集群之间是如何复制的
#107
Redis集群最大节点个数是多少
#108
Redis集群如何选择数据库
#109
Redis中的管道有什么用
#110
怎么理解Redis事务
#111
Redis事务相关的命令有哪几个
#112
Rediskey的过期时间和永久有效分别怎么设置
#113
Redis如何做内存优化
#114
Redis回收进程如何工作的
#115
在领域驱动设计中，你如何选择适合的数据库和持久化方案？
#116
Redis分布式锁的缺点
#117
systemctl start mysql
#118
systemctl status mysql
#119
systemctl stop mysql
#120
systemctl restart mysql
#121
systemctl enable mysql
#122
systemctl disable mysql
#123
mysql -u root -p
#124
使用过Redis分布式锁么，它是怎么实现的
#125
mysql -uroot -p < /path/to/sql/file.sql
#126
mysqldump -u root -p db_name > backup.sql
#127
mysqldump -u root -p db_name --databases > backup.sql // 带上create db的语句
#128
mysql -u root -p db_name < backup.sql
#129
使用过Redis做异步队列么，你是怎么用的？有什么缺点
#130
redis和memcached什么区别？为什么高并发下有时单线程的redis比多线程的memcached效率要高？
#131
redis主从复制如何实现的？redis的集群模式如何实现？redis的key是如何寻址的
#132
使用redis如何设计分布式锁？说一下实现思路？使用zk可以吗？如何实现？这两种有什么区别？
#133
知道redis的持久化吗？底层如何实现的？有什么优点缺点？
#134
在选择缓存时，什么时候选择redis，什么时候选择memcached
#135
缓存与数据库不一致怎么办
#136
主从数据库不一致如何解决
#137
Redis常见的性能问题和解决方案
#138
Redis的数据淘汰策略有哪些
#139
Redis当中有哪些数据结构
#140
假如Redis里面有1亿个key，其中有10w个key是以某个固定的已知的前缀开头的，如果将它们全部找出来
#141
如果这个redis正在给线上的业务提供服务，那使用keys指令会有什么问题？
#142
使用Redis做过异步队列吗，是如何实现的
#143
Redis如何实现延时队列
#144
memcached和MySQL的querycache相比，有什么优缺点？
#145
SQL优化
#146
一张表，里面有ID自增主键，当insert了17条记录之后，删除了第15,16,17条记录，再把Mysql重启，再insert一条记录，这条记录的ID是18还是15
#147
Mysql服务器默认端口是什么
#148
与Oracle  甲骨文相比，Mysql有什么优势
#149
请简洁描述Mysql中InnoDB支持的四种事务隔离级别名称，以及逐级之间的区别
#150
在Mysql中ENUM的用法是什么
#151
如何获取当前的Mysql版本
#152
Mysql中使用什么存储引擎
#153
如何使用Unixshell登录Mysql
#154
MYSQL数据库服务器性能分析的方法命令有哪些
#155
如何在Unix和Mysql时间戳之间进行转换
#156
Mysql查询是否区分大小写
#157
mysql_fetch_array和mysql_fetch_object的区别是什么
#158
我们如何在mysql中运行批处理模式
#159
Mysql中有哪些不同的表格
#160
Mysql如何优化DISTINCT
#161
Mysql表中允许有多少个TRIGGERS
#162
什么是通用SQL函数
#163
MYSQL支持事务吗
#164
mysql里记录货币用什么字段类型好
#165
mysql有关权限的表都有哪几个
#166
MYSQL数据表在什么情况下容易损坏
#167
Mysql中有哪几种锁
#168
NoSQL数据库是什么意思?NoSQL与RDBMS直接有什么区别?为什么要使用和不使用NoSQL数据库?说一说NoSQL数据库的几个优点?
#169
NoSQL数据库有哪些类型
#170
MySQL与MongoDB之间最基本的差别是什么?
#171
你怎么比较MongoDB、CouchDB及CouchBase
#172
MongoDB成为最好NoSQL数据库的原因是什么
#173
分析器在MongoDB中的作用是什么
#174
我应该启动一个集群分片(sharded)还是一个非集群分片的MongoDB环境
#175
MongoDB在A:{B,C}上建立索引，查询A:{B,C}和A:{C,B}都会使用索引吗
#176
MongoDB支持存储过程吗？如果支持的话，怎么用
#177
如何理解MongoDB中的GridFS机制，MongoDB为何使用GridFS来存储文件
#178
MySQL性能优化
#179
数据库三范式是什么
#180
有哪些数据库优化方面的经验
#181
有外键约束会影响插入和删除性能，如果程序能够保证数据的完整性，那在设计数据库时就去掉外键
#182
mysql数据库中索引的工作机制
#183
MySQL的基础操作命令
#184
mysql的复制原理以及流程
#185
mysql支持的复制类型
#186
mysql中myisam与innodb的区别
#187
mysql中varchar与char的区别以及varchar(50)中的50代表的涵义
#188
MySQL中InnoDB支持的四种事务隔离级别名称，以及逐级之间的区别
#189
MySQL中InnoDB引擎的行锁是通过加在什么上完成（或称实现）的
#190
MySQL中控制内存分配的全局参数，有哪些
#191
MySQL当记录不存在时insert,当记录存在时update，语句怎么写？
#192
MySQL的insert和update的select语句语法
#193
微服务如何进行数据库管理
#194

其他 (1263 题)

es 节点类型
#1
枚举实现单例，以及为啥能防止反射攻击
#2
类加载机制，双亲委派模型
#3
如何判断一个对象可以回收
#4
类加载机制
#5
双亲委派
#6
打破双亲委派
#7
垃圾收集器
#8
CPU飙高系统反应慢怎么排查
#9
生产环境服务器变慢？怎么排查处理？
#10
一个对象是多少字节？在堆区都存了什么东西？对象头里面都有啥？
#11
SDS结构
#12
为什么使用SDS
#13
Hash 哈希
#14
存储（实现）原理
#15
什么时候使用ziplist存储？
#16
存储类型
#17
应用场景
#18
List列表
#19
存储类型
#20
quicklist
#21
Set集合
#22
应用场景
#23
存储（实现）原理
#24
存储（实现）原理
#25
ZSet 有序集合
#26
什么是skiplist(跳表)？
#27
应用场景
#28
分区数和副本数怎么设置？
#29
分区的副本在Broker上是怎么分布的？假设有3个Broker，一个Topic有两个分区，每个分区两个副本，可能的分布情况是什么样的？
#30
Segment的作用是什么？
#31
Consumer Group的含义是什么？
#32
Consumer Group上次消费的偏移量记录在哪里？怎么更新？
#33
生产者acks 1 0 -1的含义是什么？
#34
一个消费组中的消费者与分区的关系是什么样的？例如topic有3个分区，假如有2个消费者，怎么分配？假如有4个消费者，怎么分配？
#35
运行时异常和一般异常（受检异常）区别是什么？
#36
throw和throws的区别是什么？
#37
final、finally、finalize有什么区别？
#38
try-catch-finally中，如果catch中return了，finally还会执行吗？
#39
try-catch-finally中哪个部分可以省略？
#40
在finally块中清理资源或者使用try-with-resource语句。
#41
优先明确的异常。
#42
对异常进行文档说明。
#43
优先捕获最具体的异常。
#44
不要捕获Throwable类。
#45
不要忽略异常。
#46
不要记录并抛出异常。
#47
包装异常时不要抛弃原始的异常。
#48
交换机与队列、队列与消费者的绑定关系是什么样的?
#49
使用标准异常。
#50
不要使用异常控制程序的流程。
#51
异常会影响性能吗？
#52
Connector和Container的微妙关系是什么？
#53
Container如何处理请求的？
#54
Container架构分析。
#55
深拷贝和浅拷贝的区别是什么？
#56
说一下堆栈的区别？
#57
如何为对象分配内存？
#58
对象的创建过程是怎样的？
#59
如何处理并发安全问题？
#60
队列和栈是什么？有什么区别？
#61
对象的访问定位方式是什么？
#62
句柄访问方式是什么？
#63
直接指针访问方式是什么？
#64
什么是双亲委派机制？介绍一下运作过程，双亲委派模型的好处是什么？
#65
`User user = new User()`做了什么操作，申请了哪些内存？
#66
类（class）文件结构是什么？
#67
本地方法栈（线程私有）是什么？
#68
程序计数器（线程私有）是什么？
#69
运行时常量池是什么？
#70
直接内存是什么？
#71
方法区/永久代（线程共享）是什么？
#72
类加载器基本概念是什么？
#73
浅谈HotSpot逃逸分析。
#74
JIT是什么？
#75
逃逸分析是什么？
#76
同步消除是什么？
#77
标量替换是什么？
#78
编译阈值是什么？
#79
栈上分配是什么？
#80
大对象直接进入老年代。
#81
长期存活的对象将进入老年代。
#82
动态对象年龄判定是什么？
#83
老年代中数组的访问方式是什么？
#84
空间分配担保是什么？
#85
对象优先在Eden分配。
#86
谁会被GC，什么时候GC？
#87
如果想在GC中生存1次怎么办？
#88
分析`System.gc()`方法。
#89
`JDK`里的`System.gc`的实现是怎样的？
#90
`Hotspot`里`System.gc`的实现是怎样的？
#91
如何找到`native`里的实现？
#92
`ExplicitGCInvokesConcurrent`参数是什么？
#93
`DisableExplicitGC`参数是什么？
#94
并行Full GC相对正常的Full GC效率高在哪里？
#95
`stop the world`是什么？
#96
CMS GC是什么？
#97
正常的Full GC是什么？
#98
并行的Full GC是什么？
#99
堆外内存常配合使用`System GC`。
#100
内存溢出和内存泄漏的区别是什么？
#101
栈溢出（StackOverflowError）是什么？
#102
OutOfMemoryError:unable to create native thread是什么？
#103
持久代溢出（OutOfMemoryError: PermGen space）是什么？
#104
元空间（Metaspace）是什么？
#105
PermGen空间的状况是什么？
#106
Metaspace内存分配模型是什么？
#107
Metaspace垃圾回收是怎样的？
#108
Metaspace容量是什么？
#109
Metaspace监控是怎样的？
#110
Metaspace更新原因是什么？
#111
简单谈谈堆外内存以及你的理解和认识。
#112
Metaspace参数设置是怎样的？
#113
广义的堆外内存是什么？
#114
狭义的堆外内存是什么？
#115
堆外内存默认是多大？
#116
如何动态地创建队列和消费者?
#117
为什么要主动调用System.gc？
#118
为什么不能大面积使用堆外内存？
#119
为什么要使用堆外内存？
#120
threadlocal使用场景及注意事项。
#121
栈是运行时的单位，而堆是存储的单位。
#122
为什么要把堆和栈区分出来呢？栈中不是也可以存储数据吗？
#123
为什么不把基本类型放堆中呢？
#124
堆中存什么？栈中存什么？
#125
讲一讲内存分代及生命周期。
#126
class文件载入过程是怎样的？
#127
加载过程是怎样的？
#128
连接过程是怎样的？
#129
拓展：双亲委派机制与AOP面向切面编程原理。
#130
内存集中管理（模型及GC机制）是怎样的？
#131
对象创建及方法调用过程是怎样的？
#132
回收器有哪些？
#133
新生代收集器有哪些？
#134
老年代收集器有哪些？
#135
G1收集器是什么？
#136
图形化工具jvisualvm.exe。
#137
什么情况下触发垃圾回收？
#138
优化策略使用。
#139
深入理解垃圾收集器和收集器的选择策略。
#140
StringTable是什么？
#141
探索StringTable提升YGC性能。
#142
验证StringTable问题。
#143
String.intern()250w个String对象。
#144
String.intern()500w个String对象。
#145
PrintStringTableStatistics结果解读。
#146
String.intern()250w个String对象-XX:StringTableSize=2500000。
#147
String.intern()500w个String对象-XX:StringTableSize=5000000。
#148
引申StringTable问题。
#149
PrintStringTableStatistics&StringTableSize结果解读。
#150
StringTable的结论是什么？
#151
String.intern方法是什么？
#152
StringTable为什么会影响YGC？
#153
YGC过程扫描StringTable对CPU影响大吗？
#154
StringTable什么时候清理？
#155
堆配置是怎样的？
#156
收集器设置是怎样的？
#157
垃圾回收统计信息。
#158
并行收集器设置。
#159
典型配置举例。
#160
堆大小设置是怎样的？
#161
回收器的选择是怎样的？
#162
如何调优？
#163
内存泄露检查是怎样的？
#164
性能调优的层次是什么？
#165
性能定义是什么？
#166
性能调优原则是什么？
#167
性能调优流程是怎样的？
#168
如何确定内存占用？
#169
运行阶段是什么？
#170
如何计算活跃数据大小？
#171
延迟调优是怎样的？
#172
系统延迟需求是什么？
#173
如何优化新生代的大小？
#174
对象提升率是什么？
#175
如何优化老年代的大小？
#176
吞吐量调优是怎样的？
#177
内存模型以及分区，需要详细到每个区放什么。
#178
堆里面的分区：Eden，survival （from+ to），老年代，各自的特点是什么？
#179
对象创建方法，对象的内存分配，对象的访问定位是什么？
#180
GC的两种判定方法是什么？
#181
SafePoint是什么？
#182
GC收集器有哪些？CMS收集器与G1收集器的特点是什么？
#183
Minor GC与Full GC分别在什么时候发生？
#184
几种常用的内存调试工具：jmap、jstack、jconsole、jhat、jstack。
#185
类加载的几个过程是什么？
#186
如何判断一个对象是否存活？（或者GC对象的判定方法）
#187
什么是类加载器，类加载器有哪些？
#188
新生代是什么？
#189
老年代是什么？
#190
永久代是什么？
#191
如何确定垃圾？
#192
GC垃圾收集器是什么？
#193
类加载器是什么？
#194
双亲委派是什么？
#195
动态改变构造。
#196
简述线程，程序、进程的基本概念。以及他们之间关系是什么？
#197
线程有哪些基本状态？
#198
如何理解内存泄漏问题？有哪些情况会导致内存泄露？如何解决？
#199
线程池的原理，为什么要创建线程池？创建线程池的方式。
#200
线程池的优点是什么？
#201
线程池的创建方式有哪些？
#202
线程池的实现原理是什么？
#203
Executor框架的两级调度模型是什么？
#204
Callable、Future、FutureTash详解。
#205
Callable与FutureTask的区别是什么？
#206
Callable与Future的区别是什么？
#207
线程的生命周期，什么时候会出现僵死进程？
#208
说说线程安全问题，什么是线程安全，如何实现线程安全？
#209
互斥同步锁（悲观锁）是什么？
#210
非阻塞同步锁是什么？
#211
无同步方案是什么？
#212
创建线程池有哪几个核心参数？如何合理配置线程池的大小？
#213
关于线程池的执行原则及配置参数详解。
#214
线程池的好处是什么？
#215
线程池的创建。
#216
线程池工作原则是什么？
#217
任务队列BlockingQueue是什么？
#218
线程池的具体参数介绍。
#219
四种类型的znode
#220
任务拒绝类型是什么？
#221
volatile、ThreadLocal的使用场景和原理。
#222
volatile的适用场景有哪些？
#223
模式 #1：状态标志。
#224
模式 #4：“volatile bean”模式。
#225
模式 #5：开销较低的“读－写锁”策略。
#226
正确使用Volatile变量。
#227
Volatile变量是什么？
#228
正确使用volatile变量的条件是什么？
#229
ThreadLocal什么时候会出现OOM的情况？为什么？
#230
ThreadLocal全部方法和内部类。
#231
ThreadLocal源码分析。
#232
性能考虑。
#233
ThreadLocal的set方法。
#234
ThreadLocal的get方法。
#235
ThreadLocal的内存回收。
#236
ThreadLocal可能引起的OOM内存溢出问题简要分析。
#237
synchronized、volatile区别。
#238
synchronized和volatile区别。
#239
synchronized锁粒度、模拟死锁场景。
#240
synchronized的三大性质总结。
#241
原子性是什么？
#242
有序性是什么？
#243
可见性是什么？
#244
基于synchronized的对象锁，类锁以及死锁模拟。
#245
zk的命名服务（文件系统）
#246
怎么提高并发量，请列举你所知道的方案？
#247
高并发解决方案——提升高并发量服务器性能解决思路。
#248
系统的用户量有多少？多用户并发访问时如何解决？
#249
大型网站是怎样解决多用户高并发访问的？
#250
说说阻塞队列的实现：可以参考ArrayBlockingQueue的底层实现（锁和同步都行）。
#251
信号是什么？
#252
管道是什么？
#253
zk的配置管理（文件系统、通知机制）
#254
共享内存是什么？
#255
信号量是什么？
#256
为什么要用线程池？
#257
自带线程池的各种坑有哪些？
#258
volatile关键字的用法：使多线程中的变量可见。
#259
线程池的基础概念是什么？
#260
内存模型的相关概念是什么？
#261
并发编程中的三个概念是什么？
#262
深入剖析volatile关键字。
#263
volatile关键字的使用场景有哪些？
#264
线程的几种状态是什么？
#265
常用的线程池模式以及不同线程池的使用场景。
#266
可选择的阻塞队列BlockingQueue详解。
#267
无界队列是什么？
#268
有界队列是什么？
#269
同步移交是什么？
#270
几种BlockingQueue的具体实现原理。
#271
AbortPolicy中止策略是什么？
#272
DiscardPolicy抛弃策略是什么？
#273
DiscardOldestPolicy抛弃旧任务策略是什么？
#274
CallerRunsPolicy调用者运行策略是什么？
#275
newCachedThreadPool是什么？
#276
newFixedThreadPool创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
#277
newScheduledThreadPool创建一个定长线程池，支持定时及周期性任务执行。
#278
newSingleThreadExecutor创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
#279
newWorkStealingPool创建一个拥有多个任务队列（以便减少连接数）的线程池。
#280
线程间通信，wait和notify。
#281
wait和notify的理解与使用。
#282
进程和线程的区别是什么？
#283
什么叫线程安全？举例说明。
#284
并发、同步的接口或方法。
#285
HashMap是否线程安全，为何不安全。ConcurrentHashMap，线程安全，为何安全。底层实现是怎么样的？
#286
volatile的理解。
#287
volatile特性是什么？
#288
如何保证内存可见性？
#289
线程是什么？
#290
4种线程池。
#291
线程生命周期（状态）是什么？
#292
终止线程4种方式。
#293
sleep与wait区别。
#294
start与run区别。
#295
乐观锁是什么？
#296
悲观锁是什么？
#297
自旋锁是什么？
#298
Synchronized同步锁是什么？
#299
理解锁的基础知识。
#300
锁的类型有哪些？
#301
markword是什么？
#302
重量级锁Synchronized是什么？
#303
偏向锁是什么？
#304
轻量级锁是什么？
#305
锁优化。
#306
如何减少锁的时间？
#307
如何减少锁的粒度？
#308
如何使用读写锁？
#309
锁粗化是什么？
#310
读写分离是什么？
#311
如何使用cas？
#312
`ReentrantLock`与`synchronized`的区别是什么？
#313
`ReentrantLock`是什么？
#314
`Semaphore`信号量是什么？
#315
`AtomicInteger`是什么？
#316
`tryLock`和`lock`和`lockInterruptibly`的区别。
#317
消除缓存行的伪共享。
#318
可重入锁（递归锁）是什么？
#319
公平锁与非公平锁是什么？
#320
`ReadWriteLock`读写锁是什么？
#321
重量级锁（Mutex Lock）是什么？
#322
偏向锁是什么？
#323
分段锁是什么？
#324
轻量级锁是什么？
#325
线程基本方法。
#326
线程上下文切换。
#327
同步锁与死锁。
#328
线程池原理。
#329
`CyclicBarrier`、`CountDownLatch`、`Semaphore`的用法。
#330
`ThreadLocalMap`（线程的一个属性）。
#331
如何在两个线程之间共享数据？
#332
`synchronized`和`ReentrantLock`的区别。
#333
`ConcurrentHashMap`并发。
#334
什么是CAS（比较并交换-乐观锁机制-锁自旋）？
#335
什么是AQS（抽象的队列同步器）？
#336
`MyISAM`索引与`InnoDB`索引的区别？
#337
`InnoDB`引擎的4大特性是什么？
#338
什么是索引？
#339
存储引擎选择。
#340
索引有哪些优缺点？
#341
索引使用场景（重点）？
#342
索引有哪几种类型？
#343
机器中为什么会有leader
#344
索引的基本原理？
#345
创建索引的原则（重中之重）？
#346
索引设计的原则？
#347
创建索引时需要注意什么？
#348
使用索引查询一定能提高查询的性能吗？为什么？
#349
百万级别或以上的数据如何删除？
#350
前缀索引是什么？
#351
什么是最左前缀原则？什么是最左匹配原则？
#352
zk节点宕机如何处理
#353
什么是聚簇索引？何时使用聚簇索引与非聚簇索引？
#354
非聚簇索引一定会回表查询吗？
#355
联合索引是什么？为什么需要注意联合索引中的顺序？
#356
事物的四大特性（ACID）介绍一下？
#357
什么是脏读？幻读？不可重复读？
#358
隔离级别与锁的关系？
#359
像上面那样子进行锁定岂不是有点阻碍并发效率了？
#360
什么是死锁？怎么解决？
#361
为什么要使用视图？什么是视图？
#362
视图有哪些特点？
#363
视图的使用场景有哪些？
#364
视图的优点？
#365
视图的缺点？
#366
什么是游标？
#367
什么是存储过程？有哪些优缺点？
#368
什么是触发器？触发器的使用场景有哪些？
#369
请解释一下什么是Nginx
#370
超键、候选键、主键、外键分别是什么？
#371
六种关联查询？
#372
什么是子查询？
#373
子查询的三种情况？
#374
`varchar`与`char`的区别？
#375
`varchar(50)`中50的涵义？
#376
请列举Nginx的一些特性
#377
`int(20)`中20的涵义？
#378
`FLOAT`和`DOUBLE`的区别是什么？
#379
`drop`、`delete`与`truncate`的区别？
#380
创建的索引有没有被使用到？或者说怎么才可以知道这条语句运行很慢的原因？
#381
大表数据查询，怎么优化？
#382
请列举Nginx和Apache之间的不同点
#383
超大分页怎么处理？
#384
慢查询日志。
#385
主键使用自增ID还是UUID？
#386
为什么要尽量设定一个主键？
#387
字段为什么要求定义为`not null`？
#388
优化查询过程中的数据访问。
#389
如果要存储用户的密码散列，应该使用什么字段进行存储？
#390
优化长难的查询语句。
#391
优化特定类型的查询语句。
#392
优化关联查询。
#393
优化LIMIT分页。
#394
优化子查询。
#395
优化WHERE子句。
#396
为什么要优化？
#397
大表怎么优化？某个表有近千万数据，CRUD比较慢，如何优化？
#398
在Nginx中，如何使用未定义的服务器名称来阻止处理请求
#399
分库分表了是怎么做的？分表分库了有什么问题？有用到中间件么？他们的原理知道么？
#400
水平分表适用场景？
#401
垂直分表适用场景及缺点？
#402
读写分离有哪些解决方案？
#403
数据表损坏的修复方式有哪些？
#404
使用“反向代理服务器”的优点是什么
#405
`JDBC`如何实现事务？
#406
嵌套事务实现？
#407
请列举Nginx服务器的最佳用途。
#408
请解释Nginx服务器上的Master和Worker进程分别是什么
#409
产生死锁的必要条件？
#410
new一个对象时会发生什么？
#411
请解释你如何通过不同于80的端口开启Nginx
#412
方法区主要存储哪些数据？
#413
堆主要存储哪些数据？
#414
栈的结构是怎样的？栈帧上面存储哪些信息？局部变量表存放的是什么？
#415
本地方法栈主要为什么服务？
#416
程序计数器的作用是什么？
#417
堆里面的分区：Eden, survival (from+to),老年代，各自的特点是什么？
#418
当新生区满了之后会触发什么GC？存活的对象会放到哪里？垃圾清理后会怎样？特别大的对象会如何处理？
#419
对象创建方法是什么？
#420
对象的内存分配是怎样的？
#421
对象的访问定位是怎样的？
#422
请解释是否有可能将Nginx的错误替换为502错误、503?
#423
GC的两种判定方法是什么？
#424
引用计数法的原理和缺点是什么？
#425
引用链法的原理是什么？
#426
GC ROOT的对象有哪些？
#427
SafePoint是什么？
#428
SafePoint通常在哪些位置？
#429
在Nginx中，解释如何在URL中保留双斜线?
#430
并行收集器和串行收集器的区别是什么？
#431
GC收集器有哪些？
#432
CMS收集器的特点是什么？
#433
G1收集器的特点是什么？
#434
Minor GC与Full GC分别在什么时候发生？
#435
几种常用的内存调试工具包括哪些？
#436
类加载的几个过程是什么？
#437
jstack、jmap、jhat工具的作用是什么？
#438
JMM中主内存和本地内存的关系是怎样的？
#439
线程A与线程B之间通信需要经历哪两个步骤？
#440
类加载过程中每个阶段的具体内容是什么？
#441
类加载中的“加载”阶段完成哪三件事情？
#442
类加载中的“验证”阶段的目的是什么？主要完成哪四种验证？
#443
类的静态变量在“准备”阶段和“初始化”阶段的初始值分别是什么？
#444
类加载中的“准备”阶段会做什么？
#445
类加载中的“解析”阶段主要完成什么？
#446
类加载中的“初始化”阶段有什么特点？
#447
请解释什么是C10K问题
#448
类加载器双亲委派模型机制是怎样的？
#449
什么是类加载器，类加载器有哪些？
#450
面向对象和面向过程的区别
#451
Oracle JDK 和 OpenJDK的对比
#452
请陈述stub_status和sub_filter指令的作用是什么
#453
字符型常量和字符串常量的区别
#454
构造器 Constructor 是否可被 override
#455
重载和重写的区别
#456
String StringBuffer 和 StringBuilder 的区别
#457
在一个静态方法内调用一个非静态成员为什么是非法的
#458
自动装箱与拆箱
#459
接口和抽象类的区别是什么
#460
解释Nginx是否支持将请求压缩到上游
#461
成员变量与局部变量的区别有那些
#462
创建一个对象用什么运算符?对象实体与对象引用有何不同?
#463
什么是方法的返回值?返回值在类的方法里的作用是什么?
#464
一个类的构造方法的作用是什么若一个类没有声明构造方法,该程序能正确执行吗?为什么?
#465
构造方法有哪些特性
#466
静态方法和实例方法有何不同
#467
对象的相等与指向他们的引用相等,两者有什么不同?
#468
在调用子类构造方法之前会先调用父类没有参数的构造方法,其目的是?
#469
== 与 equals(重要)
#470
hashCode与equals(重要)
#471
解释如何在Nginx中获得当前的时间?
#472
简述线程,程序、进程的基本概念。以及他们之间关系是什么
#473
线程有哪些基本状态?
#474
关于 final 关键字的一些总结
#475
获取用键盘输入常用的的两种方法
#476
List 和 Set 的区别
#477
HashSet 是如何保证不重复的
#478
HashMap 是线程安全的吗,为什么不是线程安全的(最好画图说明多线程环境下不安全)?
#479
用Nginx服务器解释-s的目的是什么
#480
HashMap 1.7与1.8的区别,说明1.8做了哪些优化,如何优化的?
#481
HashMap 的扩容过程
#482
final finally finalize
#483
对象的四种引用
#484
LinkedHashMap 的应用
#485
Cloneable 接口实现原理
#486
解释如何在Nginx服务器上添加模块
#487
异常分类以及处理机制
#488
数组在内存中如何分配
#489
wait 和 sleep 的区别
#490
JMM中的线程通信机制有哪些？
#491
什么是顺序一致性？其特性是什么？
#492
什么是happens-before原则？其理论内容是什么？
#493
什么是as-if-serial语义？
#494
synchronized是什么？它的原理是什么？
#495
synchronized的锁对象有哪些？
#496
synchronized的实现机制是什么？
#497
什么是monitor？
#498
synchronized的锁优化有哪些？
#499
什么是自旋锁？其优缺点是什么？
#500
什么是适应性自旋锁？
#501
什么是锁消除？判断依据是什么？
#502
什么是锁粗化？
#503
什么是轻量级锁？其性能依据和缺点是什么？
#504
事件驱动模型
#505
什么是偏向锁？其作用是什么？
#506
volatile有什么特性？（可见性、原子性）
#507
volatile的实现机制是什么？
#508
volatile的内存语义是什么？
#509
volatile的操作系统语义是什么？
#510
什么是DCL单例模式？
#511
DCL中存在什么问题？如何解决？
#512
什么是AQS（AbstractQueuedSynchronizer）？它的作用是什么？
#513
AQS采用了什么设计模式？
#514
什么是CLH同步队列？其在AQS中的作用是什么？
#515
Reactor模式
#516
AQS如何实现同步状态的获取与释放（独占式和共享式）？
#517
AQS如何实现线程阻塞和唤醒？
#518
LockSupport是什么？它的park()和unpark()方法的作用是什么？
#519
什么是CAS（Compare And Swap）？它的原理是什么？
#520
CAS存在哪些缺陷？如何解决ABA问题？
#521
什么是ReentrantLock？它的特点是什么？与synchronized有何不同？
#522
ReentrantLock分为哪两种锁？
#523
什么是ReentrantReadWriteLock？它包含哪两把锁？支持哪些特性？
#524
什么是锁降级？
#525
什么是CyclicBarrier？它的作用和应用场景是什么？
#526
CyclicBarrier的底层实现是什么？
#527
什么是CountDownLatch？它的作用是什么？
#528
CountDownLatch与CyclicBarrier的区别是什么？
#529
什么是Semaphore（信号量）？它的作用和应用场景是什么？
#530
什么是Exchanger？它的作用是什么？
#531
Semaphore的内部实现是什么？
#532
ThreadLocal是什么？它的作用是什么？
#533
ThreadLocal的四个方法是什么？
#534
ThreadLocalMap是什么？它如何实现线程隔离？
#535
Netty的特点
#536
ThreadLocal存在内存泄漏问题吗？如何解决？
#537
什么是Fork/Join框架？它的核心思想是什么？
#538
什么是工作窃取？
#539
Fork/Join框架的核心类有哪些？
#540
ConcurrentHashMap的底层存储结构和实现并发安全的机制是什么？
#541
ConcurrentHashMap有哪些重要内部类？它们的作用是什么？
#542
ConcurrentHashMap的initTable方法是如何初始化的？
#543
ConcurrentHashMap的put操作流程是怎样的？
#544
ConcurrentHashMap的get操作流程是怎样的？
#545
ConcurrentHashMap的扩容机制是怎样的？
#546
Netty的线程模型
#547
ConcurrentHashMap 1.8 与 1.7 的区别是什么？
#548
什么是ConcurrentLinkedQueue？它的特点和实现原理是什么？
#549
ConcurrentLinkedQueue的不变性是什么？
#550
什么是SkipList（跳表）？它的特性是什么？
#551
什么是ConcurrentSkipListSet？
#552
atomic包中的基本类型类有哪些？它们的作用是什么？
#553
atomic包中的数组类有哪些？它们的作用是什么？
#554
atomic包中的引用类型类有哪些？它们的作用是什么？
#555
atomic包中的字段类有哪些？它们的作用是什么？
#556
什么是阻塞队列？
#557
什么是LinkedBlockingQueue？
#558
什么是二叉堆？它有哪些分类？
#559
什么是ArrayBlockingQueue？它的特点和实现原理是什么？
#560
什么是DelayQueue？它的作用和应用场景是什么？
#561
什么是SynchronousQueue？它的特点和应用场景是什么？
#562
Delayed接口有什么要求？
#563
什么是LinkedTransferQueue？它的特点和模式是什么？
#564
了解哪几种序列化协议
#565
什么是LinkedBlockingDeque？它的特点和运用场景是什么？
#566
Executor框架中有哪些核心接口和类？
#567
使用线程池的好处有哪些？
#568
ThreadPoolExecutor的参数含义是什么？
#569
ThreadPoolExecutor可以使用哪些阻塞队列？
#570
ThreadPoolExecutor的拒绝策略有哪些？
#571
Executors提供的线程池分类有哪些？它们的特点和分析是什么？
#572
如何向线程池提交任务？
#573
ThreadPoolExecutor的任务执行流程是怎样的？
#574
如何进行线程池调优和监控？
#575
如何选择序列化协议？
#576
什么是ScheduledThreadPoolExecutor？它的作用和内部实现是什么？
#577
Future在异步计算中的作用是什么？
#578
Future提供哪些操作？
#579
什么是FutureTask？它的特点和内部实现是什么？
#580
现在有T1、T2、T3三个线程,你怎样保证T2在T1执行完后执行,T3在T2执行完后执行?
#581
XML
#582
你将如何使用threaddump?你将如何分析 Thread dump?
#583
为什么我们调用start()方法时会执行run()方法,为什么我们不能直接调用run()方法?
#584
什么是竞争条件?你怎样发现和解决竞争?
#585
什么是不可变对象,它对写并发应用有什么帮助?
#586
你在多线程环境中遇到的常见的问题是什么?你是怎么解决它的?
#587
Synchronized 用过吗,其原理是什么?
#588
JSON
#589
你刚才提到获取对象的锁,这个“锁”到底是什么?如何确定对象的锁?
#590
什么是可重入性,为什么说 Synchronized 是可重入锁?
#591
为什么说 Synchronized 是非公平锁?
#592
什么是锁消除和锁粗化?
#593
为什么说 Synchronized 是一个悲观锁?乐观锁的实现原理又是什么?什么是CAS,它有什么特性?
#594
乐观锁一定就是好的吗?
#595
跟 Synchronized 相比,可重入锁 ReentrantLock 其实现原理有什么不同?
#596
那么请谈谈 AQS 框架是怎么回事儿?
#597
Fastjson
#598
请尽可能详尽地对比下 Synchronized 和 ReentrantLock 的异同。
#599
除了 ReetrantLock,你还接触过 JUC 中的哪些并发工具?
#600
请谈谈 ReadWriteLock 和 StampedLock.
#601
ReentrantLock 是如何实现可重入性的?
#602
Cyclic Barrier 和 CountDownLatch 看起来很相似,请对比下呢?
#603
创建线程池的几个核心构造参数?
#604
线程池中的线程是怎么创建的?是一开始就随着线程池的启动创建好的吗?
#605
Thrift
#606
请谈谈 volatile 有什么特点,为什么它能保证变量对所有线程的可见性?
#607
既然 volatile 能够保证线程间的变量可见性,是不是就意味着基于 volatile 变量的运算就是并发安全的?
#608
请对比下 volatile 对比 Synchronized 的异同。
#609
请谈谈 ThreadLocal 是怎么解决并发安全的?
#610
很多人都说要慎用 ThreadLocal,谈谈你的理解,使用 ThreadLocal 需要注意些什么?
#611
工作中遇到的技术问题以及如何解决的？
#612
MyISAM和InnoDB的使用场景和差别是什么？
#613
Avro
#614
行级锁的死锁问题是什么？如何解决？
#615
InnoDB索引结构是什么？
#616
聚簇索引和非聚簇索引是什么？
#617
常用的索引类型有哪些？联合索引无法命中得情况是什么？
#618
主动复制是什么？
#619
读写分离是什么？
#620
Protobuf
#621
RDB和AOF是什么？它们有什么区别？
#622
AOF文件过大时是否会影响性能？
#623
RDB生成快照是否会阻塞执行？
#624
Netty的零拷贝实现
#625
Netty的高性能表现在哪些方面
#626
Vector是如何扩展的？
#627
什么是deep copy（深拷贝）？
#628
给出最大子列和的O(N)解法。
#629
事务场景：A事务可重复读，B事务新增了一条数据，A事务能看到吗？
#630
分库分表有哪些问题？
#631
虚拟机栈会出现OOM吗？
#632
CPU飙升如何排查？
#633
了解Netty吗？
#634
虚拟机栈溢出 (Stack Overflow) 的问题是：
#635
虚拟机栈溢出（Stack Overflow）是什么？
#636
什么情况下会抛出 `StackOverflowError` 异常？
#637
导致 `StackOverflowError` 异常的两种方式是什么？
#638
什么情况下会抛出 `OutOfMemoryError` 异常？
#639
HotSpot VM 的虚拟机栈会发生OOM吗？
#640
MVCC解决的脏读和不可重复读问题
#641
间隙锁就是一种行级锁，所以 RR 在加锁情况下可以避免幻读，不加锁还是存在幻读情况。MVCC 不解决幻读
#642
间隙锁 易造成锁表
#643
pg默认是rc吧，好像rc级别下，是没有间隙锁的
#644
在使用非唯一索引进行 UPDATE 时，为什么 InnoDB 会锁住比匹配记录更多的范围？
#645
当 UPDATE 语句中未使用任何索引时，InnoDB 会如何加锁？这种情况下是否会锁全表？
#646
UPDATE 操作中，InnoDB 是如何使用 Next-Key Lock 来防止幻读的？这种锁的具体加锁范围是什么？
#647
如果两个事务同时执行 UPDATE 并修改相邻或相同范围的数据，InnoDB 如何避免死锁？
#648
UPDATE 使用了 WHERE id > 10 这样的范围条件时，InnoDB 的锁行为是怎样的？是否锁住 id=11 之外的记录？
#649
在 UPDATE 时，如果记录刚好处于某个 gap 中，InnoDB 会加什么类型的锁？这种锁是否影响其他插入操作？
#650
在 RR（可重复读）隔离级别下执行 UPDATE，会触发哪些类型的锁？其与 RC（读已提交）下的差异体现在哪里？
#651
InnoDB 中的行锁是如何与索引绑定的？为什么 UPDATE 没有走索引会导致锁的范围大幅增加？
#652
UPDATE 操作为什么在覆盖多个记录时比 SELECT 更容易引发锁冲突？其背后有什么机制差异？
#653
当事务 A 执行 UPDATE 并持有 gap 锁时，事务 B 是否还能插入新记录？如果能，是通过什么机制实现的？
#654
为什么在 InnoDB 中，UPDATE 可能加上 gap 锁和 record 锁的组合（即 Next-Key Lock），而 INSERT 却不会？
#655
如果两个事务同时执行 UPDATE，且 UPDATE 使用的索引不同，会不会出现死锁？InnoDB 如何检测和解决此类死锁？
#656
在实际操作中，是否能够准确预判哪些租户是大租户，哪些是小租户？如果不能，这会带来什么问题？
#657
Pulsar如何实现分租户？其实现原理是什么？
#658
Pulsar分租户存在哪些潜在的问题或“坑”？（例如：每上架一个租户，都得动态创建该租户消费者）
#659
在IDaaS数据同步中，特别是增量同步的情况下，如果IDP推送来的通讯录事件发生乱序（例如更新事件晚于创建事件），应该如何处理？
#660
HashMap的扩容机制？
#661
ConcurrentHashMap？
#662
CAS机制？
#663
线程池的原理？
#664
线程池拒绝策略？
#665
zookeepe如何保证数据一致性？高可用？
#666
请列举你使用过的JUC包下的工具类。
#667
请阐述HashMap的底层原理。
#668
ReentrantLock在哪些地方应用了AQS？
#669
Lock和Synchronized有什么区别？请说明Synchronized的几种使用方式。
#670
一个字符串类型的值能存储最大容量是多少？
#671
请聊一聊G1垃圾回收器。
#672
什么情况下会触发Full GC？当出现Full GC时，你会如何排查？
#673
请说明ReentrantLock中的同步队列和等待队列的区别。
#674
当服务器CPU飙升时，你会如何进行排查？
#675
什么是意向锁？它通常出现在哪些场景？
#676
请聊一聊你熟悉的设计模式，并结合具体场景说明它们的应用。
#677
给定一个有序数组，在部分旋转后查找某个元素的位置，要求时间复杂度为O(log n)。请描述你的解题思路。
#678
什么是面向对象？
#679
for range 的时候它的地址会发生变化么？
#680
uint 类型溢出问题是什么？
#681
调用函数传入结构体时，应该传值还是指针？
#682
能介绍下 rune 类型吗？
#683
单引号，双引号，反引号的区别？
#684
怎么去复用一个接口的方法？
#685
单步调试怎么做？
#686
值拷贝 与 引用拷贝，深拷贝 与 浅拷贝的区别？
#687
数组和切片的区别？
#688
从数组中取一个相同大小的slice有成本吗？
#689
map 使用注意的点，是否并发安全？
#690
map 循环是有序的还是无序的？
#691
什么类型可以作为map 的key？
#692
怎么处理对 map 进行并发访问？有没有其他方案？ 区别是什么？
#693
map 中删除一个 key，它的内存会释放么？
#694
nil map 和空 map 有何不同？
#695
map 是怎么实现扩容的？
#696
map 的查找过程是怎样的？
#697
map 的插入过程是怎样的？
#698
map 的增删查的时间复杂度是多少？
#699
可以对map里面的一个元素取地址吗？
#700
什么是sync.Map？适用场景是什么？
#701
sync.Map的锁机制和自己用锁加上map有什么区别？
#702
值接收者和指针接收者的区别？
#703
iface 和 eface 的区别是什么？
#704
接口的动态类型和动态值分别是什么？
#705
编译器自动检测类型是否实现接口的原理是什么？
#706
接口的构造过程是怎样的？
#707
类型转换和断言的区别？
#708
如何用 interface 实现多态？
#709
接口转换的原理是什么？
#710
context 结构是什么样的？context 使用场景和用途？
#711
进程、线程、协程有什么区别？
#712
什么是 GMP？
#713
G、P、M 的个数分别有限制吗？
#714
为什么要有 P？
#715
调度器的设计策略是什么？
#716
抢占式调度是如何抢占的？
#717
调度器的生命周期是怎样的？
#718
除了 mutex 以外还有那些方式安全读写共享变量？
#719
Mutex 是悲观锁还是乐观锁？悲观锁、乐观锁是什么？
#720
Mutex 有几种模式？
#721
sync.Mutex的特点和用法是什么？
#722
sync.RWMutex的特点和用法是什么？
#723
什么是自旋锁？
#724
什么情况下自旋锁会更改失败？
#725
怎么控制并发数？
#726
什么是sync.Pool？适用场景是什么？
#727
垃圾回收（GC）原理是什么？
#728
三色标记法的流程是什么？
#729
插入写屏障规则是什么？
#730
删除写屏障规则是什么？
#731
混合写屏障的优势有哪些？
#732
GC 的触发时机？
#733
谈谈内存泄露，什么情况下内存会泄露？怎么定位排查内存泄漏问题？
#734
介绍一下大对象小对象，为什么小对象多了会造成 gc 压力？
#735
逃逸分析是怎么进行的？
#736
Gin 框架的介绍及特点？
#737
Gin 的路由机制？
#738
Gin 请求打入到响应的一个过程？
#739
gin目录结构推荐？
#740
Hertz 框架的特点？
#741
Kitex 框架的特点？
#742
有没有遇到过cpu不高但是内存高的场景？怎么排查的？
#743
什么是 DDD 领域驱动设计？
#744
DDD 的核心原则是什么？
#745
请解释实体、值对象、聚合和领域事件的定义及区别。
#746
什么是限界上下文（Bounded Context），它的作用是什么？
#747
可以举例说明多个限界上下文之间是如何互动的。
#748
如何在 DDD 中建模复杂的业务规则？
#749
谈谈使用领域服务、策略模式等方法来处理复杂逻辑的方式。
#750
领域事件（Domain Event）在 DDD 中的意义是什么？
#751
举例说明如何通过领域事件来解耦不同的域和上下文。
#752
如何处理领域模型的演变？
#753
讨论版本控制、重构和迁移策略等方法。
#754
分析领域服务的目标和聚合的业务逻辑如何分离。
#755
如何确保领域服务与聚合之间的职责清晰？
#756
思考实际项目中的挑战和错误处理。
#757
在你的经验中，有哪些常见的陷阱在实施DDD数据一致性时需要避免？
#758
在DDD项目中，你如何确保领域知识在团队成员之间的有效传递和共享？
#759
团队协作模式是什么？
#760
如何确保团队成员在日常工作中有效沟通和协作，特别是在处理复杂领域知识时？
#761
如何进行领域建模？
#762
请描述你在项目中参与的建模活动，使用了哪些工具或方法？
#763
怎样处理领域知识的变更？
#764
当领域知识发生变化时，如何确保所有团队成员都能及时掌握更新的信息？
#765
如何利用文档来支持知识共享？
#766
在DDD项目中，你认为哪些文档是必需的？如何让文档保持最新？
#767
如何组织领域知识分享活动？
#768
能否举例说明你参与过的知识分享会，怎样保证这些活动的高效性？
#769
在跨职能团队中如何促进领域知识共享？
#770
面对不同背景的团队成员，如何调整沟通方式以保证理解的一致性？
#771
如何评估领域知识的掌握程度？
#772
你会采用哪些方法或指标来判断团队成员对领域知识的掌握情况？
#773
失败案例的经验教训是什么？
#774
是否遇到过领域知识传递不畅的情况？如何总结经验教训来改善？
#775
在项目中，哪些技术工具（如版本管理、协作平台等）对知识共享有帮助？
#776
如何利用技术工具支持知识共享？
#777
如何处理领域知识与技术实现之间的矛盾？
#778
在知识共享中，是否遇到过理论与实践的不一致？如何解决这些问题？
#779
请解释最终一致性的概念及其在DDD中的重要性。
#780
你能举一个具体的案例吗，说明如何在DDD项目中实现最终一致性？
#781
在应用最终一致性时，你如何设计补偿机制以处理失败的事务？
#782
讨论补偿事务的概念及其实现方式。
#783
在哪个场景下你认为最终一致性优于强一致性？
#784
如何监控和验证一个系统的最终一致性状态？
#785
请描述你是如何解决数据冲突的，尤其在使用最终一致性时。
#786
你在团队中是如何教育其他成员关于最终一致性的？
#787
最终一致性对用户体验有什么影响？你如何缓解潜在问题？
#788
如何在DDD的界限上下文中实现最终一致性？
#789
描述上下文之间的交互和数据同步策略。
#790
你是如何确定领域模型的边界和聚合根的？
#791
领域模型的设计
#792
限界上下文
#793
事件驱动架构
#794
在使用领域驱动设计时，你如何处理跨服务的事件传播和数据一致性？
#795
领域事件
#796
能否举例说明你是如何定义和使用领域事件来促进服务间的解耦？
#797
持久化方案
#798
测试和验证
#799
你是如何测试领域模型及其行为的？有没有推荐的测试策略？
#800
团队协作
#801
你认为领域驱动设计如何影响开发团队的协作和沟通？
#802
技术选型
#803
演进和迭代
#804
在实施领域驱动设计时，你通常会选择哪些技术栈或工具？为什么？
#805
加锁机制
#806
失败与挑战
#807
在实践领域驱动设计的过程中，你遇到过哪些挑战？是如何克服的？
#808
可以举一个具体的例子吗？
#809
在DDD项目中，你是如何管理和应对技术债务的？
#810
请分享在过去项目中，你如何识别并解决技术债务的具体实例。
#811
在你的团队中，如何确保技术债务的透明度？
#812
讨论你们使用的工具或机制。
#813
分享在资源有限的情况下如何做出决策。
#814
锁互斥机制
#815
你如何平衡技术债务与新功能开发之间的冲突？
#816
如何在迭代中持续管理技术债务？
#817
谈谈你们的迭代周期中是如何融入技术债务管理的。
#818
你认为技术债务的优先级应该如何评估？
#819
讨论分类标准或评估方法。
#820
在处理技术债务时，你有哪些常用的最佳实践？
#821
如何与业务方沟通技术债务的必要性？
#822
分享你如何向非技术人员解释技术债务的影响。
#823
谈谈你们的团队或个人在项目中所遵循的方法。
#824
当团队成员对技术债务的认知不一致时，你怎么处理？
#825
分享你如何进行团队的教育和沟通。
#826
watchdog自动延期机制
#827
在代码审查过程中，如何确保技术债务的问题被提到？
#828
讨论你所采用的审查策略或工具。
#829
有哪些常见的误区是团队在管理技术债务时容易犯的？
#830
分享你在经验中观察到的错误，以及如何避免这些错误。
#831
你有使用过DDD框架（如Axon, NServiceBus等）吗？如果有，请分享你的使用经验和它们对DDD实现的支持。
#832
请具体描述在项目中如何使用这些框架来支持事件溯源。
#833
分享事件如何生成、存储和重放的过程。
#834
在使用DDD框架时，遇到过哪些挑战，如何解决的？
#835
探讨技术上的难点或团队协作方面的问题。
#836
您如何选择合适的聚合界限？使用框架时有哪些指导经验？
#837
可重入加锁机制
#838
联系领域模型，讨论聚合根和子聚合的问题。
#839
在实现CQRS模式中，您如何处理命令和查询的分离？
#840
说明如何设计命令处理和查询逻辑以实现解耦。
#841
请分享一次使用框架来处理不同版本事件的经历。
#842
描述事件演变的过程及如何保持向后兼容性。
#843
在你的项目中，有没有使用领域事件，能否分享一些使用领域事件的场景和效果？
#844
讨论领域事件的产生、订阅和处理流程。
#845
您如何在跨团队协作中维护领域模型的一致性？
#846
阐述沟通、文档或其他方法在多团队环境中的重要性。
#847
您如何评估DDD框架在项目成功中的作用？
#848
释放锁机制
#849
从度量指标、团队反馈或项目成功案例来分析。
#850
在使用这些框架时，您是如何进行测试的？
#851
讨论单元测试、集成测试和端到端测试的策略。
#852
您如何处理框架的学习曲线和团队成员的适应能力？
#853
pgrep tail-f nohup lsof -i :8080
#854
kill -9 pid
#855
netstat -tulnp | grep :8080
#856
chmod +x content
#857
df -h free -h
#858
show databases;
#859
use db_name;
#860
show tables;
#861
select from table_name;
#862
什么是缓存穿透？如何避免？什么是缓存雪崩？何如避免
#863
缓存穿透、缓存击穿、缓存雪崩解决方案
#864
memcached是怎么工作的？
#865
Memcached的神奇来自两阶段哈希（two-stagehash）
#866
memcached最大的优势是什么？
#867
memcached和服务器的localcache（比如PHP的APC、mmap文件等）相比，有什么优缺点？
#868
memcached的cache机制是怎样的？
#869
memcached如何处理容错的？
#870
如何将memcached中item批量导入导出？
#871
memcached是如何做身份验证的？
#872
memcached的多线程是什么？如何使用它们？
#873
memcached能接受的key的最大长度是多少？
#874
memcached对item的过期时间有什么限制？
#875
memcached最大能存储多大的单个item？
#876
为什么单个item的大小被限制在1Mbyte之内？
#877
Heap  堆表是什么
#878
区分CHAR_LENGTH  字符长度和LENGTH  长度
#879
如何区分FLOAT  漂浮和DOUBLE  双倍的
#880
如何定义REGEXP
#881
CHAR和VARCHAR的区别
#882
列的字符串类型可以是什么
#883
TIMESTAMP在UPDATECURRENT_TIMESTAMP数据类型上做什么
#884
主键和候选键有什么区别
#885
myisamchk是用来做什么的
#886
如何控制HEAP表的最大尺寸
#887
MyISAMStatic和MyISAMDynamic有什么区别
#888
federated表是什么
#889
如果一个表有一列定义为TIMESTAMP，将发生什么
#890
列设置为AUTOINCREMENT时，如果在表中达到最大值，会发生什么情况
#891
怎样才能找出最后一次插入时分配了哪个自动增量
#892
你怎么看到为表格定义的所有索引
#893
LIKE声明中的％和_是什么意思
#894
LIKE和REGEXP操作有什么区别
#895
BLOB和TEXT有什么区别
#896
BLOB和TEXT类型之间的区别
#897
MyISAM表格将在哪里存储，并且还提供其存储格式
#898
ISAM是什么
#899
InnoDB是什么
#900
如何显示前50行
#901
如何输入字符为十六进制数字
#902
可以使用多少列创建索引
#903
什么样的对象可以使用CREATE语句创建
#904
NOW（）和CURRENT_DATE（）有什么区别
#905
解释访问控制列表
#906
32位系统上有什么细微差别
#907
journal回放在条目(entry)不完整时(比如恰巧有一个中途故障了)会遇到问题吗
#908
名字空间(namespace)是什么
#909
如果用户移除对象的属性，该属性是否从存储层中删除
#910
能否使用日志特征进行安全备份
#911
允许空值null吗
#912
更新操作立刻fsync到磁盘
#913
如何执行事务/加锁
#914
启用备份故障恢复需要多久
#915
我必须调用getLastError来确保写操作生效了么
#916
什么是secondary或slave?
#917
为什么我的数据文件如此庞大
#918
什么是master或primary?
#919
数据在什么时候才会扩展到多个分片(shard)里
#920
如果在一个分片(shard)停止或者很慢的时候，我发起一个查询会怎样?
#921
当我试图更新一个正在被迁移的块(chunk)上的文档时会发生什么
#922
如果块移动操作(moveChunk)失败了，我需要手动清除部分转移的文档吗?
#923
当更新一个正在被迁移的块（Chunk）上的文档时会发生什么
#924
我可以把moveChunk目录里的旧文件删除吗
#925
为查询缓存优化你的查询
#926
EXPLAIN你的SELECT查询
#927
当只要一行数据时使用LIMIT1
#928
为搜索字段建索引
#929
你应该也需要知道什么样的搜索是不能使用正常的索引的
#930
在Join表的时候使用相当类型的例，并将其索引
#931
千万不要ORDERBYRAND()
#932
避免SELECT*
#933
永远为每张表设置一个ID
#934
使用ENUM而不是VARCHAR
#935
从PROCEDUREANALYSE()取得建议
#936
尽可能的使用NOTNULL
#937
把IP地址存成UNSIGNEDINT
#938
固定长度的表会更快
#939
垂直分割
#940
拆分大的DELETE或INSERT语句
#941
用PreparedStatement，一般来说比Statement性能高
#942
表中允许适当冗余
#943
请简述常用的索引有哪些种类
#944
表中有大字段X（例如：text类型），且字段X不会经常更新，以读为为主，将该字段拆成子表好处是什么
#945
若一张表中只有一个字段VARCHAR(N)类型，utf8编码，则N最大值为多少(精确到数量级即可)?
#946
[SELECT*]和[SELECT全部字段]的2种写法有何优缺点?
#947
HAVING子句和WHERE的异同点
#948
什么是死信队列
#949
Basic.Reject的用法是什么
#950
为什么不应该对所有的message信息都使用持久化机制
#951
为什么heavyRPC的使用场景下不建议采用disknode
#952
为什么说保证message被可靠持久化的条件是queue和exchange具有durable属性，同时message具有persistent属性才行
#953
deadletter”queue的用途
#954
什么情况下producer不主动创建queue是安全的
#955
数据传输的事务定义有哪三种
#956
producer是否直接将数据发送到broker的leader(主节点)
#957
消费者负载均衡策略
#958
数据有序
#959
RAM node和disk node的区别？
#960
什么是元数据？元数据分为哪些类型？包括哪些内容？与cluster相关的元数据有哪些？元数据是如何保存的？元数据在cluster中是如何分布的？
#961
vhost是什么？起什么作用？
#962
在单node系统和多node构成的cluster系统中声明queue、exchange，以及进行binding会有什么不同？
#963
客户端连接到cluster中的任意node上是否都能正常工作？
#964
cluster中node的失效会对consumer产生什么影响？若是在cluster中创建了mirrored queue，这时node失效会对consumer产生什么影响？
#965
若cluster中拥有某个queue的owner node失效了，且该queue被声明具有durable属性，是否能够成功从其他node上重新声明该queue？
#966
为什么heavy RPC的使用场景下不建议采用disk node？
#967
routing_key和binding_key的最大长度是多少？
#968
什么情况下producer不主动创建queue是安全的？
#969
dead letter queue的用途？
#970
为什么说保证message被可靠持久化的条件是queue和exchange具有durable属性，同时message具有persistent属性才行？
#971
什么情况下会出现blackholed问题？
#972
如何防止出现blackholed问题？
#973
为什么不应该对所有的message都使用持久化机制？
#974
Basic.Reject的用法是什么？
#975
请列举出在JDK中几个常用的设计模式？
#976
什么是设计模式？你是否在你的代码里面使用过任何设计模式？
#977
使用工厂模式最主要的好处是什么？在哪里使用？
#978
设计一个ATM机，请说出你的设计思路？
#979
举例说明什么情况下会更倾向于使用抽象类而不是接口？
#980
什么是悲观锁与乐观锁？
#981
悲观锁的实现原理和应用场景有哪些？
#982
乐观锁的实现原理和应用场景有哪些？
#983
乐观锁常见的两种实现方式是什么？请分别简述。
#984
什么是版本号机制？如何用版本号机制实现乐观锁？
#985
乐观锁的缺点有哪些？
#986
什么是ABA问题？如何解决ABA问题？
#987
CAS如何保证原子性？对多个共享变量有效吗？
#988
CAS和synchronized的使用场景有何不同？
#989
内存调优
#990
垃圾回收策略调优
#991
专业点的分析工具
#992
打印类的加载情况及对象的回收情况
#993
添加JMS远程监控
#994
SpingMvc 中的控制器的注解一般用那个,有没有别的注解可以替代？
#995
@RequestMapping 注解用在类上面有什么作用？
#996
怎么样把某个请求映射到特定的方法上面？
#997
如果在拦截请求中,我想拦截 get 方式提交的方法,怎么配置？
#998
我想在拦截的方法里面得到从前台传入的参数,怎么得到？
#999
如果前台有很多个参数传入,并且这些参数都是一个对象的,那么怎么样快速得到这个对象？
#1000
当一个方法向 AJAX 返回特殊对象,譬如 Object,List 等,需要做什么处理？
#1001
负载平衡的意义什么？
#1002
什么是 Hystrix？它如何实现容错？
#1003
什么是 Hystrix 断路器？我们需要它吗？
#1004
什么是 Netflix Feign？它的优点是什么？
#1005
什么是 YAML？
#1006
什么是 FreeMarker 模板？
#1007
什么是 CSRF 攻击？
#1008
什么是 WebSockets？
#1009
您使用了哪些 starter maven 依赖项？
#1010
什么是 AOP？
#1011
请解释自动装配模式的区别？
#1012
如何开启基于注解的自动装配？
#1013
请举例解释@Required 注解？
#1014
请举例解释@Autowired 注解？
#1015
请举例说明@Qualifier 注解？
#1016
构造方法注入和设值注入有什么区别？
#1017
FileSystemResource 和 ClassPathResource 有何区别？
#1018
#{}和${}的区别是什么？
#1019
接口绑定有几种实现方式,分别是怎么实现的?
#1020
什么情况下用注解绑定,什么情况下用 xml 绑定？
#1021
Xml 映射文件中，除了常见的 select|insert|updae|delete 标签之外，还有哪些标签？
#1022
当实体类中的属性名和表中的字段名不一样，如果将查询的结果封装到指定 pojo？
#1023
模糊查询 like 语句该怎么写
#1024
通常一个 Xml 映射文件，都会写一个 Dao 接口与之对应, Dao 的工作原理，是否可以重载？
#1025
如何获取自动生成的(主)键值？
#1026
在 mapper 中如何传递多个参数？
#1027
resultType resultMap 的区别？
#1028
为什么需要服务治理？
#1029
服务调用超时问题怎么解决？
#1030
消费者比提供者个数多
#1031
RMI 协议
#1032
Hessian 协议
#1033
Webservice
#1034
Thrif
#1035
前后端分离是如何做的
#1036
说说 RPC 的实现原理
#1037
怎么理解 RESTful
#1038
说说如何设计一个良好的 API
#1039
如何理解 RESTful API 的幂等性
#1040
如何保证接口的幂等性
#1041
说说 CAP 定理、 BASE 理论
#1042
怎么考虑数据一致性问题
#1043
说说最终一致性的实现方案
#1044
如何拆分服务
#1045
对于快速追踪与定位问题
#1046
动态代理（cglib 与 JDK）
#1047
如何自定义注解实现功能
#1048
为什么选择 Netty
#1049
说说业务中，Netty 的使用场景
#1050
Netty 线程模型
#1051
说说 Netty 的零拷贝
#1052
Netty 内部执行流程
#1053
何为编程？
#1054
JDK 1.5之后的三大版本是什么？
#1055
什么是跨平台性？原理是什么？
#1056
什么是字节码？采用字节码的最大好处是什么？
#1057
Oracle JDK和OpenJDK的对比是什么？
#1058
switch是否能作用在byte上？是否能作用在long上？是否能作用在String上？
#1059
用最有效率的方法计算2乘以8。
#1060
Math.round(11.5)等于多少？Math.round(-11.5)等于多少？
#1061
float f=3.4;是否正确？
#1062
short s1 = 1; s1 = s1 + 1;有错吗？short s1 = 1; s1 += 1;有错吗？
#1063
访问修饰符public, private, protected, 以及不写（默认）时的区别是什么？
#1064
&和&&的区别是什么？
#1065
final有什么用？
#1066
final, finally, finalize的区别是什么？
#1067
this关键字的用法是什么？
#1068
super关键字的用法是什么？
#1069
this与super的区别是什么？
#1070
static存在的主要意义是什么？
#1071
static的独特之处是什么？
#1072
static的注意事项有哪些？
#1073
static的应用场景有哪些？
#1074
break, continue, return的区别及作用是什么？
#1075
面向对象和面向过程的区别是什么？
#1076
面向过程的定义是什么？
#1077
面向对象的特征有哪些方面？
#1078
面向对象的定义是什么？
#1079
面向对象五大基本原则是什么？
#1080
抽象类和接口的对比是什么？
#1081
抽象类能使用final修饰吗？
#1082
普通类和抽象类有哪些区别？
#1083
创建一个对象用什么关键字？对象实例与对象引用有何不同？
#1084
成员变量与局部变量的区别有哪些？
#1085
成员变量与局部变量的作用域有何不同？
#1086
成员变量与局部变量的存储位置有何不同？
#1087
成员变量与局部变量的生命周期有何不同？
#1088
成员变量与局部变量的初始值有何不同？
#1089
在调用子类构造方法之前会先调用父类没有参数的构造方法，其目的是什么？
#1090
一个类的构造方法的作用是什么？若一个类没有声明构造方法，该程序能正确执行吗？为什么？
#1091
构造方法有哪些特性？
#1092
静态变量和实例变量的区别是什么？
#1093
静态变量与普通变量的区别是什么？
#1094
静态方法和实例方法有何不同？
#1095
在一个静态方法内调用一个非静态成员为什么是非法的？
#1096
什么是方法的返回值？返回值的作用是什么？
#1097
什么是内部类？
#1098
内部类的分类有哪些？
#1099
成员内部类是什么？
#1100
局部内部类是什么？
#1101
静态内部类是什么？
#1102
匿名内部类是什么？
#1103
匿名内部类的创建方式是什么？
#1104
内部类有哪些优点？
#1105
内部类有哪些应用场景？
#1106
局部内部类和匿名内部类访问局部变量的时候，为什么变量必须加上final？
#1107
内部类相关，请说出程序的运行结果。
#1108
构造器（constructor）是否可被重写（override）？
#1109
重载（Overload）和重写（Override）的区别是什么？重载的方法能否根据返回类型进行区分？
#1110
==和equals的区别是什么？
#1111
hashCode与equals的关系是什么？
#1112
hashCode()介绍。
#1113
为什么要有hashCode？
#1114
以“HashSet如何检查重复”为例，说明为什么要有hashCode。
#1115
hashCode()与equals()的相关规定是什么？
#1116
如果equals方法被覆盖过，则hashCode方法也必须被覆盖，为什么？
#1117
对象的相等与指向他们的引用相等，两者有什么不同？
#1118
值传递和引用传递有什么区别？
#1119
当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递？
#1120
JDK中常用的包有哪些？
#1121
Files的常用方法都有哪些？
#1122
什么是反射机制？
#1123
反射机制的优缺点是什么？
#1124
反射机制的应用场景有哪些？
#1125
什么是字符串常量池？
#1126
字符型常量和字符串常量的区别是什么？
#1127
String是最基本的数据类型吗？
#1128
String有哪些特性？
#1129
String为什么是不可变的？
#1130
String真的是不可变的吗？
#1131
是否可以继承String类？
#1132
数组有没有length()方法？String有没有length()方法？
#1133
String类的常用方法都有哪些？
#1134
在使用HashMap的时候，用String做key有什么好处？
#1135
String和StringBuffer、StringBuilder的区别是什么？
#1136
拆箱：将包装类型转换为基本数据类型。int和Integer有什么区别？
#1137
Integer a= 127与Integer b = 127相等吗？
#1138
什么是集合？
#1139
集合的特点是什么？
#1140
集合和数组的区别是什么？
#1141
使用集合框架的好处是什么？
#1142
常用的集合类有哪些？
#1143
List，Set，Map三者的区别是什么？
#1144
List、Map、Set三个接口存取元素时，各有什么特点？
#1145
哪些集合类是线程安全的？
#1146
怎么确保一个集合不能被修改？
#1147
迭代器Iterator是什么？
#1148
Iterator怎么使用？有什么特点？
#1149
Iterator和ListIterator有什么区别？
#1150
说一下ArrayList的优缺点。
#1151
如何实现数组和List之间的转换？
#1152
ArrayList和LinkedList的区别是什么？
#1153
ArrayList和Vector的区别是什么？
#1154
插入数据时，ArrayList、LinkedList、Vector谁速度较快？阐述ArrayList、Vector、LinkedList的存储性能和特性。
#1155
多线程场景下如何使用ArrayList？
#1156
为什么ArrayList的elementData加上transient修饰？
#1157
List和Set的区别是什么？
#1158
说一下HashSet的实现原理？
#1159
HashSet如何检查重复？HashSet是如何保证数据不可重复的？
#1160
HashSet与HashMap的区别是什么？
#1161
BlockingQueue是什么？
#1162
说一下HashMap的实现原理？
#1163
HashMap在JDK1.7和JDK1.8中有哪些不同？HashMap的底层实现是什么？
#1164
JDK1.8之前HashMap的底层实现是什么？
#1165
JDK1.8之后HashMap的底层实现是什么？
#1166
JDK1.7与JDK1.8的HashMap比较有哪些不同？
#1167
HashMap的put方法的具体流程是什么？
#1168
HashMap的扩容操作是怎么实现的？
#1169
什么是哈希冲突？
#1170
HashMap是怎么解决哈希冲突的？
#1171
能否使用任何类作为Map的key？
#1172
为什么HashMap中String、Integer这样的包装类适合作为Key？
#1173
如果使用Object作为HashMap的Key，应该怎么办？
#1174
HashMap为什么不直接使用hashCode()处理后的哈希值直接作为table的下标？
#1175
HashMap的长度为什么是2的幂次方？
#1176
如何决定使用HashMap还是TreeMap？
#1177
HashMap和ConcurrentHashMap的区别是什么？
#1178
HashMap与HashTable有什么区别？
#1179
ConcurrentHashMap和Hashtable的区别是什么？
#1180
ConcurrentHashMap底层具体实现知道吗？实现原理是什么？
#1181
Array和ArrayList有何区别？
#1182
comparable和comparator的区别是什么？
#1183
Vector, ArrayList, LinkedList的区别是什么？
#1184
HashMap的扩容因子是什么？
#1185
HashTable, HashMap，TreeMap区别？
#1186
多线程修改HashMap的问题是什么？
#1187
反射中，Class.forName和classloader的区别是什么？
#1188
字节流和字符流的区别是什么？
#1189
输入流和输出流的区别是什么？
#1190
节点流和处理流的区别是什么？
#1191
InputStream是什么？
#1192
Reader是什么？
#1193
OutputStream是什么？
#1194
Writer是什么？
#1195
Reactor模型是什么？
#1196
Reactor单线程模型是什么？
#1197
Reactor多线程模型是什么？
#1198
主从Reactor多线程模型是什么？
#1199
select和epoll的区别是什么？
#1200
Zero Copy是什么？
#1201
传统的数据传输方式是什么？
#1202
Zero Copy的数据传输方式是什么？
#1203
connect()在非阻塞模式下的行为是什么？
#1204
write()在非阻塞模式下的行为是什么？
#1205
read()在非阻塞模式下的行为是什么？
#1206
非阻塞模式与选择器的关系是什么？
#1207
如何监听新进来的连接？
#1208
String编码UTF-8和GBK的区别是什么？
#1209
什么时候使用字节流、什么时候使用字符流？二者的区别是什么？
#1210
递归读取文件夹下的文件，代码怎么实现？
#1211
SynchronousQueue实现原理是什么？
#1212
SynchronousQueue的简单使用是怎样的？
#1213
SynchronousQueue在公平模式下的模型是怎样的？
#1214
SynchronousQueue在非公平模式下的模型是怎样的？
#1215
如何自定义类加载器？
#1216
JDK和JRE是什么？
#1217
封装的定义是什么？
#1218
继承的定义是什么？
#1219
自动装箱与拆箱是什么？
#1220
多态的定义是什么？
#1221
获取用键盘输入常用的两种方法是什么？
#1222
接口继承关系和实现是什么？
#1223
List的特点是什么？
#1224
Set的特点是什么？
#1225
Map的特点是什么？
#1226
TreeSet和TreeMap的关系是什么？
#1227
TreeMap的添加节点过程是怎样的？
#1228
TreeMap的删除节点过程是怎样的？
#1229
HashMap的死循环问题是什么？
#1230
延伸考察ConcurrentHashMap与HashMap、HashTable等，考察对技术细节的深入了解程度。
#1231
ConcurrentHashMap在jdk1.8中的改进是什么？
#1232
谈谈ConcurrentHashMap1.7和1.8的不同实现。
#1233
深入分析ConcurrentHashMap1.8的扩容实现。
#1234
什么情况会触发ConcurrentHashMap扩容？
#1235
ConcurrentHashMap的transfer实现是怎样的？
#1236
深入浅出ConcurrentHashMap1.8。
#1237
ConcurrentHashMap1.8的重要概念是什么？
#1238
ConcurrentHashMap1.8的实例初始化过程是怎样的？
#1239
ConcurrentHashMap1.8的table初始化过程是怎样的？
#1240
ConcurrentHashMap1.8的table扩容过程是怎样的？
#1241
ConcurrentHashMap1.8的get操作是怎样的？
#1242
说说反射的用途及实现，反射是不是很慢，我们在项目中是否要避免使用反射？
#1243
反射的用途是什么？
#1244
反射的实现方式是什么？
#1245
反射的缺点是什么？
#1246
说说自定义注解的场景及实现。
#1247
List和Map的区别是什么？
#1248
什么场景下使用list，set，map呢？
#1249
Arraylist与LinkedList区别，ArrayList与Vector区别。
#1250
Throwable是什么？
#1251
Error（错误）是什么？
#1252
运行时异常是什么？
#1253
编译时异常是什么？
#1254
受检异常与非受检异常的区别是什么？
#1255
如何声明异常？
#1256
如何抛出异常？
#1257
如何捕获异常？
#1258
常见异常处理方式直接抛出异常是什么？
#1259
封装异常再抛出是什么？
#1260
自定义异常是怎样的？
#1261
try-catch-finally的用法是怎样的？
#1262
try-with-resource的用法是怎样的？
#1263

运维 (9 题)

两个虚拟机中的docker容器如何进行通信 网络如何配置
#1
k8s配置文件挂载方式
#2
docker 十个常用命令
#3
命令行工具（以Linux场景进行详解）。
#4
linux模块和应用程序分别运行在什么空间?
#5
Linux通过什么方式实现系统调用?
#6
Linux软中断和工作队列的作用是什么?
#7
怎么实时查看k8s内存占用的？
#8
linux 常用命令
#9

算法 (62 题)

垃圾回收算法
#1
内层的哈希底层使用两种数据结构实现
#2
GC分哪两种，Minor GC和Full GC有什么区别？什么时候会触发Full GC？分别采用什么算法？
#3
GC算法有哪些？
#4
标记-清除算法是什么？
#5
标记-整理算法是什么？
#6
复制算法是什么？
#7
类加载器的树状组织结构是怎样的？
#8
GC算法，永久代对象如何GC，GC有环怎么处理？
#9
为什么jdk8用metaspace数据结构用来替代perm？
#10
回收算法有哪些？
#11
如何选择合适的垃圾收集算法？
#12
GC的三种收集方法：标记清除、标记整理、复制算法的原理与特点，分别用在什么地方，如果让你优化收集方法，有什么思路？
#13
垃圾回收与算法。
#14
GC分代收集算法VS分区收集算法是什么？
#15
`volatile`关键字的作用（变量可见性、禁止重排序）。
#16
进程调度算法。
#17
索引的数据结构（b树，hash）？
#18
索引算法有哪些？
#19
B树和B+树的区别？
#20
使用B树的好处？
#21
使用B+树的好处？
#22
Hash索引和B+树索引有什么区别或者说优劣呢？
#23
B+树在满足聚簇索引和覆盖索引的时候不需要回表查询数据？
#24
`InnoDB`存储引擎的锁的算法有三种？
#25
红黑树的实现原理和应用场景？
#26
理解分布式id生成算法`SnowFlake`。
#27
GC的三种收集方法：标记清除、标记整理、复制算法的原理与特点，分别用在什么地方？如果让你优化收集方法，有什么思路？
#28
标记清除算法的特点和问题是什么？
#29
复制算法的原理和内存划分是怎样的？
#30
标记整理算法的原理是什么？
#31
什么是重排序？重排序的条件和问题是什么？
#32
ConcurrentHashMap中链表转换为红黑树的条件是什么？
#33
什么是ConcurrentSkipListMap？它使用了哪种数据结构？
#34
B+树数据结构是什么？B树和B+树在数据结构上的差异是什么？
#35
算法题：链表翻转是什么？
#36
在协议设计方面，特别是加密算法的实现，如何与iDAAS业务进行结合或优化？
#37
HashMap的数据结构？
#38
你了解哪些排序算法？
#39
给定一个数组链表（多个链表组成的数组），请按照节点大小顺序合并这些链表，要求时间复杂度为$O(n log n)$。请描述你的解题思路。
#40
讲讲 Go 的 defer 底层数据结构和一些特性？
#41
讲讲 Go 的 select 底层数据结构和一些特性？
#42
讲讲 Go 的 slice 底层数据结构和一些特性？
#43
map 的数据结构是什么？
#44
go channel 的底层实现原理 （数据结构）是什么？
#45
讲讲 Go 的 chan 底层数据结构和主要使用场景？
#46
GC 算法有哪几种？Go采用的是什么？
#47
什么是CAS算法？CAS算法的原理是什么？
#48
CAS算法的三个操作数是什么？
#49
CAS算法在高并发下存在哪些性能问题？
#50
集合框架底层数据结构有哪些？
#51
HashMap的数据结构是什么？
#52
JDK1.8新增的红黑树是什么？
#53
TreeMap和TreeSet在排序时如何比较元素？
#54
红黑树是什么？
#55
红黑树添加节点后的修复过程是怎样的？
#56
红黑树删除节点后的修复过程是怎样的？
#57
红黑树检索节点过程是怎样的？
#58
HashMap内部的数据结构是什么？底层是怎么实现的？
#59
ConcurrentHashMap在JDK1.7的数据结构和put/size实现是怎样的？
#60
ConcurrentHashMap在JDK1.8的数据结构和put/size实现是怎样的？
#61
ConcurrentHashMap1.8的红黑树构造过程是怎样的？
#62

消息队列 (114 题)

kafka零拷贝原理
#1
Pulsar和kafka的区别？为什么选择kafka?
#2
kafka如何避免重复消费问题
#3
kafka如何保证消息不丢失
#4
kafka是什么？可以用来做什么？
#5
为什么kafka安装需要依赖Zookeeper？
#6
pull和push，kafka支持哪种消费模型？为什么这么设计？
#7
Topic的用途是什么？为什么Kafka没有队列？
#8
消息主要的物理存储文件有哪些？
#9
生产者送消息如何选择分区？
#10
Kafka中有哪些索引类型？消息怎么通过索引检索？
#11
kafka的稀疏索引，间隔由什么决定？为什么不用B+Tree？
#12
Kafka的日志文件不可能无限扩大，那么可以通过哪些方式释放磁盘空间？
#13
Kafka副本Leader是怎么选举的？谁来选举？选谁为Leader？什么是AR？什么是ISR？什么是OSR？
#14
Kafka副本follower怎么向Leader同步？什么是HW？什么是LEO？
#15
kafka的offset怎么维护？存在哪里？什么时候更新？
#16
MQ解决了什么通信问题？
#17
MQ的本质是什么？
#18
MQ如何将一次通信变成两次通信？
#19
MQ与HTTP、TCP的不同之处在哪里？
#20
MQ如何实现存储与转发？
#21
MQ的通信协议有哪些？
#22
MQ的存储系统如何设计？
#23
MQ的索引机制是怎样的？
#24
MQ是否需要持久化？持久化是内存还是磁盘？
#25
MQ是一对一还是广播模型？
#26
MQ的可靠性如何保证？Broker和消费者如何确认消息？
#27
MQ如何实现顺序消息？
#28
MQ是否支持历史消息消费？
#29
MQ如何处理重复消息？
#30
MQ如何支持批量消息？
#31
MQ如何支持事务？
#32
MQ的服务端如何实现？
#33
MQ的客户端如何实现？
#34
MQ是否提供web UI？
#35
MQ采用pull还是push模型？
#36
消息队列的作用与使用场景?
#37
多个项目共用MQ服务器，怎么实现权限隔离?
#38
RabbitMQ的消息有哪些路由方式? 适合在什么业务场景使用?
#39
使用描述性消息抛出异常。
#40
无法被路由的消息，去了哪里?
#41
消息在什么时候会变成Dead Letter（死信）?
#42
如果一个项目要从多个服务器接收消息，怎么做?
#43
如果一个项目要发送消息到多个服务器，怎么做?
#44
RabbitMQ如何实现延迟消息? 例如订单15分钟未支付自动关闭
#45
哪些情况会导致消息丢失? 怎么解决?
#46
一个队列最多可以存放多少条消息?
#47
可以用队列的x-max-length最大消息数来实现限流吗? 例如秒杀场景
#48
如何提高消息的消费速率?
#49
AmqpTemplate和RabbitTemplate的区别?
#50
如何保证消息的顺序性?
#51
RabbitMQ的集群节点类型? 区别是什么?
#52
如何保证RabbitMQ的高可用?
#53
大量消息堆积怎么办?
#54
MQ选型分析?
#55
设计一个MQ，你的思路是什么?
#56
进程通讯的方式：消息队列，共享内存，信号量，socket通讯等。
#57
Linux进程间通信方式--信号，管道，消息队列，信号量，共享内存。
#58
消息队列是什么？
#59
MQ的使用场景有哪些？
#60
如何保证MQ的数据不会被重复消费？
#61
Kafka的主从复制及high watermark机制实现原理是什么？
#62
Kafka rebalance出现的原因及详细技术细节描述是什么？
#63
在通过Kafka进行用户同步时，如何解决不同租户间不相互阻塞的问题？具体场景是：假如A租户同步10万用户，B租户只需要同步10个用户，如果A先同步，会不会阻塞B租户的同步？
#64
对于Kafka的租户隔离，是否考虑过租户分级的方案，例如小租户共用一个topic，大租户用单独的topic？这种方案的挑战是什么？
#65
Kafka中是否有实现优先级同步的机制，使得少量租户能够优先同步？
#66
Kafka分区如何帮助解决不同租户间的同步阻塞问题？
#67
kafka的高可用？
#68
使用事件驱动架构或消息队列等技术。
#69
在应用最终一致性时，你会选择何种消息传递协议？为什么？
#70
消息中间件
#71
activemq的几种通信方式
#72
activemq如果数据提交不成功怎么办(消息丢失)
#73
如何解决消息重复问题
#74
activeMQ发送消息的方式有哪些
#75
大量的消息每页被消费，能否发生oom异常
#76
activeMQ如何调优
#77
向不存在的exchange发publish消息会发生什么？向不存在的queue执行consume动作会发生什么
#78
Kafka的设计时什么样的
#79
Kafka判断一个节点是否还活着有那两个条件
#80
Kafaconsumer是否可以消费指定分区消息
#81
Kafka消息是采用Pull模式，还是Push模式
#82
Kafka存储在硬盘上的消息格式是什么
#83
Kafka高效文件存储设计特点
#84
Kafka与传统消息系统之间有三个关键区别
#85
Kafka创建Topic时如何将分区放置到不同的Broker中
#86
Kafka新建的分区会在哪个目录下创建
#87
kafka的ack机制
#88
Kafka的消费者如何消费数据
#89
kafka生产数据时数据的分组策略
#90
RabbitMQ中的broker是指什么？cluster又是指什么？
#91
RabbitMQ上的一个queue中存放的message是否有数量限制？
#92
RabbitMQ概念里的channel、exchange和queue这些是逻辑概念，还是对应着进程实体？这些分别起什么作用？
#93
向不存在的exchange发publish消息会发生什么？向不存在的queue执行consume动作会发生什么？
#94
能够在地理上分开的不同数据中心使用RabbitMQ cluster么？
#95
RabbitMQ允许发送的message最大可达多大？
#96
RabbitMQ中的cluster、mirrored queue，以及warrens机制分别用于解决什么问题？存在哪些问题？
#97
什么是ActiveMQ？
#98
ActiveMQ服务器宕机怎么办？
#99
ActiveMQ的持久化消息和非持久化消息在存储和恢复上有什么区别？
#100
如果ActiveMQ的持久化文件或临时文件达到最大限制会发生什么？
#101
ActiveMQ如何防止消息丢失？
#102
ActiveMQ在什么情况下会丢消息？如何解决？
#103
持久化消息为什么非常慢？如何提升持久化消息的发送效率？
#104
ActiveMQ消息消费不均匀的原因是什么？如何解决？
#105
什么是ActiveMQ的prefetch机制？如何设置？
#106
ActiveMQ如何处理死信队列？
#107
AUTO_ACKNOWLEDGE模式下，消息何时被确认？如何阻止消息被确认？
#108
如果一条消息反复处理失败会发生什么？
#109
ActiveMQ的消息重发时间间隔和重发次数如何设置？
#110
ActiveMQ在什么情况下会将消息重发给消费者？
#111
ActiveMQ的Redelivery Policy有哪些可配置参数？各自含义是什么？
#112
ActiveMQ如何判断消费者是否已经处理完消息？
#113
什么是 Apache Kafka？
#114

网络 (68 题)

分区Partition的作用是什么？
#1
Queue、Exchange、Topic、Consumer Group、Partition、Message Queue等对象分别是什么？有何区别？
#2
Error和Exception区别是什么？
#3
NoClassDefFoundError和ClassNotFoundException区别？
#4
类ExampleA继承Exception，类ExampleB继承ExampleA。
#5
常见的RuntimeException有哪些？
#6
RejetedExecutionHandler：饱和策略是什么？
#7
模式 #2：一次性安全发布（one-time safe publication）。
#8
模式 #3：独立观察（independent observation）。
#9
可选择的饱和策略RejectedExecutionHandler详解。
#10
`Condition`类和`Object`类锁方法区别。
#11
NIO是什么？适用于何种场景？
#12
`UNION`与`UNION ALL`的区别？
#13
请解释Nginx如何处理HTTP请求
#14
优化UNION查询。
#15
请解释ngx_http_upstream_module的作用是什么
#16
Arrays.sort 和 Collections.sort 实现原理和区别
#17
Collection和Collections区别
#18
BIO、NIO和AIO的区别
#19
什么是Condition？它的作用是什么？
#20
NIO的组成
#21
TCP粘包/拆包的原因及解决方法
#22
什么是PriorityBlockingQueue？它的特点和实现原理是什么？
#23
TCP三次握手过程是怎样的？
#24
TCP四次挥手过程是怎样的？
#25
IO多路复用函数（如select、epoll、poll）的区别是什么？它们的实现原理是什么？
#26
IOC常用注解、工作流程是什么？
#27
NIOEventLoopGroup源码？
#28
IO多路复用是什么？
#29
分片(sharding)和复制(replication)是怎样工作的
#30
如果我在使用复制技术(replication)，可以一部分使用日志(journaling)而其他部分则不使用吗?
#31
UNIONALL要比UNION快很多
#32
partition的数据如何保存到硬盘
#33
Consumer Cancellation Notification机制用于什么场景？
#34
共享session处理
#35
使用黏性session的策略
#36
怎么样在方法里面得到 Request,或者 Session？
#37
怎么样把 ModelMap 里面的数据放入 Session 里面？
#38
什么是控制反转(IOC)？什么是依赖注入？
#39
BeanFactory 和 ApplicationContext 有什么区别？
#40
简述AOP和IOC概念AOP:
#41
IOC容器对Bean的生命周期:
#42
http
#43
BeanFactory 和 ApplicationContext 有什么区别
#44
原生的 NIO 在 JDK 1.7 版本存在 epoll bug
#45
什么是 TCP 粘包/拆包
#46
TCP 粘包/拆包的解决办法
#47
BIO, NIO, AIO有什么区别？
#48
List、Set、Map是否继承自Collection接口？
#49
如何边遍历边移除Collection中的元素？
#50
Collection和Collections有什么区别？
#51
Collections工具类中的sort()方法如何比较元素？
#52
讲讲IO里面的常见类，字节流、字符流、接口、实现类、方法阻塞。
#53
IO流的概念是什么？
#54
IO流的分类有哪些？
#55
IO流的四大基类是什么？
#56
讲讲NIO。
#57
NIO技术概览。
#58
两种IO多路复用方案：Reactor和Proactor。
#59
IO模型的分类有哪些？
#60
传统BIO模型是什么？
#61
NIO的实现原理是什么？
#62
AIO是什么？
#63
NIO与epoll的关系是什么？
#64
NIO存在的问题是什么？
#65
FileChannel的position方法有什么用？
#66
Collection里面有什么子类？
#67
Exception（异常）是什么？
#68

分布式 (71 题)

ZooKeeper是什么
#1
ZooKeeper提供了什么
#2
Zookeeper文件系统
#3
Zookeeper通知机制
#4
Zookeeper做了什么
#5
Zookeeper集群管理（文件系统、通知机制）
#6
Zookeeper分布式锁（文件系统、通知机制）
#7
获取分布式锁的流程
#8
Zookeeper队列管理（文件系统、通知机制）
#9
Zookeeper数据复制
#10
Zookeeper工作原理
#11
zookeeper是如何保证事务的顺序一致性的？
#12
Zookeeper下Server工作状态
#13
zookeeper是如何选取主leader的
#14
Zookeeper同步流程
#15
分布式通知和协调
#16
zookeeper负载均衡和nginx负载均衡区别
#17
zookeeperwatch机制
#18
分布式事务的原理2阶段提交，同步异步阻塞非阻塞？
#19
分布式事务实现？
#20
Seata分布式事务的原理是什么？会选择哪种模式？
#21
分布式定时任务（例如基于XXL-JOB）在用户同步场景中的应用是什么？
#22
ZooKeeper有哪些常见的使用场景？
#23
请给出一个具体的例子，说明如何在DDD项目中应用“最终一致性”来处理分布式系统中的数据一致性问题。
#24
如何确保在分布式系统中数据的一致性，并防止孤立的数据状态。
#25
如何在微服务架构中使用领域驱动设计？
#26
你如何识别和定义微服务中的限界上下文？如何确保上下文之间的交互？
#27
随着业务需求的变化，你是如何调整领域模型和微服务的？
#28
Dubbo 超时时间怎样设置？
#29
Dubbo 支持哪些协议，每种协议的应用场景，优缺点？
#30
Dubbo 有哪些注册中心？
#31
Dubbo 集群的负载均衡有哪些策略？
#32
Dubbo 是什么？
#33
Dubbo 的主要应用场景？
#34
Dubbo 的核心功能？
#35
Dubbo 的核心组件？
#36
Dubbo 服务注册与发现的流程？
#37
Dubbo 的架构设计？
#38
Dubbo 的服务调用流程？
#39
dubbo 推荐用什么协议？
#40
Dubbo 默认采用注册中心？
#41
Dubbo 的注册中心集群挂掉，发布者和订阅者之间还能通信么？
#42
Dubbo 使用的是什么通信框架?
#43
Dubbo 集群提供了哪些负载均衡策略？
#44
Dubbo 的默认集群容错方案？
#45
Dubbo 的集群容错方案有哪些？
#46
Dubbo 支持哪些序列化方式？
#47
Dubbo 在安全机制方面是如何解决？
#48
Dubbo 和 Dubbox 之间的区别？
#49
Dubbo 的广播模式适合哪些场景？
#50
Dubbo 支持异步调用吗？
#51
Dubbo 如何实现优雅停机？
#52
如何使用 telnet 连接 dubbo 服务进行测试？
#53
如何对 dubbo 服务进行泛化调用？
#54
Dubbo 的 SPI 扩展机制原理是什么？
#55
Dubbo 中 zookeeper 做注册中心，如果注册中心集群都挂掉，发布者和订阅者之间还能通信么？
#56
dubbo 服务负载均衡策略？
#57
Dubbo 在安全机制方面是如何解决的
#58
dubbo 连接注册中心和直连的区别
#59
dubbo 服务集群配置（集群容错模式）
#60
dubbo 通信协议 dubbo 协议为什么要消费者比提供者个数多
#61
dubbo 通信协议 dubbo 协议为什么不能传大包
#62
dubbo 通信协议 dubbo 协议为什么采用异步单一长连接
#63
dubbo 通信协议 dubbo 协议适用范围和适用场景
#64
微服务
#65
微服务哪些框架
#66
说说 Dubbo 的实现原理
#67
你怎么看待微服务
#68
微服务与 SOA 的区别
#69
如何应对微服务的链式调用异常
#70
微服务的安全
#71
返回首页