java全集持续更新维护

一个幂等操作的特点是其任意多次执行所产生的影响均与一次执行的影响相同。幂等函数，或幂等方法，是指可以使用相同参数重复执行，并能获得相同结果的函数。这些函数不会影响系统状态，也不用担心重复执行会对系统造成改变

重复提交、重复请求，重复支付

查询操作、删除操作、唯一索引

前端重复提交表单

用户恶意进行刷单

接口超时重复提交

消息进行重复消费

数据库唯一主键

数据库乐观锁

防重 Token 令牌

下游传递唯一序列号

对比图

JDK(Java Development Kit)是程序开发者用来来编译、调试java程序用的开发工具包。JDK的工具也是Java程序，也需要JRE才能运行。为了保持JDK的独立性和完整性，在JDK的安装过程中，JRE也是 安装的一部分。所以，在JDK的安装目录下有一个名为jre的目录，用于存放JRE文件

JRE(JavaRuntimeEnvironment，Java运行环境)，也就是Java平台。所有的Java 程序都要在JRE下才能运行。普通用户只需要运行已开发好的java程序，安装JRE即可

原理

关系

Java\jre1.8.0_181\lib\amd64\jvm.cfg，64位支持server模式

Java\jre1.8.0_181\lib\i386\jvm.cfg, 32位支持server 、 client 模式切换

配置模式：
-server KNOWN
-client IGNORE

Client 模式启动时，速度较快，启动之后不如 Server，适合用于桌面等有界面的程序

-Server 模式启动时，速度较慢，但是启动之后，性能更高，适合运行服务器后台程序

作用

描述

所有线程共享

Java堆在虚拟机启动时创建，是Java虚拟机所管理的内存中最大的一块。Java堆的唯一目的就是存放对象实例和数组

结构

设置参数

结构

描述

调整栈的深度：-Xss1m

虚拟机栈操作的是java方法的服务栈

本地方法栈操作非虚拟机栈以外的window服务栈

方法区也有一个别名叫做Non-Heap（非堆），用于与Java堆区分

用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据

存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码数据等

lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态

unlock（解锁）：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定

read（读取）：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用

load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中

use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作

assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作

store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作

write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。

简图

volatile

synchronized

Synchronized、Lock来保证代码块内的操作是原子的

在Java中可以使用volatile关键字来保证多线程操作时变量的可见性
volatile的功能是被其修饰的变量在被修改后可以立即同步到主内存，而被其修饰的变量在每次使用之前都会从主内存刷新。除此之外，synchronized和final两个关键字也可以实现可见性 。volatile也可以看作是轻量级的锁，在其内部使用了Lock指令来解决可见性问题。

在Java中，可以使用synchronized和volatile来保证多线程之间操作的有序性。只是实现方式有所区别： volatile关键字会禁止指令重排，synchronized关键字保证同一时刻只允许一个线程的操作

volatile 、synchronized
volatile可以禁止指令重排序，synchronized是在同一时刻只允许一个线程操作

主内存与工作内存 之间的关系

java.lang.OutOfMemoryError: Java heap space异常

java.lang.OutOfMemoryError: PermGen space异常

java.lang.StackOverflowError异常

-server:一定要作为第一个参数，在多个CPU时性能佳 ，表示以服务模式启动，启动速度会稍 微慢一点，但性能会高很多。不加这个参数，默认是以客户端模式启动

-Xms：java Heap初始大小。 默认是物理内存的1/64

-Xmx：java heap最大值。默认是物理内存的1/4，建议设为物理内存的一半。不可超过物理内存

-XX:PermSize:设定内存的永久保存区初始大小，缺省值为64M

-XX:MaxPermSize:设定内存的永久保存区最大 大小，缺省值为64M

-XX:SurvivorRatio=2 :生还者池的大小,默认是2，如果垃圾回收变成了瓶颈，您可以尝试定制生成池设置

-XX:NewSize: 新生成的池的初始大小。 缺省值为2M

-XX:MaxNewSize: 新生成的池的最大大小。 缺省值为32M

内存溢出生成文件

初始内存太小，无法触发GC回收

堆内存溢出代码

堆内存垃圾回收配置

1、虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可被虚拟机直接使用的Java类型的过程

2、类的加载指的是将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个 java.lang.Class对象，用来封装类在方法区内的数据结构。

概念

引导（Bootstrap）类加载器。由原生代码（如C语言）编写，不继承自java.lang.ClassLoader。负责加载核心Java库，存储在<JAVA_HOME>/jre/lib目录中（rt.jar等等基础包）

扩展（Extensions）类加载器。用来在<JAVA_HOME>/jre/lib/ext,[6]或java.ext.dirs中指明的目录中加载 Java的扩展库。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。该类由sun.misc.Launcher$ExtClassLoader实现

Apps类加载器（也称系统类加载器）。根据 Java应用程序的类路径（java.class.path或CLASSPATH环境变量）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader()来获取它。该类由sun.misc.Launcher$AppClassLoader实现

可自定义类加载器，继承classLoader 重写 

双亲委派机制

加载（类加载器）（内存：方法区）

链接

初始化（内存：堆区（class对象））

标记-清楚算法（Mark-Sweep）：最基础的垃圾回收算法

复制算法（Copying）

标记整理算法（Mark-Compact）（标记压缩算法、标记清除压缩算法）

分代收集算法(Generational Collection)

serial收集器：

ParNew收集器

parallel收集器

Parallel Old收集器？

CMS收集器

G1收集器

当前程序空闲，垃圾回收器会自动触发

堆内存空间不足，触发垃圾回收，先轻量GC（新生待） ，后 重量GC（老年代）

概念：强引用(Strong Reference)是最普通的引用，以=进行赋值，例如String s="ni hao"、User user=new User()中的s就是一个强引用

特点：只要有引用存在，那么堆中数据不会被回收，哪怕是OOM

概念：软引用（SoftReference）是一种比强引用弱的引用

特点：在内存足够的时候，软引用对象不会被回收，只有在内存不足时，系统则会回收软引用对象

关键说明：

场景：可以是在排除过期数据的情况下。JDK中有个类叫ResourceBundle，内部会使用ConcurrentMap缓存ResourceBundle对象，这里就是使用的软引用机制

概念：是比软引用更弱的一种引用

特点：无论内存空间是否充足，都会将堆中的弱引用的数据空间回收。

场景：较为复杂的数据结构中，为了避免内存泄露而使用的一种引用方式

示例：
ThreadLocal的存在是提供了一种线程内全局的上下文容器，类似Spring中的Context，只不过使用范围是在当前线程内。
它可以简化同一个线程内多个方法直接参数的重复传递，隔离其他线程的干扰。
原理是把ThreadLocal变量以弱key的形式存放在java.lang.ThreadLocal.ThreadLocalMap中。
java.lang.ThreadLocal.ThreadLocalMap.Entry就是继承了WeakReference，把ThreadLocal作为一种弱引用存在于map中的key中，一旦ThreadLocal变量的引用被回收或者被置为null值的时候，JVM就会将数据中的key也回收掉并置为null值。
可以写个例子来证明上面的结论

概念：虚引用是使用PhantomReference创建的引用，虚引用也称为幽灵引用或者幻影引用，是所有引用类型中最弱的一个。一个对象是否有虚引用的存在，完全不会对其生命周期构成影响，也无法通过虚引用获得一个对象实例

特点：
GC随时回收，无需考虑任务情况
虚引用是最弱的引用
虚引用对对象而言是无感知的，对象有虚引用跟没有是完全一样的
虚引用不会影响对象的生命周期
虚引用可以用来做为对象是否存活的监控

场景：
使用虚引用的目的就是为了得知对象被GC的时机，所以可以利用虚引用来进行销毁前的一些操作，比如说资源释放等。这个虚引用对于对象而言完全是无感知的，有没有完全一样，但是对于虚引用的使用者而言，就像是待观察的对象的把脉线，可以通过它来观察对象是否已经被回收，从而进行相应的处理。

事实上，虚引用有一个很重要的用途就是用来做堆外内存的释放，DirectByteBuffer就是通过虚引用来实现堆外内存的释放的。

热点代码

字节码：

机器码和本地代码：可以直接识别运行的代码，也就是机器指令

java

编译器：把源程序的每一条语句都编译成机器语言,并保存成二进制文件,这样运行时计算机可以直接以机器语言来运行此程序,速度很快;

解释器：只在执行程序时,才一条一条的解释成机器语言给计算机来执行,所以运行速度是不如编译后的程序运行的快的；

1、必须指出的是，不管是解释执行，还是编译执行，最终执行的代码单元都是可直接在真实机器上运行的机器码，或称为本地代码
2、JIT是一种提高程序运行效率的方法。通常，程序有两种运行方式：静态编译与动态解释。静态编译的程序在执行前全部被翻译为机器码，而动态解释执行的则是一句一句边运行边翻译

编译阶段

装配阶段

实例化阶段

什么是类：类是一个模板，它描述一类对象的行为和状态（类是抽象的模板，所有的  ".class "  文件,加载到JVM中都被定义为Class类型）

什么是对象：对象是java类的定义，有状态和行为（例如：User类、Patient类）

什么是实例：是承载数据的载体，对象的具体实例

什么是反射

类型获取方式

类的结构

实例化的方式（5种）

Member 接口：反映关于单个成员(字段或方法)或构造函数的标识信息

Field 类：提供一个类的域的信息以及访问类的域的接口

Method 类：提供一个类的方法的信息以及访问类的方法的接口

Constructor 类：提供一个类的构造函数的信息以及访问类的构造函数的接口

Array 类：该类提供动态地生成和访问 JAVA 数组的方法

Modifier 类：提供了 static 方法和常量，对类和成员访问修饰符进行解码

Proxy 类：提供动态地生成代理类和类实例的静态方法

开发通用框架 -
反射最重要的用途就是开发各种通用框架。很多框架（比如 Spring）都是配置化的（比如通过 XML 文件配置 JavaBean、Filter 等），为了保证框架的通用性，它们可能需要根据配置文件加载不同的对象或类，调用不同的方法，这个时候就必须用到反射——运行时动态加载需要加载的对象。

动态代理 -
在切面编程（AOP）中，需要拦截特定的方法，通常，会选择动态代理方式。这时，就需要反射技术来实现了

注解 -
注解本身仅仅是起到标记作用，它需要利用反射机制，根据注解标记去调用注解解释器，执行行为。如果没有反射机制，注解并不比注释更有用

可扩展性功能 -
 应用程序可以通过使用完全限定名称创建可扩展性对象实例来使用外部的用户定义类
（动态创建对象，实现外部扩展的功能）

性能开销 -
由于反射涉及动态解析的类型，因此无法执行某些 Java 虚拟机优化。因此，反射操作的性能要比非反射操作的性能要差，应该在性能敏感的应用程序中避免频繁调用反射动态解析

破坏封装性 -
 反射调用方法时可以忽略权限检查，因此可能会破坏封装性而导致安全问题

内部曝光 -
 由于反射允许代码执行在非反射代码中非法的操作，例如访问私有字段和方法，所以反射的使用可能会导致意想不到的副作用，这可能会导致代码功能失常并可能破坏可移植性。反射代码打破了抽象，因此可能会随着平台的升级而改变行为

定义：隐藏对象的属性和实现细节，仅对外公开接口,控制在程序中属性的读和修改的访问级别

目的：

主要特点

概念

主要特点

与接口的区别

概念

特点

概念：

前提

功能增强：代理可以在不破坏原有的功能基础功能之上，进行功能的扩展即增强

访问控制：可以在访问源功能的时候进行限流或控制访问

动态代理是一种方便运行时动态构建代理、动态处理代理方法调用的机制，很多场景都是利用类似机制做到的，比如用来包装 RPC 调用、面向切面的编程（AOP）

实现动态代理的方式很多，比如 JDK 自身提供的动态代理，主要利用反射机制实现

JDK代理、ASM、cglib（基于 ASM）、Javassist

代码实现

优点：

缺点：

特点

JDK代理

CGLIB代理

进程

创建方式3种

线程的状态

线程主要方法

线程终止原因

volatile

修饰作用域

实现原理

特点：保证内存可见性、操作原子性

概念

主要解决的问题：

编译代码会生成lock指令

实现分析：

概念：Java 主要利用 Unsafe 这个类提供的 CAS 操作。Unsafe 的 CAS 依赖的是 JVM 针对不同的操作系统实现的硬件指令 Atomic::cmpxchg。Atomic::cmpxchg 的实现使用了汇编的 CAS 操作，并使用 CPU 提供的 lock 信号保证其原子性

特点：CAS 比锁性能更高。因为 CAS 是一种非阻塞算法，所以其避免了线程阻塞和唤醒的等待时间

缺点:

是什么

原理

内存溢出点

可重入锁

注解是以 @ 字符开始的修饰符

如果注解没有属性，则称为标记注解。如：@Override

从本质上来说，注解是一种标签，其实质上可以视为一种特殊的注释，如果没有解析它的代码，它并不比普通注释强

解析一个注解往往有两种形式：

1、编译期直接的扫描 - 编译器的扫描指的是编译器在对 java 代码编译字节码的过程中会检测到某个类或者方法被一些注解修饰，这时它就会对于这些注解进行某些处理。这种情况只适用于 JDK 内置的注解类。
2、运行期的反射 - 如果要自定义注解，Java 编译器无法识别并处理这个注解，它只能根据该注解的作用范围来选择是否编译进字节码文件。如果要处理注解，必须利用反射技术，识别该注解以及它所携带的信息，然后做相应的处理。

概念：是一个接口，程序可以通过反射来获取指定程序元素的注解对象，然后通过注解对象来获取注解里面的元数据。

子主题

概念：元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其它的注解上面

@Retention

@Documented

@Target

@Inherited

@Repeatable

@Override

@Deprecated

@SuppressWarnings

@FunctionalInterface

@SafeVarargs

注解的定义

注解属性

所有的Class/Field/Method对象都可以调用上述方法

getAnnotations()： 获取所有的注解，包括自己声明的以及继承的

getAnnotation(Class< A > annotationClass) 获取指定的注解，该注解可以是自己声明的，也可以是继承的

getDeclaredAnnotations() 获取自己声明的注解

编译时的强类型检查

消除强制类型转换带来的问题

泛型编程可以实现通用算法

泛型类（class className<T1, T2, ..., Tn>）

泛型接口(public interface Content<T> {T text();})

泛型方法(public <T> T func(T obj) {})

概念

编译期间擦除：

泛型不能用于显式地引用运行时类型的操作之中，例如：转型、instanceof 操作和 new 表达式。因为所有关于参数的类型信息都丢失了。当你在编写泛型代码时，必须时刻提醒自己，你只是看起来好像拥有有关参数的类型信息而已。

正是由于泛型时基于类型擦除实现的，所以，泛型类型无法向上转型。

向上转型是指用子类实例去初始化父类，这是面向对象中多态的重要表现。

Integer 继承了 Object；ArrayList 继承了 List；但是 List<Interger> 却并非继承了 List<Object>。

这是因为，泛型类并没有自己独有的 Class 类对象。比如：并不存在 List<Object>.class 或是 List<Interger>.class，Java 编译器会将二者都视为 List.class。

概念：可以对泛型的类型参数设置限制条件

概念：类型通配符一般是使用 ? 代替具体的类型参数。例如 List<?> 在逻辑上是 List<String> ，List<Integer> 等所有 List<具体类型实参> 的父类。

上界通配符（<? extends Number>）

下界通配符(<? super Number>)

无界通配符<?>

通配符和向上转型

泛型类型的类型参数不能是值类型

不能创建类型参数的实例

不能声明类型为类型参数的静态成员

类型参数不能使用类型转换或 instanceof

不能创建类型参数的数组

不能创建、catch 或 throw 参数化类型对象

仅仅是泛型类相同，而类型参数不同的方法不能重载

阻塞式 I/O

非阻塞式 I/O

I/O 复用

信号驱动 I/O

异步 I/O

五大 I/O 模型比较

同步 I/O 与异步 I/O

阻塞式 I/O、非阻塞式 I/O、I/O 复用和信号驱动 I/O 都是同步 I/O，虽然非阻塞式 I/O 和信号驱动 I/O 在等待数据阶段不会阻塞，但是在之后的将数据从内核复制到应用进程这个操作会阻塞

概念：传统IO，同步阻塞IO，数据读写方式：面向流

关键概念

创建流程

特点

概念：基于IO多路复用技术的“非阻塞式IO”。简单来说，内核将可读可写事件通知应用，由应用主动发起读写操作
数据的读写方式面向：缓存区

关键概念

创建流程

特点

概念：非阻塞异步IO模型。简单来说，内核将读完成事件通知应用，读操作由内核完成，应用只需操作数据即可；应用做异步写操作时立即返回，内核会进行写操作排队并执行写操作

关键概念

概念：Reactor模型是基于事件驱动的线程模型，可以分为Reactor单线程模型、Reactor多线程模型、主从Reactor多线程模型，通常基于在I/O多路复用实现

关键词

原理

存储在浏览器端

以明文的方式存储，存在很大风险，可能被篡改

有：有效期

浏览器禁用Cookie，则Cookie不能使用

支持跨域名

存储在服务器端

并发访问的用户非常多，会产生很多的 Session，消耗大量的内存

有效期

不支持跨域

无状态

支持跨域

需要验证Token，查库或查缓存验证

无法携带用户信息，需要进行二次查询才可以

无状态

支持跨域

支持自动校验解码，不需要查库或缓存校验

支持携带用户信息，进行加密返回

JWT(JSON Web Token) 是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息

无状态

支持跨域

支持自动校验解码

支持携带数据，暂无限制，尽可能不要超过HTTP请求携带的8K大小

JWT由三部分组成，它们之间用圆点(.)连接。

头部：Header

数据载体：Payload

签证信息：Signature

https://auth0.com/blog/refresh-tokens-what-are-they-and-when-to-use-them/

doc = Jsoup.parse(html);

doc = Jsoup.parseBodyFragment(html);

 doc = Jsoup.connect("http://example.com/").get();

doc = Jsoup.parse(input, "UTF-8", "http://example.com/");

方法：method

选择器：Selector（规则）

转换符

补充

pom引入

默认占位符符号 "${" 开头，“}”结尾

使用方式

1、打开 tomcat/bin/startup.bat

2、找到最后一行：  call "%EXECUTABLE%" start %CMD_LINE_ARGS%

3、更改  start  为  run 

4、将错误信息打印到当前cmd命令窗口，退出任务为tomcat任务，保留错误日志

1、打开  tomcat/bin/catailina.bat

2、找到   ：if "%TITLE%" == "" set TITLE=Tomcat

3、将tomcat 名称更改为你需要的名称即可

1、打开  tomcat/conf/logging.properties

2、找到显示控制台日志编码位置进行更改  ： java.util.logging.ConsoleHandler.encoding = UTF-8

3、将 UTF-8 或 其他编码更改为 GBK 或其他编码进行尝试，直到命令窗口乱码正常

pom包

核心类、接口解释

应用示例

重写切换路由器抽象类：AbstractRoutingDataSource

存储线程安全的数据源关系

如何切换数据源

切换数据源采用AOP技术进行动态切换

IOC（Inverse of Control）：控制反转

DI（Dependency Injection）：依赖注入

IOC容器

AOP（Aspect Oriented Programming）：面向切面编程

ClassPathXmlApplicationContext：它是从类的根路径下加载配置文件

FileSystemXmlApplicationContext：它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置

AnnotationConfigApplicationContext：当我们使用注解配置容器对象时，需要使用此类来创建Spring容器。它用来读取注解

java

web

概念

请求方式

统一处理异常

配置验证模式

手动验证

自定义验证注解

@Validated

@Valid

优秀文章

验证创建Bean进入容器是否合法：BeanValidationPostProcessor

官方文档

底层实现接口

基于声明性注解的缓存

开启缓存：@EnableCaching

子主题

讲解文章

将请求提交的数据化转换为方法的对象，经过解析器处理处理转化

实例1：创建实例过程示例

实例2：

数据源：未配置数据源启动服务报错

数字类型精度丢失

状态码错误

获取所有URL地址列表

命令窗口：bat

后台命令运行：java -jar xxx.jar

默认静态资源位置

未找到处理资源

是否启用静态资源映射

当前项目目录下的一个/config子目录：file:/config/

当前项目目录：file:/

项目的resources即一个classpath下的/config包：classpath:/config/

项目的resources即classpath根路径（root）：classpath:/

如果在不同的目录中存在多个配置文件，它的读取顺序是：
1、config/application.properties（项目根目录中config目录下）
2、config/application.yml
3、application.properties（项目根目录下）
4、application.yml
5、resources/config/application.properties（项目resources目录中config目录下）
6、resources/config/application.yml
7、resources/application.properties（项目的resources目录下）
8、resources/application.yml
总结：
存在相同的配置内容，高优先级的内容会覆盖低优先级的内容
存在不同的内容的时候，高优先级和低优先级的配置内容取并集

bootstrap.yml (.properties)  >  application.yml (.properties)  >  application-dev(prod).yml(.properties)

描述文章地址：https://reflectoring.io/spring-boot-exception-handling/

注解使用

mapper

service

controller

关系结构图

mybatis3+springboot

Plus

pom

参数配置[application.properties]

流控异常处理：BlockExceptionHandler

流控规则

熔断规则

热点规则

系统规则\授权规则【待完善处理】

持久化限流规则（nacos\redis\db）

子主题

源码下载

构建项目

启动注册中心

导入POM依赖

配置注册中心地址

开启服务注册注解

导入POM依赖

设置项目启动配置内容

开启项目配置注解

Netty基于NIO技术，可读可写时通知应用

Reactor特点

路由（Router）

谓词（Predicate）: 匹配请求中任何内容的参数是否满足请求规则

过滤器（Filter）：将路由之前或之后进行修改制定数据

自定义

默认（11个）

自定义过滤器：

默认(31个)

版本管理

导入jar

解压文件：tar -zxvf redis-6.2.6.tar.gz

进入目录： cd  redis-6.2.6

编译源代码： make
编译完成后，默认在解压目录

运行：./src/redis-server ./redis.conf

编译完成的文件可以集中存放，方便启动
cp redis-benchmark  redis-check-aof  redis-check-rdb  redis-cli  redis.conf  redis-sentinel  redis-server  redis-trib.rb  sentinel.conf  /目录/bin
直接就可以启动
redis-server redis.conf

后台运行：daemonize  (默认为no,修改为yes) 

导入配置文件：include 文件名
相同配置会存在覆盖的情况，请注意

日志文件：logfile  /目录/文件名

持久化数据

主从复制

900秒内1个key被修改就进行快照保存：save 900 1

https://www.runoob.com/java/java-inheritance.html

继承

封装

多态

ArrayList

linkList

接口运行编写默认方法

面向函数式编程的Lamdb表达式

函数式的接口

新接口

时间类

接口

抽象类

数组 、 链表

1、根据key 计算hash值，通过hash取模（(n - 1) & hash）计算出数组下标值进行存储
2、存储数据超过默认初始大小，默认扩展当前大小的2倍
3、hash值相同，存储数据会变成链表形式存储，最新数据存储在头部

JDK1.7:相同的hash值已链表形式存储
JDK1.8：相同的hash值已链表形式存储，链表超过8个会采用红黑树形式存储

红黑树
      红黑树的平均查找长度是log(n)，如果长度为8，平均查找长度为log(8)=3，链表的平均查找长度为n/2，当长度为8时，平均查找长度为8/2=4，这才有转换成树的必要；链表长度如果是小于等于6，6/2=3，而log(6)=2.6，虽然速度也很快的，但是转化为树结构和生成树的时间并不会太短。

1、HashMap线程不安全，多线程下扩容死循环
2、线程安全采用HashTable、Collections.synchronizedMap、以及 ConcurrentHashMap 可以实现线程安全
     2.1 HashTable 是在每个方法加上 synchronized 关键字，粒度比较大
     2.2 Collections.synchronizedMap 是使用 Collections 集合工具的内部类，通过传入 Map 封装出一个 SynchronizedMap 对象，内部定义了一个对象锁，方法内通过对象锁实现
     2.3 ConcurrentHashMap 在jdk1.7中使用分段锁，在jdk1.8中使用CAS+synchronized

hashcode

equeal

http

https

浅拷贝：
1、复制对象的引用，指向同一块空间
2、原始对象值发生改变，新拷贝的对象值也发生改变

深拷贝：
1、完整的复制对象的内容，新开辟一块内存地址空间进行存储，引用不同
2、原始对象值发生改变，新拷贝对象不发生改变
3、Cloneable 接口并且实现 clone 方法

mmap:
1、mmap 通过内存映射，将文件映射到内核缓冲区，减少内核空间到用户空间的拷贝次数
2、内存拷贝(从 4 次变成了 3 次)，适合 小数据 传输
3、java NIO MappedByteBuffer 实现

sendFile：
1、内核缓冲区进入到 Socket Buffer，同时，由于和用户态完全无关，就减少了一次上下文切换
2、sendFile 可以利用 DMA 方式，减少 CPU 拷贝，mmap 则不能（必须从内核拷贝到 Socket 缓冲区）

使用场景

基本类型的时候，用的是值传递

参数类型是对象、数组 、集合 是拷贝引用的值，所以能修改引用数据指向同一个对象

持久化：就是把内存的数据写到磁盘中去，防止服务宕机了内存数据丢失

持久化机制 ：RDB（默认：快照） 和 AOF（写模式、日志模式） :

过期策略

Redis中同时使用了  惰性过期  和   定期过期  两种过期策略

内存淘汰策略

FIFO 淘汰最早数据、LRU 剔除最近最少使用、和 LFU 剔除最近使用频率最低

redis内存数据集大小上升到一定大小的时候，就会施行数据淘汰策略。

String、List、Set、Sorted Set、hashes

主从

哨兵

总结：
1、Redis 4.0 之前 的执行原理，通过IO多路复用器监听来自客户端的socket网络连接，然后由主线程进行IO请求的处理以及命令的处理，所有操作都是线性的（单线程）
2、Redis 4.0版本引入了Lazy Free（耗时数据异步处理），目的是将慢操作异步化，Lazy Free:异步删除耗时大的任务，达到主线程不会阻塞的效果
3、Redis 6.0版本 多线程模型只用来处理网络IO读写请求，对于 Redis 的读写命令，依然是单线程处理。网络处理经常是瓶颈，通过多线程并行处理可提高性能 （利用多核cpu处理网络请求）
4、Redis6.0 默认禁用多线程，只使用主线程。如需开启需要修改 redis.conf 配置文件：io-threads-do-reads yes，开启多线程后，还需要设置线程数，否则是不生效的（io-threads 4）

事务：
1、基础命令：MULTI、EXEC、DISCARD、WATCH、UNWATCH
2、 Redis的事务无法实现原子性，无法保证数据一致

缓存击穿

缓存穿透

缓存雪崩

网络层

服务层

引擎层

系统（文件）层

原子性（整体）：要么成功、要么失败，不允许有中间状态

一致性（数据）：事务开始前和结束后，数据库的完整性约束没有被破坏

隔离性（并发提交）：隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离

持久性（数据与故障）：持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作

你了解事务的几大特性

脏读：回滚的数据被读到
事务A读取了事务B更新的数据，然后B回滚操作，那么A读取到的数据是脏数据

不可重复读：事务提交之前与之后读取的数据不一致
事务 A 多次读取同一数据，事务 B 在事务A多次读取的过程中，对数据作了更新并提交，导致事务A多次读取同一数据时，结果因此本事务先后两次读到的数据结果会不一致。

幻读：其它事务插入破坏了当前事务读取数据（2）
1、幻读解决了不重复读，保证了同一个事务里，查询的结果都是事务开始时的状态（一致性）
2、A事务读取了一个范围的内容,而同时B事务在此期间插入了一条数据

char(n) : 定长存储，存储内容不足自动补充空格，最大长度255

varchar(n) : 变长存储，存储内容<n 时，不会补充空格，只存储实际内容，最大长度16383

InnoDB(默认的存储引擎)

MyISAM

有几种锁机制

悲观锁、乐观锁 区别

delete和truncate只删除表的数据不删除表的结构

delete语句是dml,这个操作会放到rollback segement中,事务提交之后才生效，如果有相应的trigger,执行的时候将被触发

truncate,drop是ddl, 操作立即生效,原数据不放到rollback segment中,不能回滚. 操作不触发trigger.

表结构字典尽量不要设置null值，应该设置空字符串或0

表关联不要超过3张表，关联查询应该遵循小表驱动大表

索引失效

多用 explain 执行SQL检查是否落到索引上

优秀SQL优化

索引是一种数据结构,可以帮助我们快速的进行数据的查找

使用联合索引时，注意索引列的顺序，一般遵循最左匹配原则

索引的数据结构和具体存储引擎的实现有关, 在MySQL中使用较多的索引有Hash索引,B+树索引等,而我们经常使用的InnoDB存储引擎的默认索引实现为:B+树索引

显示执行计划详细信息：SHOW WARNINGS

输出格式

接口层

数据处理层

基础层

子主题

子主题

子主题

子主题

子主题

简单易学：

灵活

解耦

支持对象与数据库的orm字段关系映射

提供xml标签，支持编写动态sql

子主题

ORM （HIbernate）

ORM（半自动化->mybatis）

Interceptor

PageHelper 也是采用interceptor方式实现

#{} 是预编译处理，像传进来的数据会加个" "（#将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号）

${}  就是字符串替换。直接替换掉占位符

为了防止 SQL 注入，能用 #{} 的不要去用 ${}

不同mapper映射文件ID是可以重复的，因为Namespace不同

Namespace没有设置，则不能相同，因为Mybatis 解析方式使用Namespace + ID 的形式映射每一个statementMapper

同一个Mapper接口不能重载，因为是全名（Namespace）+方法名进行寻找策略对应MappedStatement

Mapper代理JDK动态代理
Mybatis运行时会使用JDK动态代理为Dao接口生成代理proxy对象，代理对象proxy会拦截接口方法

支持枚举类型，需要根据自己实现TypeHandler类型器处理

方法：

作用是javaType和jdbcType相互转换

缓存机制减轻数据库压力，提高数据库性能

一级缓存（sqlSession）

二级缓存（Mapper）