Java核心

多态分为编译时多态和运行时多态:
编译时多态主要指方法的重载
运行时多态指程序中定义的对象引用所指向的具体类型在运行期间才确定

它的定义是：就一个类而言，应该仅有一个引起它变化的原因。

一个类中是一组相关性和高的函数，一个类尽量只实现一个功能。

它的定义是：程序中的对象应该对应扩展是开放的，对于修改是封闭的。

它的定义是：所有引用基类的地方必须能透明的使用其子类对象。

高级模块不应依赖于低级模块，两者都应依赖于抽象。抽象不应依赖于细节。细节应依赖于抽象。

理解为： 面向接口编程，或者说面向抽象编程。程序要依赖于抽象接口，不要依赖于具体实现。

它的定义是：客户端不应该依赖它不需要的接口。一个类对另一个类的依赖应该建立在最小的接口上。

它的定义是：一个对象应该对其他对象有最少的了解

HashSet

SortedSet接口

ArrayList

LinkedList

Vector

LinkedList：可以用它来实现双向队列

PriorityQueue：基于堆结构实现，可以用它来实现优先队列

Collections.synchronizedList(list);

asList的缺陷

泛型类，泛型接口

泛型方法

泛型变量

泛型擦除

https://www.jianshu.com/p/986f732ed2f1

https://cloud.tencent.com/developer/article/1033693

扩容

删除元素

添加元素

Fail-Fast

序列化

ArrayList是线程不安全的解决方案

适用场景
CopyOnWriteArrayList 在写操作的同时允许读操作，大大提高了读操作的性能，因此很适合读多写少的应用场景。
但是 CopyOnWriteArrayList 有其缺陷：
内存占用：在写操作时需要复制一个新的数组，使得内存占用为原来的两倍左右；
数据不一致：读操作不能读取实时性的数据，因为部分写操作的数据还未同步到读数组中。
所以 CopyOnWriteArrayList 不适合内存敏感以及对实时性要求很高的场景。

基于1.7

基于1.8

扩展

存储结构

size 操作

JDK 1.8 的改动

基于1.7

新增方法

查询方法

add

数值型

字符型（char）

布尔型（boolean）

类

接口

数组

String 被声明为 final，因此它不可被继承。
在 Java 8 中，String 内部使用 char 数组存储数据。

String Pool

new String("abc")

   String s1 = "1";
   String s2 = "1";
   System.out.println(s1.intern()== s2.intern());// true

基本类型都有对应的包装类型，基本类型与其对应的包装类型之间的赋值使用自动装箱与拆箱完成。

总结

工具类

BigDecimal格式化

BigDecimal大小比较

Java 的参数是以值传递的形式传入方法中，而不是引用传递。

方法参数传递是基本类型复制一个份值传入。也就是在方法中修改了变量也没有影响方法外的变量。

1. 重写（Override）
存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。

2. 重载（Overload）
存在于同一个类中，指一个方法与已经存在的方法名称上相同，但是参数类型、个数、顺序至少有一个不同。
应该注意的是，返回值不同，其它都相同不算是重载。

检查是否为同一个对象的引用，如果是直接返回 true；
检查是否是同一个类型，如果不是，直接返回 false；
将 Object 对象进行转型；
判断每个关键域是否相等。

理想的散列函数应当具有均匀性，即不相等的对象应当均匀分布到所有可能的散列值上。这就要求了散列函数要把所
有域的值都考虑进来。可以将每个域都当成 R 进制的某一位，然后组成一个 R 进制的整数。R 一般取 31，因为它是
一个奇素数，如果是偶数的话，当出现乘法溢出，信息就会丢失，因为与 2 相乘相当于向左移一位。
一个数与 31 相乘可以转换成移位和减法： 31*x == (x<<5)-x ，编译器会自动进行这个优化。

默认返回 ToStringExample@4554617c 这种形式

1. cloneable
clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类
实例的 clone() 方法。

2. 浅拷贝
拷贝对象和原始对象的引用类型引用同一个对象。

3. 深拷贝
拷贝对象和原始对象的引用类型引用不同对象。

4. clone() 的替代方案
使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，
最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。

1. 数据
声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能被改变的常量。
对于基本类型，final 使数值不变；
对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的。

2. 方法
声明方法不能被子类重写。
private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方
法不是重写基类方法，而是在子类中定义了一个新的方法。

3. 类
声明类不允许被继承

1. 静态变量
静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来
访问它。静态变量在内存中只存在一份。
实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。

2. 静态方法
静态方法在类加载的时候就存在了，它不依赖于任何实例。所以静态方法必须有实现，也就是说它不能是抽象方法。

3. 静态语句块
静态语句块在类初始化时运行一次。

4. 静态内部类
非静态内部类依赖于外部类的实例，而静态内部类不需要。

5. 静态导包
在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大降低。

6. 初始化顺序
静态变量和静态语句块优先于实例变量和普通语句块，静态变量和静态语句块的初始化顺序取决于它们在代码中的顺
序

T->boolean

()->T

T->void

T ->R

T->T

(T,T)->T

(T,U)->R

(T,U)->void

(L,R)->boolean

流和集合

流操作

数值流

构建流

归约和汇总

分组

分区

包括以下 7 个阶段：
加载（Loading）
验证（Verification）
准备（Preparation）
解析（Resolution）
初始化（Initialization）
使用（Using）
卸载（Unloading）

1. 加载

2. 验证
确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。

3. 准备
类变量是被 static 修饰的变量，准备阶段为类变量分配内存并设置初始值，使用的是方法区的内存

4. 解析
将常量池的符号引用替换为直接引用的过程。
其中解析过程在某些情况下可以在初始化阶段之后再开始，这是为了支持 Java 的动态绑定。

5. 初始化
初始化阶段才真正开始执行类中定义的 Java 程序代码。初始化阶段是虚拟机执行类构造器 () 方法的过程。在
准备阶段，类变量已经赋过一次系统要求的初始值，而在初始化阶段，根据程序员通过程序制定的主观计划去初始化
类变量和其它资源。

1. 主动引用

2. 被动引用

两个类相等，需要类本身相等，并且使用同一个类加载器进行加载。这是因为每一个类加载器都拥有一个独立的类名
称空间。
这里的相等，包括类的 Class 对象的 equals() 方法、isAssignableFrom() 方法、isInstance() 方法的返回结果为
true，也包括使用 instanceof 关键字做对象所属关系判定结果为 true。

类加载器的引用

图示

1. 工作过程
一个类加载器首先将类加载请求转发到父类加载器，只有当父类加载器无法完成时才尝试自己加载。

2. 好处
使得 Java 类随着它的类加载器一起具有一种带有优先级的层次关系，从而使得基础类得到统一

3. 实现

双亲委派模型的"破坏"

沙箱安全机制

什么情况下需要开始类加载过程的第一个阶段加载

i++操作的字节码指令

类加载机制-双亲委派，破坏双亲委派

图示

（图源阿里）JDK8的元数据区+JIT编译产物 就是JDK8以前的方法区

 堆、栈、方法区的交互关系

一般来说，jvm优化95%是优化堆区，5%优化的是方法区，至于栈区无非出入栈操作优化较少

线程角度看运行时数据区

JVM系统线程分类

程序计数器是一块内存区域，用来记录线程当前要执行的指令地址。那么为何要将程序计数器设计为线程私有的呢？前面说了线程是占用CPU执行的基本单位，而CPU一般是使用时间片轮转方式让线程轮询占用的，所以当前线程CPU时间片用完后，要让出CPU，等下次轮到自己的时候再执行。那么如何知道之前程序执行到哪里了呢？其实程序计数器就是为了记录该线程让出CPU时的执行地址的，待再次分配到时间片时线程就可以从自己私有的计数器指定地址继续执行。另外需要注意的是，如果执行的是native方法，那么pc计数器记录的是undefined地址，只有执行的是Java代码时pc计数器记录的才是下一条指令的地址。

PC寄存器面试常问

程序计数寄存器作用

图示

栈帧

栈操作

栈是运行时的单位，而堆是存储的单位

Java虚拟机栈的存储结构和运行原理

虚拟机栈的相关面试题

静态变量与局部变量的对比及小结

在栈帧中，与性能调优关系最为密切的部分就是局部变量表。在方法执行时，虚拟机使用局部变量表完成方法的传递
局部变量表中的变量也是重要的垃圾回收根节点，只要被局部变量表中直接或间接引用的对象都不会被回收

概述

配置及查看

堆的细分内存结构

设置堆内存大小与OOM

年轻代与老年代

图解对象分配的一般过程

Minor GC、Major GC、Full GC

常用调优工具

堆空间分代思想

内存分配策略总结

新概念：TLAB（堆当中的线程私有缓存区域）

堆空间的参数设置

JVM--堆是分配对象的唯一选择么?

可利用参数 -XX:PermSize -XX:MaxPermSize 控制初始化方法区和最大方法区大小。

元数据区(JDK1.8)

方法区的理解

设置方法区大小的参数

解决报错OOM：（内存泄漏、内存溢出）

方法区的内部结构

常量池

方法区的垃圾回收

Class对象是存放在堆区的，不是方法区，这点很多人容易犯错。

为什么需要常量池呢？
常量池的作用，就是为了提供一些符号和常量，便于指令的识别。

永久代为什么要被元空间替换

实例代码

直接内存来源于NIO

直接内存异常OOM

直接内存参数设置

图示

创建对象的方式

创建对象的步骤

对象的内存布局

对象的访问定位

图示

HotSpot VM 可以设置程序执行方式

基于目前JVM执行引擎当中解释器与即时编译器共存

解释器（interpreter）

JIT （Just In Time Compiler）：即时编译器

图示

概念

方法调用计数器

热度衰减（现实当中的残酷概念，好理解，但不好受）

回边计数器

HotSpot VM 中的JIT分类

Graal编译器

AOT编译器

子主题

Boolean类型

KV设值类型

jinfo举例，如何查看当前运行程序的配置

两个经典参数：-Xms和-Xmx

-XX:+PrintFlagsInitial

-XX:+PrintFlagsFinal

-XX:+PrintCommandLineFlags

基础

常用参数

解释

新生代和老年代配置比率

为什么需要GC

1. 引用计数算法

2. 可达性分析算法

3. 方法区的回收

4. finalize()

使用(MAT与JProfiler)工具分析GCRoots

1. 强引用

2. 软引用

3. 弱引用

4. 虚引用

GCRoots和四大引用的小总结

终结器引用

引用计数

1. 标记 - 清除

2. 标记 - 整理

3. 复制

4. 分代收集

5. 增量收集算法

相关概念

收集器配合

新生代

老年代

垃圾回收器小结

G1 收集器（区域化分代式）

7种经典的垃圾回收器总结

使用

G1和CMS的比较

概念

停顿的原因

例子

内存溢出

内存泄漏(Memory Leak)

程序的并行和并发

图示

子主题

GC安全点(Safepoint)

安全区域(Safe Region)

+PrintGC

PrintGCDetails

PrintGCTimeStamps

日志补充说明

日志分析工具

Java.lang.StackOverflowError

Java.lang.OutOfMemoryError:Java heap space

Java.lang.OutOfMemeoryError:GC overhead limit exceeded

Java.lang.OutOfMemeoryError:Direct buffer memory

Java.lang.OutOfMemeoryError:unable to create new native thread

Java.lang.OutOfMemeoryError:Metaspace

1. 对象优先在 Eden 分配
大多数情况下，对象在新生代 Eden 上分配，当 Eden 空间不够时，发起 Minor GC。

2. 大对象直接进入老年代
大对象是指需要连续内存空间的对象，最典型的大对象是那种很长的字符串以及数组。
经常出现大对象会提前触发垃圾收集以获取足够的连续空间分配给大对象。

3. 长期存活的对象进入老年代
为对象定义年龄计数器，对象在 Eden 出生并经过 Minor GC 依然存活，将移动到 Survivor 中，年龄就增加 1 岁，
增加到一定年龄则移动到老年代中。

4. 动态对象年龄判定

5. 空间分配担保

图示

1. 调用 System.gc()
只是建议虚拟机执行 Full GC，但是虚拟机不一定真正去执行。不建议使用这种方式，而是让虚拟机管理内存。

2. 老年代空间不足

3. 空间分配担保失败

4. JDK 1.7 及以前的永久代空间不足

5. Concurrent Mode Failure

图示

1. Java 堆空间

2. GC 开销超过限制

3. 请求的数组大小超过虚拟机限制

4. Perm gen 空间

5. Metaspace

6. 无法新建本机线程

7. 杀死进程或子进程

8. 发生 stack_trace_with_native_method

显示的调用toString()方法在字符串常量池当中生成调用者对应的字符串,并且返回常量池当中的地址

测试代码

常量拼接：编译期优化

变量拼接:StringBuilder原理

final常量拼接

拼接操作与append的效率对比

总结String的intern（）的使用

关于String.intern()的面试题

intern练习题1

intern练习题2

intern练习题3

intern()效率测试

G1中的String去重操作

去重实现步骤

命令行选项

编码就是把字符转换为字节，而解码是把字节重新组合成字符。
如果编码和解码过程使用不同的编码方式那么就出现了乱码。
GBK 编码中，中文字符占 2 个字节，英文字符占 1 个字节；
UTF-8 编码中，中文字符占 3 个字节，英文字符占 1 个字节；
UTF-16be 编码中，中文字符和英文字符都占 2 个字节。
UTF-16be 中的 be 指的是 Big Endian，也就是大端。相应地也有 UTF-16le，le 指的是 Little Endian，也就是小端。
Java 的内存编码使用双字节编码 UTF-16be，这不是指 Java 只支持这一种编码方式，而是说 char 这种类型使用
UTF-16be 进行编码。char 类型占 16 位，也就是两个字节，Java 使用这种双字节编码是为了让一个中文或者一个英
文都能使用一个 char 来存储。

不管是磁盘还是网络传输，最小的存储单元都是字节，而不是字符。但是在程序中操作的通常是字符形式的数据，因
此需要提供对字符进行操作的方法。
InputStreamReader 实现从字节流解码成字符流；
OutputStreamWriter 实现字符流编码成为字节流。

实现逐行输出文本文件的内容

序列化就是将一个对象转换成字节序列，方便存储和传输。
序列化：ObjectOutputStream.writeObject()
反序列化：ObjectInputStream.readObject()
不会对静态变量进行序列化，因为序列化只是保存对象的状态，静态变量属于类的状态。

序列化的类需要实现 Serializable 接口，它只是一个标准，没有任何方法需要实现，但是如果不去实现它的话而进行
序列化，会抛出异常。

序列化 ID

transient 关键字可以使一些属性不会被序列化。

可以直接从 URL 中读取字节流数据。

ServerSocket：服务器端类
Socket：客户端类
服务器和客户端通过 InputStream 和 OutputStream 进行输入输出。

DatagramSocket：通信类
DatagramPacket：数据包类

1. 通道

2. 缓冲区

多路复用

capacity：最大容量；
position：当前已经读写的字节数；
limit：还可以读写的字节数。

NIO 常常被叫做非阻塞 IO，主要是因为 NIO 在网络通信中的非阻塞特性被广泛使用。

NIO 实现了 IO 多路复用中的 Reactor 模型，一个线程 Thread 使用一个选择器 Selector 通过轮询的方式去监听多个
通道 Channel 上的事件，从而让一个线程就可以处理多个事件。

1. 创建选择器
Selector selector = Selector.open();

2. 将通道注册到选择器上
ServerSocketChannel ssChannel = ServerSocketChannel.open();
ssChannel.configureBlocking(false);
ssChannel.register(selector, SelectionKey.OP_ACCEPT);

3. 监听事件
int num = selector.select();
使用 select() 来监听到达的事件，它会一直阻塞直到有至少一个事件到达。

4. 获取到达的事件

5. 事件循环
因为一次 select() 调用不能处理完所有的事件，并且服务器端有可能需要一直监听事件，因此服务器端处理事件的代
码一般会放在一个死循环内。

服务端

客户端

内存映射文件 I/O 是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的 I/O 快得多。
向内存映射文件写入可能是危险的，只是改变数组的单个元素这样的简单操作，就可能会直接修改磁盘上的文件。修
改数据与将数据保存到磁盘是没有分开的。
下面代码行将文件的前 1024 个字节映射到内存中，map() 方法返回一个 MappedByteBuffer，它是 ByteBuffer 的
子类。因此，可以像使用其他任何 ByteBuffer 一样使用新映射的缓冲区，操作系统会在需要时负责执行映射。
MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, 1024);

所以在切换线程上下文时需要保存当前线程的执行现场，当再次执行时根据保存的执行现场信息恢复执行现场。线程上下文切换时机有：当前线程的CPU时间片使用完处于就绪状态时，当前线程被其他线程中断时。

在该线程被 CPU 剥夺时间片后又再次运行恢复上次所保存的信息的过程就称为上下文切换。

解决方案:

进程是资源分配的基本单位。
进程控制块 (Process Control Block, PCB) 描述进程的基本信息和运行状态，所谓的创建进程和撤销进程，都是指对
PCB 的操作。

线程是独立调度的基本单位。
一个进程中可以有多个线程，它们共享进程资源。

区别

并发是指宏观上在一段时间内能同时运行多个程序，而并行则指同一时刻能运行多个指令。
并行需要硬件支持，如多流水线、多核处理器或者分布式计算系统。
操作系统通过引入进程和线程，使得程序能够并发运行。

Erlang 之父 Joe Armstrong 用一张5岁小孩都能看懂的图解释了并发与并行的区别

程序的并行和并发

Java Thread 类内部 state枚举  状态解析

可运行状态（就绪状态）

进入方法 退出方法
没有设置 Timeout 参数的 Object.wait() 方法 Object.notify() / Object.notifyAll()
没有设置 Timeout 参数的 Thread.join() 方法 被调用的线程执行完毕
LockSupport.park() 方法 LockSupport.unpark(Thread)

那么守护线程和用户线程有什么区别呢？区别之一是当最后一个非守护线程结束时，JVM会正常退出，而不管当前是否有守护线程，也就是说守护线程是否结束并不影响JVM的退出。言外之意，只要有一个用户线程还没结束，正常情况下JVM就不会退出。

如果在睡眠期间其他线程调用了该线程的interrupt（）方法中断了该线程，则该线程会在调用sleep方法的地方抛出InterruptedException异常而返回。

调用yield方法时，线程只是让出自己剩余的时间片，并没有被阻塞挂起，而是处于就绪状态，线程调度器下一次调度时就有可能调度到当前线程执行。

等待线程执行终止的join方法，当线程A调用Join方法会等待线程A执行完毕。

如何指定多个线程的执行顺序（join 方法）

该检测当前线程是否被中断，如果是返回true，否则返回false。与isInterrupted不同的是，该方法如果发现当前线程被中断，则会清除中断标志。但是不影响方法中的while(!Thread.currentThread().interrupted()) 的判断。即当线程被中断返回true，并中断标志清除为false 。

isInterrupted检测当前线程是否被中断,不清除中断标志

图示

图示

该关键字可以确保对一个变量的更新对其他线程马上可见。当一个变量被声明为volatile时，线程在写入变量时不会把值缓存在寄存器或者其他地方，而是会把值刷新回主内存。当其他线程读取该共享变量时，会从主内存重新获取最新值，而不是使用当前线程的工作内存中的值。

首先需要了解的是，Java中只有对基本类型变量的赋值和读取是原子操作，如i = 1的赋值操作，但是像j = i或者i++这样的操作都不是原子操作，因为他们都进行了多次原子操作，比如先读取i的值，再将i的值赋值给j，两个原子操作加起来就不是原子操作了。
所以，如果一个变量被volatile修饰了，那么肯定可以保证每次读取这个变量值的时候得到的值是最新的，但是一旦需要对变量进行自增这样的非原子操作，就不会保证这个变量的原子性了。

https://blog.csdn.net/xdzhouxin/article/details/81236356

1.volatile是Java虚拟机提供的轻量级的同步机制

volatile 的应用

详细解释了volatile关键字的原理

1. 同步一个代码块

2. 同步一个方法

3. 同步一个类

4. 同步一个静态方法

原理分析

ReentrantLock 实现原理

1. 锁的实现
synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
2. 性能
新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。
3. 等待可中断
当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。
ReentrantLock 可中断，而 synchronized 不行。
4. 公平锁
公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。
synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。
5. 锁绑定多个条件
一个 ReentrantLock 可以同时绑定多个 Condition 对象。

锁优化

乐观锁与悲观锁（数据库中引入的思想）

公平锁与非公平锁

独占锁与共享锁

什么是可重入锁

读写锁

不同进程

wait() 和 sleep() 的区别
wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；
wait() 会释放锁，sleep() 不会。

为什么wait会释放锁，如果调用wait（）方法的线程没有事先获取该对象的监视器锁，则调用wait（）方法时调用线程会抛出IllegalMonitorStateException异常。

对象监视器锁在对象上面，wait是Object对象的方法，而sleep是Thread 的方法。 

wait(long timeout)方法,线程挂起等待指定时间被notify 和notyfyAll 唤醒，超时释放锁。

产生条件

如何避免

死锁定位

Condition的特性

用来控制一个线程等待多个线程。
维护了一个计数器 cnt，每次调用 countDown() 方法会让计数器的值减 1，减到 0 的时候，那些因为调用 await() 方
法而在等待的线程就会被唤醒。

用来控制多个线程互相等待，只有当多个线程都到达时，这些线程才会继续执行。
和 CountdownLatch 相似，都是通过维护计数器来实现的。线程执行 await() 方法之后计数器会减 1，并进行等待，
直到计数器为 0，所有调用 await() 方法而在等待的线程才能继续执行。

CyclicBarrier 和 CountdownLatch 的一个区别是，CyclicBarrier 的计数器通过调用 reset() 方法可以循环使用，所以
它才叫做循环屏障。
CyclicBarrier 有两个构造函数，其中 parties 指示计数器的初始值，barrierAction 在所有线程都到达屏障的时候会
执行一次。

Semaphore 类似于操作系统中的信号量，可以控制对互斥资源的访问线程数。

信号量的主要用两个目的,一个是用于多个共享资源的相互排斥使用,另一个用于并发资源数的控制.

AbstractQueuedSynchronizer维护了一个volatile int类型的变量，用户表示当前同步状态。volatile虽然不能保证操作的原子性，但是保证了当前变量state的可见性。

getState()
setState()
compareAndSetState()
这三种叫做均是原子操作，其中compareAndSetState的实现依赖于Unsafe的compareAndSwapInt()方法。

AQS定义两种资源共享方式：Exclusive（独占，只有一个线程能执行，如ReentrantLock）和Share（共享，多个线程可同时执行，如Semaphore/CountDownLatch）。

同步器的实现是 ABS 核心

核心三板斧，自旋，LockSupport，CAS

手写

BlockingQueue

图示

ArrayBlockingQueue源码实现

实际案例

demo

线程池原理

线程池的组成

优势

Executors框架

生产上使用

SpringBoot 使用线程池

线程池隔离

使用

和Random对比

原理分析

将数据抽象成一个类 ，并将数据的操作作为这个类的方法

Runnable 对象作为 一个类的内部类

当一个线程操作共享变量时，它首先从主内存复制共享变量到自己的工作内存，然后对工作内存里的变量进行处理，处理完后将变量值更新到主内存。

子主题

什么是伪共享

所有的变量都存储在主内存中，每个线程还有自己的工作内存，工作内存存储在高速缓存或者寄存器中，保存了该线
程使用的变量的主内存副本拷贝。
线程只能直接操作工作内存中的变量，不同线程之间的变量值传递需要通过主内存来完成。

Java 内存模型定义了 8 个操作来完成主内存和工作内存的交互操作。

read：把一个变量的值从主内存传输到工作内存中
load：在 read 之后执行，把 read 得到的值放入工作内存的变量副本中
use：把工作内存中一个变量的值传递给执行引擎
assign：把一个从执行引擎接收到的值赋给工作内存的变量
store：把工作内存的一个变量的值传送到主内存中
write：在 store 之后执行，把 store 得到的值放入主内存的变量中
lock：作用于主内存的变量
unlock

图示

1. 原子性

2. 可见性

3. 有序性

1. 单一线程原则
Single Thread rule
在一个线程内，在程序前面的操作先行发生于后面的操作。

2. 管程锁定规则
Monitor Lock Rule
一个 unlock 操作先行发生于后面对同一个锁的 lock 操作。

3. volatile 变量规则
Volatile Variable Rule
对一个 volatile 变量的写操作先行发生于后面对这个变量的读操作。

4. 线程启动规则
Thread Start Rule
Thread 对象的 start() 方法调用先行发生于此线程的每一个动作。

5. 线程加入规则
Thread Join Rule
Thread 对象的结束先行发生于 join() 方法返回。

6. 线程中断规则
Thread Interruption Rule
对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过 interrupted() 方法检
测到是否有中断发生。

7. 对象终结规则
Finalizer Rule
一个对象的初始化完成（构造函数执行结束）先行发生于它的 finalize() 方法的开始。

8. 传递性
Transitivity
如果操作 A 先行发生于操作 B，操作 B 先行发生于操作 C，那么操作 A 先行发生于操作 C。

synchronized 

 ReentrantLock。

CAS

AtomicInteger

1. 栈封闭
多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在虚拟机栈中，属于线程私有
的。

2. 线程本地存储（Thread Local Storage）

3. 可重入代码（Reentrant Code）

Java用static 修饰的变量的是方法区是线程共享资源。

如果多个线程都只是读取共享资源，而不去修改，那么就不会存在线程安全问题，只有当至少一个线程修改共享资源时才会存在线程安全问题

静态变量：线程非安全。静态变量即类变量，位于方法区，为所有对象共享，共享一份内存，一旦静态变量被修改，其他对象均对修改可见，故线程非安全。
实例变量：单例模式（只有一个对象实例存在）线程非安全，非单例线程安全。实例变量为对象实例私有，在虚拟机的堆中分配，若在系统中只存在一个此对象的实例，在多线程环境下，“犹如”静态变量那样，被某个线程修改后，其他线程对修改均可见，故线程非安全；如果每个线程执行都是在不同的对象中，那对象与对象之间的实例变量的修改将互不影响，故线程安全。
局部变量：线程安全。每个线程执行时将会把局部变量放在各自栈帧的工作内存中，线程间不共享，故不存在线程安全问题。

https://www.cnblogs.com/tiko/p/12369003.html

https://juejin.im/post/6876773156560994311#heading-1

类和接口

JavaBean内省机制

作用

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它 们具体的类。

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

用 原 型 实 例 指 定 创 建 对 象 的 种 类 ， 并 且 通 过 拷 贝 这 个 原 型 来 创 建 新 的 对 象。

将 一 个 复 杂 对 象 的 构 建 与 它 的 表 示 分 离 ， 使 得 同 样 的 构 建 过 程 可 以 创 建 不 同的表示。

定义一个用于创建对象的接口，让子类决定将哪一个类实例化。 Factory Method使一个类的实例化延迟到其子类。

为其他对象提供一个代理以控制对这个对象的访问。

将一个类的接口转换成客户希望的另外一个接口。 Adapter 模式使得原本 由于接口不兼容而不能一起工作的那些类可以一起工作。

将抽象部分与它的实现部分分离，使它们都可以独立地变化。

动态地给一个对象添加一些额外的职责。就扩展功能而言， D e c o r a t o r 模 式比生成子类方式更为灵活。

为子系统中的一组接口提供一个一致的界面， F a c a d e 模式定义了一个高层 接口，这个接口使得这一子系统更加容易使用。

将 对 象 组 合 成 树 形 结 构 以 表 示 “ 部 分 -整 体 ” 的 层 次 结 构 。 Composite 使 得客户对单个对象和复合对象的使用具有一致性。

运用共享技术有效地支持大量细粒度的对象。

定 义 一 系 列 的 算 法 , 把 它 们 一 个 个 封 装 起 来 , 并 且 使 它 们 可 相 互 替 换 。 本 模
式使得算法的变化可独立于使用它的客户。

定义对象间的一种一对多的依赖关系 , 以便当一个对象的状态发生改变时 , 所有依赖于它的对象都得到通知并自动刷新。

为 解 除 请 求 的 发 送 者 和 接 收 者 之 间 耦 合 ， 而 使 多 个 对 象 都 有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象 处理它。

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

允 许 一 个 对 象 在 其 内 部 状 态 改 变 时 改 变 它 的 行 为 。 对 象 看 起 来 似 乎 修 改 了 它
所属的类。

在 不 破 坏 封 装 性 的 前 提 下 ， 捕 获 一 个 对 象 的 内 部 状 态 ， 并 在 该 对 象 之 外 保存这个状态。这样以后就可将该对象恢复到保存的状态。

将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数 化;对请求排队或记录请求日志，以及支持可取消的操作

提供一种方法顺序访问一个聚合对象中各个元素 , 而 又 不 需 暴 露 该 对 象 的 内部表示。

表 示 一 个 作 用 于 某 对 象 结 构 中 的 各 元 素 的 操 作 。 它 使 你 可 以 在 不 改 变 各 元
素的类的前提下定义作用于这些元素的新操作。

给定一个语言 , 定义它的文法的一种表示，并定义一个解释器 , 该解释 器使用该表示来解释语言中的句子。

用 一 个 中 介 对 象 来 封 装 一 系 列 的 对 象 交 互 。 中 介 者 使 各 对 象 不 需 要 显 式 地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。