JAVA知识点归纳，你想要的这里都有！

1. J2SE基础

1. 九种基本数据类型的大小，以及他们的封装类。

https://blog.csdn.net/rabbit_in_android/article/details/49793813

2. Switch能否用string做参数？

https://www.cnblogs.com/lchzls/p/6711222.html

3. equals与==的区别。

https://www.cnblogs.com/whcwkw1314/p/8044947.html

4. Object有哪些公用方法？

https://blog.csdn.net/donghaol/article/details/49252383

5. Java的四种引用，强弱软虚，用到的场景。

https://www.cnblogs.com/remember-forget/p/5971963.html

6. Hashcode的作用。

https://www.cnblogs.com/yibutian/p/9619696.html

7. hashmap

https://blog.csdn.net/weixin_43629719/article/details/100005643

https://blog.csdn.net/weixin_43629719/article/details/100024493

8. String、StringBuffer与StringBuilder的区别。

String
在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。需要注意的是，String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，这样不仅效率低下，而且大量浪费有限的内存空间。
StringBuffer & StringBuilder
StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

区别
（1）字符修改上的区别（主要）
String：不可变字符串
StringBuffer：可变字符串、效率低、线程安全
StringBuilder：可变字符序列、效率高、线程不安全
（2）初始化上的区别，String可以空赋值，后者不行，报错
总结
（1）如果要操作少量的数据用 String；
（2）多线程操作字符串缓冲区下操作大量数据 StringBuffer；
（3）单线程操作字符串缓冲区下操作大量数据 StringBuilder（推荐使用）。

https://baijiahao.baidu.com/s?id=1629804867201303563&wfr=spider&for=pc

9. try catch finally，try里有return，finally还执行么？

https://blog.csdn.net/tianhouquan/article/details/82467646

10. Excption与Error包结构。OOM你遇到过哪些情况，SOF你遇到过哪些情况。

https://blog.csdn.net/samjustin1/article/details/52400734

11. Java面向对象的三个特征与含义。

https://www.jianshu.com/p/32a71726db21

12. Override和Overload的含义去区别。

https://blog.csdn.net/u011860731/article/details/48730617

13. Interface与abstract类的区别。

https://blog.csdn.net/lmlcode/article/details/83273167

14. Static class 与non static class的区别。

1 用途
“static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。” 方便在没有创建对象的情况下来进行调用（方法/变量）。
① Static方法
static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。但是要注意的是，虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。
② Static变量
static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。static成员变量的初始化顺序按照定义的顺序进行初始化。
③ Static代码块
static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次。
2 误区
① static关键字会改变类中成员的访问权限吗？
Java中的static关键字不会影响到变量或者方法的作用域。
② 能通过this访问静态成员变量吗？
静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）。
③ static能作用于局部变量么？
在Java中切记：static是不允许用来修饰局部变量。不要问为什么，这是Java语法的规定。
https://www.cnblogs.com/dolphin0520/p/3799052.html

https://www.cnblogs.com/fankongkong/p/5608710.html

15. java多态的实现原理。

https://www.cnblogs.com/kaleidoscope/p/9790766.html

18. Java IO与NIO与AIO。

http://ifeve.com/java-nio-vs-io/

https://www.cnblogs.com/94cool/p/5952903.html

21. 反射的作用于原理。

Java中的反射机制，使得我们可以在运行期获取Java类的字节码文件中的构造函数，成员变量，成员函数等信息。
1 获取Class对象的三种方式：
	1.Class.forName("类名字符串")（注意：类名字符串必须是全称,包名+类名）
		Class baseInfo = Class.forName("top.sguotao.ReflectionJava");
	2.类名.class
		Class object = Object.class;
	3.实例对象.getClass()
		Class date = (new Date()).getClass();
		Class testclass = this.getClass();
2 获取类的构造函数Constructor:
	1.获取参数列表是parameterTypes，访问控制符是public的构造函数
    	public Constructor getConstructor(Class[] parameterTypes)
	2.获取所有访问控制符是public的构造函数
    	public Constructor[] getConstructors()
	3.获取参数列表是parameterTypes，并且是类自身声明的构造函数，访问控制符包含public、protected和private的函数。
    	public Constructor getDeclaredConstructor(Class[] parameterTypes)
	4.获取类自身声明的全部的构造函数，访问控制符包含public、protected和private的函数。
    	public Constructor[] getDeclaredConstructors()
	5.如果类声明在其它类的构造函数中，返回该类所在的构造函数，如果存在则返回，不存在返回null
public Constructor getEnclosingConstructor()
3 获取类的成员变量
	1.获取“名称是name”的public的成员变量(包括从基类继承的、从接口实现的所有public成员变量)
    	public Field getField(String name)
    	
	2.获取全部的public成员变量(包括从基类继承的、从接口实现的所有public成员变量)
    	public Field[] getFields()
    	
	3.获取“名称是name”，并且是类自身声明的成员变量，包含public、protected和private成员变量。
    	public Field getDeclaredField(String name)
    	
	4.获取全部的类自身声明的成员变量，包含public、protected和private成员变量。
		public Field[] getDeclaredFields()
		
4 获取类的成员函数
	1.获取函数名是name，参数是parameterTypes的public的函数(包括从基类继承的、从接口实现的所有public函数)
    	public Method getMethod(String name, Class[] parameterTypes)
    	
	2.获取全部的public的函数(包括从基类继承的、从接口实现的所有public函数)
    	public Method[] getMethods()
    	
	3.获取函数名name，参数是parameterTypes，并且是类自身声明的函数，包含public、protected和private方法。
   		public Method getDeclaredMethod(String name, Class[] parameterTypes)
   		
	4.获取全部的类自身声明的函数，包含public、protected和private方法。
    	public Method[] getDeclaredMethods()
    	
	5.如果这个类是其它类中某个方法的内部类，调用getEnclosingMethod()就是这个类所在的方法；若不存在，返回null。
		public Method getEnclosingMethod()

https://blog.csdn.net/gtsong/article/details/83901388
https://www.cnblogs.com/zhaoguhong/p/6937364.html

22. 泛型常用特点，List能否转为List。

不行，类型转换只能在子类与父类的之间进行，而在泛型中不允许!

23. 解析XML的几种方式的原理与特点：DOM、SAX、PULL。

https://blog.csdn.net/Sa916487698/article/details/101254440?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param

24. Java与C++对比。

25. Java1.7与1.8新特性。

https://blog.csdn.net/qq_35503221/article/details/80311591

26. lambda表达式

https://www.cnblogs.com/JohnTsai/p/5584905.html

27. JNI的使用。

28. 常用注解

https://blog.csdn.net/da_xin/article/details/79241055

29. 深拷贝与浅拷贝的区别

简单地说，深拷贝对引用数据类型的成员变量的对象图中所有的对象都开辟了内存空间；而浅拷贝只是传递地址指向，新的对象并没有对引用数据类型创建内存空间。
1.浅拷贝（影子拷贝）
将原对象或原数组的引用直接赋给新对象，新数组，新对象／数组只是原对象的一个引用。
实现方式：
1.拷贝构造方法指的是该类的构造方法参数为该类的对象。使用拷贝构造方法可以很好地完成浅拷贝，直接通过一个现有的对象创建出与该对象属性相同的新的对象。
2.通过重写clone()方法进行浅拷贝：
Object类是类结构的根类，其中有一个方法为protected Object clone() throws CloneNotSupportedException，这个方法就是进行的浅拷贝。有了这个浅拷贝模板，我们可以通过调用clone()方法来实现对象的浅拷贝。
但是需要注意：
1、Object类虽然有这个方法，但是这个方法是受保护的（被protected修饰），所以我们无法直接使用。
2、使用clone方法的类必须实现Cloneable接口，否则会抛出异常CloneNotSupportedException。对于这两点，我们的解决方法是，在要使用clone方法的类中重写clone()方法，通过super.clone()调用Object类中的原clone方法。
2.深拷贝
创建一个新的对象和数组，将原对象的各项属性的“值”（数组的所有元素）拷贝过来，是“值”而不是“引用”。
实现方式：
1.将对象序列化为字节序列后，默认会将该对象的整个对象图进行序列化，再通过反序列即可完美地实现深拷贝。
2.与通过重写clone方法实现浅拷贝的基本思路一样，只需要为对象图的每一层的每一个对象都实现Cloneable接口并重写clone方法，最后在最顶层的类的重写的clone方法中调用所有的clone方法即可实现深拷贝。简单的说就是：每一层的每个对象都进行浅拷贝=深拷贝。
https://www.cnblogs.com/shakinghead/p/7651502.html
https://blog.csdn.net/weixin_41910848/article/details/82144671
https://blog.csdn.net/qq_39207948/article/details/81067482

30. 函数式接口

https://www.cnblogs.com/weixuqin/p/11494894.html

推荐书籍：《java核心技术卷I》《Thinking in java》《java并发编程》《effictive java》《大话设计模式》

JVM

JVM

https://www.jianshu.com/p/76959115d486

https://www.cnblogs.com/rinack/p/9888692.html

https://www.cnblogs.com/IUbanana/p/7067362.html

一、为什么需要垃圾回收
如果不进行垃圾回收，内存迟早都会被消耗空，因为我们在不断的分配内存空间而不进行回收。除非内存无限大，我们可以任性的分配而不回收，但是事实并非如此。所以，垃圾回收是必须的。
二、哪些内存需要回收？
哪些内存需要回收是垃圾回收机制第一个要考虑的问题，所谓“要回收的垃圾”无非就是那些不可能再被任何途径使用的对象。那么如何找到这些对象？
1、引用计数法
这个算法的实现是，给对象中添加一个引用计数器，每当一个地方引用这个对象时，计数器值+1；当引用失效时，计数器值-1。任何时刻计数值为0的对象就是不可能再被使用的。
2、可达性分析法
这个算法的基本思想是通过一系列称为“GC Roots”的对象作为起始点，从这些节点向下搜索，搜索所走过的路径称为引用链，当一个对象到GC Roots没有任何引用链（即GC Roots到对象不可达）时，则证明此对象是不可用的。
那么问题又来了，如何选取GCRoots对象呢？在Java语言中，可以作为GCRoots的对象包括下面几种：
(1) 虚拟机栈（栈帧中的局部变量区，也叫做局部变量表）中引用的对象。
(2) 方法区中的类静态属性引用的对象。
(3) 方法区中常量引用的对象。
(4) 本地方法栈中JNI(Native方法)引用的对象。
三、四种引用状态
1、强引用
代码中普遍存在的类似"Object obj = new Object()"这类的引用，只要强引用还存在，垃圾收集器永远不会回收掉被引用的对象。
2、软引用
描述有些还有用但并非必需的对象。在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围进行二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。Java中的类SoftReference表示软引用。
3、弱引用
描述非必需对象。被弱引用关联的对象只能生存到下一次垃圾回收之前，垃圾收集器工作之后，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。Java中的类WeakReference表示弱引用。
4、虚引用
这个引用存在的唯一目的就是在这个对象被收集器回收时收到一个系统通知，被虚引用关联的对象，和其生存时间完全没关系。Java中的类PhantomReference表示虚引用。
四、方法区的垃圾回收
1、方法区的垃圾回收主要回收两部分内容
1. 废弃常量。2. 无用的类。
2、如何判断无用的类呢？
1. 该类的所有实例都已经被回收，即Java堆中不存在该类的任何实例。
2. 加载该类的ClassLoader已经被回收。
3. 该类对应的java.lang.Class对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。
五、垃圾收集算法
1、标记-清除（Mark-Sweep）算法
2、复制（Copying）算法
3、标记-整理（Mark-Compact）算法
4、分代收集算法
六、垃圾收集器
1、Serial收集器
2、ParNew收集器
3、Parallel Scavenge收集器
4、Serial Old收集器
5、Parallel Old收集器
6、CMS收集器
7、G1收集器

https://www.cnblogs.com/xiaoxi/p/6486852.html

1. 内存模型以及分区，需要详细到每个区放什么。

2. 堆里面的分区：Eden，survival from to，老年代，各自的特点。

3. 对象创建方法，对象的内存分配，对象的访问定位。

4. GC的两种判定方法：引用计数与引用链。

5. GC的三种收集方法：标记清除、标记整理、复制算法的原理与特点，分别用在什么地方，如果让你优化收集方法，有什么思路？

6. GC收集器有哪些？CMS收集器与G1收集器的特点。

7. Minor GC与Full GC分别在什么时候发生？

8. 几种常用的内存调试工具：jmap、jstack、jconsole。

9. 类加载的五个过程：加载、验证、准备、解析、初始化。

10. 双亲委派模型：

启动类加载器 Bootstrap ClassLoader ：加载<JAVA_HOME>\lib目录下核心库

扩展类加载器 Extension ClassLoader ：加载<JAVA_HOME>\lib\ext目录下扩展包

应用程序类加载器 Application ClassLoader ：加载用户路径(classpath)上指定的类库

1. 当Application ClassLoader 收到一个类加载请求时，他首先不会自己去尝试加载这个类，而是将这个请求委派给父类加载器Extension ClassLoader去完成。 
2. 当Extension ClassLoader收到一个类加载请求时，他首先也不会自己去尝试加载这个类，而是将请求委派给父类加载器Bootstrap ClassLoader去完成。 
3. 如果Bootstrap ClassLoader加载失败(在<JAVA_HOME>\lib中未找到所需类)，就会让Extension ClassLoader尝试加载。 
4. 如果Extension ClassLoader也加载失败，就会使用Application ClassLoader加载。 
5. 如果Application ClassLoader也加载失败，就会使用自定义加载器去尝试加载。 
6. 如果均加载失败，就会抛出ClassNotFoundException异常。

https://blog.csdn.net/u012900118/article/details/79525931

11. 分派：静态分派与动态分派。

推荐书籍：《深入理解java虚拟机》

数据结构与算法

数据结构与算法

1. 链表与数组。

数组：顺序存储，随机访问

链表：链表存储，顺序访问

2. 队列和栈，出栈与入栈。

队列：先入先出

栈：先入后出，后入先出

3. 链表的删除、插入、反向。

https://blog.csdn.net/qq_24677897/article/details/88862891

4. 字符串操作。

5. Hash表的hash函数，冲突解决方法有哪些。

https://www.cnblogs.com/ITdong-1/articles/10178819.html

6. 各种排序：冒泡、选择、插入、希尔、归并、快排、堆排、桶排、基数的原理、平均时间复杂度、最坏时间复杂度、空间复杂度、是否稳定。

https://www.cnblogs.com/eniac12/p/5329396.html

7. 快排的partition函数与归并的Merge函数。

8. 对冒泡与快排的改进。

9. 二分查找，与变种二分查找。

10. 二叉树、B+树、AVL树、红黑树、哈夫曼树。

https://blog.csdn.net/yuxin6866/article/details/52327328

11. 二叉树的前中后续遍历：递归与非递归写法，层序遍历算法。

12. 图的BFS与DFS算法，最小生成树prim算法与最短路径Dijkstra算法。

13. KMP算法。

14. 排列组合问题。

15. 动态规划、贪心算法、分治算法。（一般不会问到）

16. 大数据处理：类似10亿条数据找出最大的1000个数…等等

https://blog.csdn.net/bigwatermelon11/article/details/76914386

推荐书籍：《大话数据结构》《剑指offer》《编程之美》

操作系统

1. 进程和线程的区别。

https://www.cnblogs.com/dengheng/p/5798913.html

2.wait()和sleep()的区别。

https://www.cnblogs.com/loren-Yang/p/7538482.html

join()、yield()与interrupt()的区别

join:将指定的线程加入到当前的线程之中，可以将两个交替执行的线程合并为顺序执行的线程，如果在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。

yield:暂停当前线程，以便其他线程有机会执行，不过不能指定暂停的时间，并且也不能保证当前线程马上停止。

interrupt()：实例方法只是改变中断状态，不会中断一个正在运行的线程

interrupted()：静态方法：内部实现是调用的当前线程的isInterrupted()，并且会重置当前线程的中断状态。

isInterrupted()：实例方法，是调用该方法的对象所表示的那个线程的isInterrupted()，不会重置当前线程的中断状态，测试线程当前是否已经中断，但是不能清除状态标识。

https://blog.csdn.net/zmh458/article/details/99673609

线程中断

线程被阻塞 调用interrupt()，才会中断线程，否则无反应

https://www.cnblogs.com/myseries/p/10918819.html

3. 实现多线程的两种方法：Thread与Runable。

https://blog.csdn.net/tianhouquan/article/details/82467714

4. 开启线程的三种方式,run()和start()方法区别

https://www.cnblogs.com/sunflower627/p/4816821.html

5. 死锁的必要条件，怎么处理死锁。

https://www.cnblogs.com/lipeineng/p/5919070.html

6. Window内存管理方式：段存储，页存储，段页存储。

https://www.jianshu.com/p/fc7853ae28a4

7. 进程的几种状态。

创建状态：进程在创建时需要申请一个空白PCB，向其中填写控制和管理进程的信息，完成资源分配。如果创建工作无法完成，比如资源无法满足，就无法被调度运行，把此时进程所处状态称为创建状态

就绪状态：进程已经准备好，已分配到所需资源，只要分配到CPU就能够立即运行

执行状态：进程处于就绪状态被调度后，进程进入执行状态

阻塞状态：正在执行的进程由于某些事件（I/O请求，申请缓存区失败）而暂时无法运行，进程受到阻塞。在满足请求时进入就绪状态等待系统调用

终止状态：进程结束，或出现错误，或被系统终止，进入终止状态。无法再执行

原文链接：https://blog.csdn.net/cafucwxy/article/details/78453430

https://www.cnblogs.com/zxf98/p/5716296.html

8. IPC几种通信方式。

https://blog.csdn.net/q5390498/article/details/50837699

9. 什么是虚拟内存。

https://blog.csdn.net/lvyibin890/article/details/82217193

10. 虚拟地址、逻辑地址、线性地址、物理地址的区别。

https://www.cnblogs.com/bhlsheji/p/4868964.html

推荐书籍：《深入理解现代操作系统》

集合

1. ArrayList、LinkedList、Vector的区别。

https://www.cnblogs.com/downey/p/4915334.html

2. foreach与正常for循环效率对比。

https://www.jianshu.com/p/e14f75716f9e

3. for循环为什么要倒序遍历list。

https://blog.csdn.net/ls0111/article/details/80810101

4. Map、Set、List、Queue、Stack的特点与用法。

https://www.cnblogs.com/yw-ah/p/5841369.html

5. HashMap和HashTable的区别。

https://blog.csdn.net/luojishan1/article/details/81952147

6. SparseArray 、ArrayMap和hashmap的区别

https://www.jianshu.com/p/7b9a1b386265

7. HashMap和ConcurrentHashMap的区别，HashMap的底层源码。

https://blog.csdn.net/kangxidagege/article/details/81474704

8. TreeMap、HashMap、LindedHashMap的区别。

https://blog.csdn.net/tianhouquan/article/details/82467627

9. Collection包结构，与Collections的区别。

https://www.cnblogs.com/fankongkong/p/5586504.html

10. Concurrent包里的其他东西：ArrayBlockingQueue、CountDownLatch等等。

https://www.cnblogs.com/feicheninfo/p/9679042.html

设计模式

1. 单一职责原则(Single Responsibility Principle SRP)

所谓单一职责原则就是一个类只负责一个职责，只有一个引起变化的原因。如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化会削弱或抑制这个类完成其他职责的能力，这个耦合会脆弱的设计。软件设计真正要做的许多内容，就是发现职责并把这些职责相互分离；如果能够想到多于一个动机去改变一个类，那么这个类就具有多个职责，就应该考虑类的分离。

2. 开放封闭原则(Open-Closed Principle OCP)

所谓开放封闭原则就是软件实体应该对扩展开放，而对修改封闭。开放封闭原则是所有面向对象原则的核心。软件设计本身所追求的目标就是封装变化，降低耦合，而开放封闭原则正是对这一目标的最直接体现。

开放封闭原则主要体现在两个方面：

对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。

对修改封闭，意味着类一旦设计完成，就可以独立其工作，而不要对类进行任何修改。

3. 里氏替换原则（Liskov Substitution Principle LSP）

里氏替换原则是面向对象设计的基本原则之一。任何基类可以出现的地方，子类一定可以出现。LSP是继承复用的基石，只有当子类可以替换基类，软件单位的功能不受影响时，基类才能真正的被复用，而子类也可以在基类的基础上增加新的行为。

4. 依赖倒置原则（Dependence Inversion Principle）

所谓依赖倒置原则就是要依赖于抽象，不要依赖于具体。简单的说就是对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。

5. 迪米特法则（Law of Demeter）又叫最少知识原则（Least Knowledge Principle LKP）

对面向对象来说，一个软件实体应当尽可能的少的与其他实体发生相互作用。每一个软件单位对其他的单位都只有最少的知识，而其局限于那些与本单位密切相关的软件单位。

迪米特法则的目的在于降低类之间的耦合。由于每个类尽量减少对其他类的依赖，因此，很容易使得系统的功能模块相互独立，相互之间不存在依赖关系。应用迪米特法则有可能造成的一个后果就是，系统中存在的大量的中介类，这些类之所以存在完全是为了传递类之间的相互调用关系—这在一定程度上增加系统的复杂度。

6. 组合/聚合复用原则（Composite/Aggregate Reuse Principle CARP）

组合和聚合都是对象建模中关联（Association）关系的一种.聚合表示整体与部分的关系，表示“含有”，整体由部分组合而成，部分可以脱离整体作为一个独立的个体存在。组合则是一种更强的聚合，部分组成整体，而且不可分割，部分不能脱离整体而单独存在。在合成关系中，部分和整体的生命周期一样，组合的新的对象完全支配其组成部分，包括他们的创建和销毁。一个合成关系中成分对象是不能与另外一个合成关系共享。

常用模式：单例模式、工厂模式、适配器模式、迭代器模式、策略模式、观察者模式、Builder模式

https://www.cnblogs.com/shaosks/category/351488.html

锁

1. 锁的分类

https://blog.csdn.net/t4i2b10X4c22nF6A/article/details/99256982

2. 锁的等级：方法锁、对象锁、类锁。

https://blog.csdn.net/tanga842428/article/details/79067479

3. volatile关键字

https://www.cnblogs.com/dolphin0520/p/3920373.html

4. CAS算法

https://www.jianshu.com/p/21be831e851e

5. 线程同步的方法：sychronized、lock、reentrantLock等。

https://blog.csdn.net/qiuchaoxi/article/details/79805450