编程

博客

◆
•
■
➽
■
▶
►
●
▻
☛
♥
✯
▍

Typora 编辑器

题： https://blog.csdn.net/zoucanfa/article/details/79559869

※ 1Basis ※

1-基础

1. Java特性，然后解释？

   • ans：跨平台、面向对象、多线程、分布式、简单、安全、健壮、高性能
   • 8大特性
     1）跨平台/可移植性-
     Java在设计时就很注重移植和跨平台性。
     比如：Java的int永远都是32位。不像C++可能是16，32，可能是根据编译器厂商规定的变化。程序的移植就会非常麻烦。
     3）面向对象
     面向对象是一种程序设计技术，非常适合大型软件的设计和开发。由于C++为了照顾大量C语言使用者而兼容了C，使得自身仅仅成为了带类的C语言，多少影响了其面向对象的彻底性！
     Java则是完全的面向对象语言。
     7）多线程
     多线程的使用可以带来更好的交互响应和实时行为。 Java多线程的简单性是Java成为主流服务器端开发语言的主要原因之一。
     6）分布式
     Java是为Internet的分布式环境设计的，因为它能够处理TCP/IP协议。事实上，通过URL访问一个网络资源和访问本地文件是一样简单的。Java还支持远程方法调用(RMI,Remote Method Invocation)，
     使程序能够通过网络调用方法。
     4）简单性
     Java就是C++语法的简化版，我们也可以将Java称之为“C++-”。跟我念“C加加减”，指的就是将C++的一些内容去掉；比如：头文件，指针运算，结构，联合，操作符重载，虚基类等等。
     同时，由于语法基于C语言，因此学习起来完全不费力。
     2）安全性
     Java适合于网络/分布式环境，为了达到这个目标，在安全性方面投入了很大的精力，使Java可以很容易构建防病毒，防篡改的系统。
     8）健壮性
     Java是一种健壮的语言，吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如：指针、内存的申请与释放等）。Java程序不可能造成计算机崩溃。即使Java程序也可能有错误。
     如果出现某种出乎意料之事，程序也不会崩溃，而是把该异常抛出，再通过异常处理机制加以处理。
     5）高性能
     Java最初发展阶段，总是被人诟病“性能低”；客观上，高级语言运行效率总是低于低级语言的，这个无法避免。Java语言本身发展中通过虚拟机的优化提升了几十倍运行效率。
     比如，通过JIT(JUST IN TIME)即时编译技术提高运行效率。 将一些“热点”字节码编译成本地机器码，并将结果缓存起来，在需要的时候重新调用。这样的话，使Java程序的执行效率大大提高，
     某些代码甚至接待C++的效率。因此，Java低性能的短腿，已经被完全解决了。业界发展上，我们也看到很多C++应用转到Java开发，很多C++程序员转型为Java程序员。
     参考：https://zhuanlan.zhihu.com/p/61995019

2. 面向对象的理解？ 什么是面向对象？/面向对象概念的理解？/面向对象三大特性？ |3

   • ans：封装、多态、继承
   • 理解：对现实世界万物的抽象建模。
     任何物体具有相同属性和行为特征的对象都可以归类，任何个体对象又是类的实例。
   • 核心思想：封装、继承和多态。
   • 封装。是将一类事物的属性和行为抽象成一个类，使代码模块化。
   • 继承。基于已有的类的定义为基础，构建新的类，已有的类称为父类，新构建的类称为子类，子类能调用父类的非private修饰的成员，同时还可以自己添加一些新的成员，扩充父类，甚至重写父类已有的方法，更其表现符合子类的特征。
   • 多态。方法的重写、重载与动态连接构成多态性。

3. 面向对象好处，体现在哪？

   • 易维护、质量高、效率高、易扩展
     -- 将对象进行分类，分别封装它们的数据和可以调用的方法，方便了函数、变量、数据的管理，方便方法的调用（减少重复参数等），尤其是在编写大型程序时更有帮助。
     -- 用面向对象的编程可以把变量当成对象进行操作，让编程思路更加清晰简洁，而且减少了很多冗余变量的出现
   • 好处

4. 多态是什么？怎样实现多态？

   • 多态：多态是同一个行为具有多个不同表现形式的能力。
     如，按下 F1 键，不同的软件界面，出现不同的功能
   • 实现：重写、接口、抽象类和抽象方法
     https://www.runoob.com/java/java-polymorphism.html

5. 重写和重载的区别 |2

   • 重写(Overriding)是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。参数列表和返回类型都不可修改。
   • 重载(overloading)是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
   • 重写重载是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载是一类中多态性的一种表现。

6. JDK 各个版本的特性？
   8-12: https://www.cnblogs.com/junrong624/p/11596191.html
   5-10: https://blog.csdn.net/pursue_vip/article/details/78692584

7. jdk1.8新特性？
   https://www.runoob.com/java/java8-new-features.html

   • Lambda表达式
   • 函数式接口
   • 方法引用和构造器调用
   • Stream API
   • 接口可以添加默认方法和静态方法，也就是定义不需要实现类实现的方法
   • 新的时间日期（Date/Time）相关的API
   • 重复注解，同一个注解可以使用多次
   • 引入Optional来避免空指针
   • 新增jdeps命令行，来分析类、目录、jar包的类依赖层级关系
   • JVM使用MetaSpace代替了永久代（PermGen Space）
     https://www.cnblogs.com/junrong624/p/11596191.html

8. Lambda表达式？

9. stream api？

10. 计算日期差？

    • 总：https://blog.csdn.net/sy793314598/article/details/79544796
    • J8：https://blog.csdn.net/hspingcc/article/details/73332526
      1）Period
      2）Duration
      3）ChronoUnit

11. Java编译和执行的缺点？

    • 优点
      编译执行是指把代码先编译成机器码。编译后的机器码具有平台相关性，运行速度快。
    • 缺点
      编译的过程（检查词法，语法代码优化，生成可执行文件）需要花费时间。
      编译后按顺序运行，如果编译中有任何异常，都无法继续运行。

12. 抽象类和接口的区别？ |3

    • 抽象类：
      • abstract修饰；
      • 抽象类不能实例化，即不能使用new关键字来实例化对象；
      • 含有抽象方法（使用abstract关键字修饰的方法）的类是抽象类，必须使用abstract关键字修饰；
      • 抽象类可以含有抽象方法，也可以不包含抽象方法，抽象类中可以有具体的方法；
      • 如果一个子类实现了父类（抽象类）的所有抽象方法，那么该子类可以不必是抽象类，否则就是抽象类；
      • 抽象类中的抽象方法只有方法体声明，没有具体实现；
    • 接口：
      • interface修饰；
      • 接口不能被实例化；
      • 一个类只能继承一个类，但是可以实现多个接口；
      • 接口中方法均为抽象方法；
      • 接口中不能包含实例域或静态方法（静态方法必须实现，接口中方法是抽象方法，不能实现）
      https://blog.csdn.net/qq_38734403/article/details/105712449

13. 类和接口区别？
    1）接口里所有的属性和方法都只能是静态的和public的
    2）接口中的方法不能有方法体
    3）接口不属能实例化对象
    4）接口只能用implements实现，而不能用extends继承，但是接口继承接口时要用extends
    5）一个类可以实现多个接口，只能继承一个类
    6）实现接口的类必须要实现接口中的方法，但继承类可以不重写父类中的方法
    7）接口的关键字是interface，类是class

14. 空间复杂度，时间复杂度？

    • 时间复杂度：算法执行语句的次数。
    • 空间复杂度：是对一个算法在运行过程中临时占用存储空间的度量

15. 写出查找网页中所有图片地址的正则表达式

16. 异常怎么用的，项目里哪些地方用到了异常，有没有用过ExceptionResover

    • 异常：是程序运行过程中发生的事件,该事件可以中断程序指令的正常执行流程。
    • 常见：空指针异常、下标越界异常等
      https://blog.csdn.net/woshi2512901978/article/details/8515464

17. exception的根类是哪个类？1/0是哪类异常？

    • 异常分成两种，Error和Exception。所有Exception的父类都是java.lang.Throwable。
      http://wenda.tianya.cn/question/15976cc8f0b695f6
    • 1/0异常：ArithmeticException: / by zero

18. 栈和队列的区别？
    1）栈和队列

    • 栈是先进后出，队列是先进先出。
    • 插入和删除操作：栈在一端，队列在两端。
    • 栈只允许在表尾一端进行插入和删除，
      队列只允许在表尾一端进行插入，在表头一端进行删除。

19. 链表和数组的优缺点及适用场景？
    1）特点

    • 数组：在内存中是一块连续的区域。
    • 链表：在内存中可以存在任何地方，不要求连续。

    2）优缺点

    • 数组：优点：随机访问性强；查找速度快。
      缺点：插入和删除效率低；内存空间要求高，必须有足够的连续内存空间；数组大小固定，不能动态拓展
    • 链表：优：插入删除速度快；内存利用率高；大小没有固定，拓展很灵活。
      缺：不能随机查找，必须从第一个开始遍历，查找效率低

    3）区别：

    • 链表适合插入删除，数组适合查询

20. 深拷贝和浅拷贝，举例说明
    1）浅拷贝：

    • 属性是基本类型，拷贝的就是基本类型的值；
    • 属性是引用类型（内存地址），拷贝的就是内存地址，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。

    2）深拷贝：clone

    • 会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

21. 泛型

22. 反射了解吗，JDK 中具体哪里用了，优点及缺点
    https://blog.csdn.net/huangliniqng/article/details/88554510

2-设计模式

1. 大纲
   |单例模式|工厂模式|生产者消费者|||||

2. 设计模式？
   ① 单例模式。
   ② 工厂模式。
   ③ 生产者消费者

3. 写出你熟悉的三种设计模式及UML图
   UML图画法：https://blog.csdn.net/js_tengzi/article/details/90143246
   设计模式UML：https://www.cnblogs.com/ningskyer/articles/3615312.html

   • 单例模式：https://blog.csdn.net/It_sharp/article/details/82147111
   • 工厂模式：
   • 消费者生产者模式：

4. 单例几种实现

   • 5种实现方式：饿汉、懒汉、双重校验锁、静态内部类和枚举
   • 单例代码
     https://blog.csdn.net/qq_38734403/article/details/106976266

5. 单例模式的线程安全问题

   • 设计模式，具体问了单例的 DCL（双重检查锁定DCL(double-checked locking) ）
   • 单例模式都有什么，都是否线程安全，可以怎么改进？（从synchronized到双重检验锁到枚举 Enum）
   • 单例模式，然后面试官问指令重排。

6. 设计模式用过哪些？写一个单例吧

7. 模板模式

8. 模板方法
   https://www.jianshu.com/p/800a44c1d9dd

9. 简单工厂 问题：依赖关系的解除，一个是if else。

3-JDK源码解析

|JDK1.8源码解析|

1-Object

|object源码解析 |

1. Object类都有哪些方法？ |2

   • 1）clone方法
     保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。
     主要是JAVA里除了8种基本类型传参数是值传递，其他的类对象传参数都是引用传递，有时候不希望在方法里讲参数改变，这是就需要在类中复写clone方法。
   • 2）getClass方法
     final方法，获得运行时类型。
   • 3）toString方法
     该方法用得比较多，一般子类都有覆盖。
   • 4）finalize方法
     该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。
   • 5）equals方法
     该方法是非常重要的一个方法。一般equals和==是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法。
   • 6）hashCode方法
     该方法用于哈希查找，可以减少在查找中使用equals的次数，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。
     一般必须满足obj1.equals(obj2)==true。可以推出obj1.hash-Code()==obj2.hashCode()，但是hashCode相等不一定就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。
     如果不重写hashcode(),在HashSet中添加两个equals的对象，会将两个对象都加入进去。
   • 7）wait方法
     wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。
     调用该方法后当前线程进入睡眠状态，直到以下事件发生。
     ① 其他线程调用了该对象的notify方法。
     ② 其他线程调用了该对象的notifyAll方法。
     ③ 其他线程调用了interrupt中断该线程。
     ④ 时间间隔到了。
     此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。
   • 8）notify方法
     该方法唤醒在该对象上等待的某个线程。
   • 9）notifyAll方法
     该方法唤醒在该对象上等待的所有线程。
     https://www.cnblogs.com/wxywxy/p/6740277.html

2. 介绍下hashcode和euqals。 |3

3. == 与 equals的区别 |2

4. 你重写过hashcode和equals么，要注意什么
   注意：https://blog.csdn.net/Mountain_YS/article/details/82151451

5. equals和==的区别，两个String之间判别，两个Integer之间判别？[note][3]
   1）String引用型数据类型字符串比较之中“==”和equals()的区别:

   • ==：比较的是两个字符串内存地址（堆内存）的数值是否相等，属于数值比较；
   • equals()：比较的是两个字符串的内容（地址值），属于内容比较
   • 基本类型通过==比较的是他们的值大小，而引用类型比较的是他们的引用地址
     

     String s1 = “Hello”;
     String s2 = “Hello”;
     String s3 = new String(“hello”);
     String s4 = s3; //引用传递
     s1 == s2 //true
     s1 == s3 //false
     s1 == s4 //false
     s3 == s4 //true
     s1.equals(s3) //true
     s1.equals(s4) //true
     s3.equals(s4) //true

2-引用类型

|基础源码解析|

1-基本类型

1. Java的基本数据类型？ |2

   • 8种类型
     1）四种整数类型(byte、short、int、long)
     2）两种浮点数类型(float、double)
     3）一种字符类型(char)
     4）一种布尔类型(boolean)
   • 类型转换：
     自动转换：byte-->short-->int-->long-->float-->double
   • 强制转换：①会损失精度，产生误差，小数点以后的数字全部舍弃。②容易超过取值范围。
   • 记忆：
     8位：Byte（字节型） 16位：short（短整型）、char（字符型） 32位：int（整型）、float（单精度型/浮点型）
     64位：long（长整型）、double（双精度型）
     boolean(布尔类型
     https://blog.csdn.net/pcwl1206/article/details/80766174
   • 8中基本数据类型的包装类除了Character和Boolean没有继承该类外，剩下的都继承了 Number 类，该类的方法用于各种数据类型的转换。

2. 汉字占几个char，int和long分别是多少位

   • 汉字
     UTF-8编码长度:3、GBK编码长度:2、GB2312编码长度:2
     https://www.cnblogs.com/xhlwjy/p/11398606.html
   • int和long
     byte：2个字节 16位
     char：2个字节 16位
     short ：2个字节 16位
     int ：4个字节 32位
     long：8个字节 64位
     float：4个字节 32 位
     double ：8个字节 64位
     https://www.cnblogs.com/150643com/p/10273377.html

3. int的默认值？

   • byte，short，int类型的默认值为0
   • float，double默认值为0.0
   • char等价于short其默认值也为0
   • boolean的默认值为false。
   • java中基本类型的默认值是0，引用类型会默认为null。
     https://www.cnblogs.com/hawk-li/p/10755182.html

4. int和Integer的区别

   • 区别:
     1）包装：Integer是int的包装类，int则是java的一种基本数据类型
     2）实例化：Integer变量必须实例化后才能使用，而int变量不需要
     3）存储：Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值
     4）默认值：Integer的默认值是null，int的默认值是0
   • 参考

3-Integer

|Integer的源码解析|[浅谈In]|

1. 为什么在接口设计的时候推荐使用包装类型而不推荐使用基本数据类型？

   • 传递基本类型:出方法外，参数还是原值
     如，参数2个int值 a，b交换数值，是在函数里面他们值是交换的，但是出了函数，还是原来各自的值。
     因为对于基本类型，java是把值传进去了，比如原来的a是某个元素的属性，比如是5，只是把5这个数复制一份传过去了，这5只是个数字，并不指向a的属性,你的改动是不会影响到a的属性的对非基本类型，在函数里的更改可以影响外面是因为直接把那个对象传进去了，改的是那个对象
   • 其他：
     1）Java是一个面向对象的语言，然而基本数据类型不具备面向对象的属性。当我们把基本数据类型包装成包装类型后，基本数据类型就具备了面向对象的属性。
     -- 在ArrayList 、HashMap这些容器来传输数据是，基本类型int和double是传输不进去的，因为容器都是装泛型（object类型）的，所以需要转为包装类型进行传输。
     -- 每一个基本类型都有对应的包装类型
     2）Integer包装数据类型中缓存了最大值和最小值
     对于自动装箱的int数据类型，会存在在方法区的缓冲区中保留，再次使用的时候直接引用。这里使用的是通过空间换时间的策略，减少了对象创建的过程，因此，如果是数值相同的Integer类型，地址也相同，代码演示。而new出来的对象，实际的存在于堆中，地址不相同。

2. Integer(1)数据都存在哪儿？

   • 基本数据类型和引用数据类型的区别主要在存储方式上：
     • 基本数据类型在被创建时，在栈上给其划分一块内存，将数值直接存储在栈上；
     • 引用数据类型在被创建时，首先要在栈上给其引用（句柄）分配一块内存，而对象的具体信息都存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。
   • new integer是创建一个对象 ，对象存在虚拟机堆中；
   • integer a =1，常量池中，即在方法区中。
     https://zhidao.baidu.com/question/1388492174848317980.html

3. Integer类型的变量能否==int类型变量，能否作比较，什么时候不能作比较。

   • 都可以，比较的是值
     http://www.2cto.com/kf/201210/162326.html

4. Integer a =new Integer(7);Integer b=7; a==b

5. 谁实现int装包的，是List吗不是list

   • 自动装箱时编译器调用valueOf将原始类型值转换成对象
   • 自动拆箱时，编译器通过调用类似intValue(),doubleValue()这类xxxValue()的方法将对象转换成原始类型值。
   • 缓存策略：如果i值在-128和127之间则直接从IntegerCache.cache缓存中获取指定数字的包装类；不存在则new出一个新的包装类。除double和float的自动装箱外。原因：缓存的这些对象都是经常使用到的（如字符、-128至127之间的数字），防止每次自动装箱都创建一此对象的实例。
     源码：https://www.jb51.net/article/111847.htm

6. 拆装箱

   • 把Integer类型赋值给int类型。此时，int类型变量的值会自动装箱成Integer类型，然后赋给Integer类型的引用，这里底层就是通过调用valueOf()这个方法来实现所谓的装箱的。
   • 把int类型赋值给Integer类型。此时，Integer类型变量的值会自动拆箱成int类型，然后赋给int类型的变量，这里底层则是通过调用intValue()方法来实现所谓的拆箱的。

7. 包装类型和基本类型的比较问题。

   • 整型包装类的值一定要使用 equals 方法进行判断
   • 浮点数的对比：1）指定一个误差范围或2）使用 BigDecimal 来定义值，再进行浮点数的运算操作
     https://www.cnblogs.com/angryprogrammer/p/11934415.html
     https://blog.csdn.net/czr11616/article/details/88188651

3-String

|String源码解析|

1.string，stringbuilder，stringbuffer的区别

1. String不可变的原因 |2

   • String类被final修饰，表示不可被继承。
   • String的成员变量char[] value被final修饰，初始化后不可更改引用。
   • String的成员变量value访问修饰符为private，不对外界提供修改value数组值的方法。

2. 为什么String用char数组存储？

   • 看原理

3-集合概况

|基础源码解析|

1. 集合框架概述？ /集合架构/集合体系

   • 参考
   • Java 集合框架主要包括2种类型的容器:
     ① 集合（Collection）：存储一个元素集合;
     ② 图（Map）：存储键/值对映射。
     Collection 接口又有 3种子类型，List、Set和Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。
     
   • 集合框架内容包含：
     集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：
     • 接口：是代表集合的抽象数据类型。
     例如Collection、List、Set、Map等。之所以定义多个接口，是为了以不同的方式操作集合对象
     • 实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
     • 算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。
   • 除了集合，该框架也定义了几个Map接口和类。Map 里存储的是键/值对。尽管Map不是集合，但是它们完全整合在集合中。
   • java集合框架位于java.util包中，所以当使用集合框架的时候需要进行导包。
     
     

2. 了解哪些List，哪些Map？

   接口	实现类
   List	ArrayList、LinkedList
   Set	HashSet、TreeSet、LinkedHashSet
   Map	HashMap、TreeMap、LinkedHashMap

   

3. 集合类介绍？

   • List 不唯一，有序
   • Set 唯一，无序
   • Map 键值对，key到value的映射
     
     • Key 唯一 无序
     • value 不唯一 无序

4. 你知道的集合，哪些是线程安全的？

   • 线程安全的集合：
     Vector | HashTable | StringBuffer
   • 非线程安全的：
     ArrayList|LinkedList|HashMap|HashSet|TreeMap|TreeSet|StringBulider

1-List

|1.8Arrays源码||1.8LinkedList源码|

1. list集合下有哪些？
   

2. Arraylist 与 LinkedList 区别? |7

   • 1> 是否保证线程安全：ArrayList和LinkedList都是不同步的，也就是不保证线程安全；
   • 2> 底层数据结构： Arraylist 底层使用的是 Object[]数组；LinkedList底层使用的是 双向链表数据结构（JDK1.6 之前为循环链表，JDK1.7 取消了循环。注意双向链表和双向循环链表的区别，下面有介绍到！）
   • 3> 插入和删除是否受元素位置的影响： ①ArrayList采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响。 比如：执行add(E e)方法的时候，ArrayList会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是O(1)。但是如果要在指定位置i插入和删除元素的话（add(int index, E element)）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的(n-i)个元素都要执行向后位/向前移一位的操作。
     ②LinkedList 采用链表存储，所以对于add(E e)方法的插入，删除元素时间复杂度不受元素位置的影响，近似 O(1)，如果是要在指定位置i插入和删除元素的话（(add(int index, E element)） 时间复杂度近似为o(n))因为需要先移动到指定位置再插入。
   • 4> 是否支持快速随机访问： LinkedList 不支持高效的随机元素访问，而 ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于get(int index)方法)。
   • 5> 内存空间占用： ArrayList 的空 间浪费主要体现在在 list 列表的结尾会预留一定的容量空间，而 LinkedList 的空间花费则体现在它的每一个元素都需要消耗比 ArrayList 更多的空间（因为要存放直接后继和直接前驱以及数据）。

ArrayList

|1.8ArrayList源码|扩容|

1. ArrayList源码实现？ |2

   • ArrayList 是一个用数组实现的集合，支持随机访问，元素有序且可以重复。
     

     public class ArrayList<E> extends AbstractList<E>
             implements List<E>, RandomAccess, Cloneable, java.io.Serializable

   

   • 实现
     ①、实现 RandomAccess 接口
     ②、实现 Cloneable 接口
     ③、实现 Serializable 接口
     ④、实现 List 接口
     这个接口是 List类集合的上层接口，定义了实现该接口的类都必须要实现的一组方法，如下所示，下面我们会对这一系列方法的实现做详细介绍。
     

   • 字段属性

      //集合的默认大小
      private static final int DEFAULT_CAPACITY = 10;
      //空的数组实例
      private static final Object[] EMPTY_ELEMENTDATA = {};
      //这也是一个空的数组实例，和EMPTY_ELEMENTDATA空数组相比是用于了解添加元素时数组膨胀多少
      private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
      //存储 ArrayList集合的元素，集合的长度即这个数组的长度
      //1、当 elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时将会清空 ArrayList
      //2、当添加第一个元素时，elementData 长度会扩展为 DEFAULT_CAPACITY=10
      transient Object[] elementData;
      //表示集合的长度
      private int size;

   • 构造函数

     public ArrayList(){}
     public ArrayList(int initialCapacity){}

2. 新建一个ArrayList会分配内存吗？

   • 新建ArrayList的时候，JVM为其分配一个默认或指定大小的连续内存区域（封装为数组）

3. ArrayList数据结构？
   ArrayList 的底层是数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。

4. 内存够用情况下ArrayList插入10w条数据？优化？

   • 插入

5. 扩容

6. ArrayList扩容的时机

   • 随着不断添加元素，数组大小增加，当数组的大小大于初始容量的时候(比如初始为10，当添加第11个元素的时候)，就会进行扩容，新的容量为旧的容量的1.5倍。扩容规则：((旧容量 * 3) / 2) + 1
   • 扩容方式
     扩容的时候，会以新的容量建一个原数组的拷贝，修改原数组，指向这个新数组，原数组被抛弃，会被GC回收。

7. ArrayList底层，依次删除List中的所有元素应该怎么删除？

8. 循环中的剔除掉Arraylist中的元素安全吗？

9. ArrayList什么时候缩容trimToSize()

   • 如果需要存储的数量刚好达到扩容而又没有更多的数据需要存储，剩下的空间岂不浪费掉了？
     类似场景：系统启动，初始化一些数据到ArrayList中缓存起来，这些数据比较多（几千个元素）但是根据业务场景是不会变的。那么我想是不是也会出现如上空间浪费的问题呢？
   • java.util.ArrayList.trimToSize()方法修整此ArrayList实例的是列表的当前大小的容量。
   • 调用Arrays.copyOf将容量减少到和元素数量一样大。
     Arrays.copyOf(elementData, size);
     https://blog.csdn.net/zhang_zhenwei/article/details/90717884

7.arraylist是线程安全的吗？如何实现线程安全

1. 什么时候用ArrayList或者List

LinkedList

1. linkedlist是单向的还是双向的，为什么这么设计

2. LinkedList底层，依次删除List中的所有元素应该怎么删除？

3. Linkedlist 数据结构 扩容

4. LinkedList插入int如何实现

   • 装箱~~

5. linkedlist的介绍

   • LinkedList是一个继承于AbstractSequentialList的双向链表。也可以被当作堆栈、队列或双端队列进行操作。

   • LinkedList 实现 List 接口，能进行队列操作。

     Queue<String> queue = new LinkedList<>();

   • LinkedList 实现 Deque接口，即能将LinkedList当作双端队列使用。

     Deque<String> deque = new LinkedList<>();

   • ArrayList底层是由数组支持，而LinkedList 是由双向链表实现的，其中的每个对象包含数据的同时还包含指向链表中前一个与后一个元素的引用。
     https://www.cnblogs.com/msymm/p/9872912.html

6. 代码题：List转化为Map

   /**
    * 用于把List<Object>转换成Map<String,Object>形式，便于存入缓存
    * @param keyName 主键属性
    * @param list 集合
    * @return 返回对象
    */
   private <T> Map<String, T> listToMap(String keyName, List<T> list){
       Map<String, T> map = new HashMap<String, T>();
       try {
           for (T l : list) {
               PropertyDescriptor pd = new PropertyDescriptor(keyName, l.getClass());
               Method method = pd.getReadMethod();// 获得get方法
               Object obj = method.invoke(l);// 执行get方法返回一个Object
               map.put(obj.toString(), l);
           }
           return map;
       } catch (Exception e) {
           System.out.println("Convert List to Map failed");
           e.printStackTrace();
       }
       return null;
   }

2-Map

1. Map的内部实现

   • Map只是一个接口，并没有实现，具体的实现由HashMap、HashTable

2. map了解吗，说说hashmap，hashtable，treemap？

HashMap

|HashMap1.8源码解析|源码1|ms经验|源码解析2|

1. HashMap源码/底层实现？ |4

   • HashMap1.8源码解析

2. HashMap实现原理

   • 遇到冲突时，HashMap是采用的链地址法来解决；
   • JDK1.6、JDK1.7
     采用位桶数组+链表实现，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）.
   • JDK1.8
     采用位桶数组+链表+红黑树实现，在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8），将链表转换为红黑树，这样大大减少了查找时间。

1-定义及字段属性

1. HashMap源码：HashMap1.8源码解析

   • HashMap定义：
     • 遇到冲突时，HashMap是采用的链地址法来解决；
     • 在JDK1.7中，HashMap是由数组+链表构成的；
     • 在JDK1.8中，HashMap是由数组+链表+红黑树构成，新增了红黑树作为底层数据结构，结构变得复杂了，但是效率也变的更高效。
     • JDK1.8 中 HashMap是如何实现的。
     
   • 1）HashMap的定义
     • HashMap 是一个散列表，它存储的内容是键值对(key-value)映射，而且 key 和 value 都可以为 null。
     

     public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
         ...
     }

   
   • 1> 首先该类实现了一个Map接口，该接口定义了一组键值对映射通用的操作。储存一组成对的键-值对象，提供key（键）到value（值）的映射，Map中的key不要求有序，不允许重复。value同样不要求有序，但可以重复。
   • 2> 但是我们发现该接口方法有很多，我们设计某个键值对的集合有时候并不像实现那么多方法，那该怎么办？
   JDK 还为我们提供了一个抽象类 AbstractMap ，该抽象类继承Map接口，所以如果我们不想实现所有的 Map 接口方法，就可以选择继承抽象类 AbstractMap 。
   • 但是我们发现HashMap类即继承了AbstractMap 接口，也实现了Map接口，这样做难道不是多此一举？后面我们会讲的LinkedHashSet集合也有这样的写法。
   是的.
   • 3> HashMap集合还实现了Cloneable接口以及 Serializable接口，分别用来进行对象克隆以及将对象进行序列化。

2. 字段属性

   //序列化和反序列化时，通过该字段进行版本一致性验证
   private static final long serialVersionUID = 362498820763181265L;
   //默认 HashMap 集合初始容量为16（必须是 2 的倍数）
   static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
   //集合的最大容量，如果通过带参构造指定的最大容量超过此数，默认还是使用此数
   static final int MAXIMUM_CAPACITY = 1 << 30;
   //默认的填充因子
   static final float DEFAULT_LOAD_FACTOR = 0.75f;
   //当桶(bucket)上的结点数大于这个值时会转成红黑树(JDK1.8新增)
   static final int TREEIFY_THRESHOLD = 8;
   //当桶(bucket)上的节点数小于这个值时会转成链表(JDK1.8新增)
   static final int UNTREEIFY_THRESHOLD = 6;
   /**(JDK1.8新增)
    * 当集合中的容量大于这个值时，表中的桶才能进行树形化 ，否则桶内元素太多时会扩容，
    * 而不是树形化 为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD
    */
   static final int MIN_TREEIFY_CAPACITY = 64;
   // **注意：后面三个字段是JDK1.8新增的，主要是用来进行红黑树和链表的互相转换。**
   // ------------------------------------------------------------------------
   /**
   * 初始化使用，长度总是 2的幂
   */
   transient Node<K,V>[] table;
   /**
   * 保存缓存的entrySet（）
   */
   transient Set<Map.Entry<K,V>> entrySet;
   /**
   * 此映射中包含的键值映射的数量。（集合存储键值对的数量）
   */
   transient int size;
   /**
   * 跟前面ArrayList和LinkedList集合中的字段modCount一样，记录集合被修改的次数
   * 主要用于迭代器中的快速失败
   */
   transient int modCount;
   /**
   * 调整大小的下一个大小值（容量*加载因子）。capacity * load factor
   */
   int threshold;
   /**
   * 散列表的加载因子。
   */
   final float loadFactor;

   ① Node[] table
   -- HashMap是由数组+链表+红黑树组成，table字段就是数组。
   -- 初始化长度默认是DEFAULT_INITIAL_CAPACITY= 16。
   ② size
   集合中存放key-value的实时对数。
   ③ loadFactor
   -- 装载因子，是用来衡量HashMap满的程度；
   -- HashMap的实时装载因子的计算：size/capacity，而不是占用桶的数量去除以capacity。capacity 是桶的数量，也就是table的长度length。
   -- 默认的负载因子0.75 是对空间和时间效率的一个平衡选择，建议大家不要修改，除非在时间和空间比较特殊的情况下，如果内存空间很多而又对时间效率要求很高，可以降低负载因子loadFactor的值；相反，如果内存空间紧张而对时间效率要求不高，可以增加负载因子 loadFactor 的值，这个值可以大于1。
   ④ threshold
   计算公式：capacity*loadFactor。
   这个值是当前已占用数组长度的最大值。过这个数目就重新resize(扩容)，扩容后的HashMap容量是之前容量的两倍

3. 为什么HashMap的加载因子是0.75？
   https://zhuanlan.zhihu.com/p/149687607

2-构造函数

• 5）构造函数
  ① 默认无参构造函数
  无参构造器，初始化散列表的加载因子为0.75

  /**
   * 默认构造函数，初始化加载因子loadFactor = 0.75
   */
  public HashMap() {
      this.loadFactor = DEFAULT_LOAD_FACTOR; 
  }

  ② 指定初始容量的构造函数

      /**
       *
       * @param initialCapacity 指定初始化容量
       * @param loadFactor 加载因子 0.75
       */
      public HashMap(int initialCapacity, float loadFactor) {
          //初始化容量不能小于 0 ，否则抛出异常
          if (initialCapacity < 0)
              throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
          //如果初始化容量大于2的30次方，则初始化容量都为2的30次方
          if (initialCapacity > MAXIMUM_CAPACITY)
              initialCapacity = MAXIMUM_CAPACITY;
          //如果加载因子小于0，或者加载因子是一个非数值，抛出异常
          if (loadFactor <= 0 || Float.isNaN(loadFactor))
              throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
          this.loadFactor = loadFactor;
          this.threshold = tableSizeFor(initialCapacity);
      }
      // 返回大于等于initialCapacity的最小的二次幂数值。
      // >>> 操作符表示无符号右移，高位取0。
      // | 按位或运算
      static final int tableSizeFor(int cap) {
          int n = cap - 1;
          n |= n >>> 1;
          n |= n >>> 2;
          n |= n >>> 4;
          n |= n >>> 8;
          n |= n >>> 16;
          return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
      }

  1. 容量

3-hash

1. 哈希表
   • Hash表也称为散列表，也有直接译作哈希表；
   • Hash表是一种根据关键字值（key-value）而直接进行访问的数据结构。也就是说它通过把关键码值映射到表中的一个位置来访问记录，以此来加快查找的速度。
   • 查找
   哈希表通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表，只需要O(1)的时间级。
   
   • 问题①：为什么要有散列函数？
   散列函数的存在能够帮助我们更快的确定key和value的映射关系，试想一下，如果没有汉字和拼音的转换规则（或者汉字和偏旁部首的），给你一个汉字，你该如何从字典中找到该汉字？我想除了遍历整部字典，你没有什么更好的办法。
   • 问题②：多个key通过散列函数会得到相同的值，这时候怎么办？
   哈希冲突：
   ① 开放地址法：
   当我们遇到冲突了，这时候通过另一种函数再计算一遍，得到相应的映射关系。比如对于汉语字典，一个字 “余”，拼音是“yu”，我们将其放在页码为567(假设在该位置)，这时候又来了一个汉字“于”，拼音也是“yu”，那么这时候我们要是按照转换规则，也得将其放在页码为567的位置，但是我们发现这个页码已经被占用了，这时候怎么办？我们可以在通过另一种函数，得到的值加1。那么汉字"于"就会被放在576+1=577的位置。
   ② 链地址法：
   -- 我们可以将字典的每一页都看成是一个子数组或者子链表，当遇到冲突了，直接往当前页码的子数组或者子链表里面填充即可。那么我们进行同音字查找的时候，可能需要遍历其子数组或者子链表。
   -- 对于开放地址法，可能会遇到二次冲突，三次冲突，所以需要良好的散列函数，分布的越均匀越好。对于链地址法，虽然不会造成二次冲突，但是如果一次冲突很多，那么会造成子数组或者子链表很长，那么我们查找所需遍历的时间也会很长。

2. HashMap中的hash函数？Hash算法（扰动函数） |3

   • HashMap中的哈希算法：确定哈希桶数组索引位置

     static final int hash(Object key) {
         int h;
         return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
     }
     // 使用:这一步是在后面添加元素putVal()方法中进行位置的确定
     i = (table.length - 1) & hash(key);

   • 散列函数来确定索引的位置。
     散列函数设计的越好，使得元素分布的越均匀。HashMap是数组+链表+红黑树的组合，我们希望在有限个数组位置时，尽量每个位置的元素只有一个，那么当我们用散列函数求得索引位置的时候，能马上知道对应位置的元素是不是想要的，而不是要进行链表的遍历或者红黑树的遍历，这会大大优化我们的查询效率。

3. 哈希表
   哈希表

4. hashmap哈希冲突的解决方式？

   • 拉链法

5. hashmap容量为什么是2的幂次

   • get方法中，使用 (n - 1) & hash实际上是计算出 key 在 tab 中索引位置
   • n 永远是2的次幂，n-1的二进制永远都是尾端以连续1的形式表示，当(n - 1) & hash 会保留hash中 后 x 位的 1
     https://blog.csdn.net/weixin_38405253/article/details/104230889
   • 不是2幂次就会造成分布不均匀了，增加了碰撞的几率，减慢了查询的效率，造成空间的浪费。
     https://www.cnblogs.com/aotemanzhifu/p/9192373.html

4-put

1. HashMap的put过程？

   • 代码

     //hash(key)就是上面讲的hash方法，对其进行了第一步和第二步处理
         public V put(K key, V value) {
             return putVal(hash(key), key, value, false, true);
         }
         /**
          *
          * @param hash 索引的位置
          * @param key  键
          * @param value  值
          * @param onlyIfAbsent true 表示不要更改现有值
          * @param evict false表示table处于创建模式
          * @return
          */
         final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                 boolean evict) {
              Node<K,V>[] tab; Node<K,V> p; int n, i;
              //如果table为null或者长度为0，则进行初始化
              //resize()方法本来是用于扩容，由于初始化没有实际分配空间，这里用该方法进行空间分配，后面会详细讲解该方法
              if ((tab = table) == null || (n = tab.length) == 0)
                  n = (tab = resize()).length;
              //注意：这里用到了前面讲解获得key的hash码的第三步，取模运算，下面的if-else分别是 tab[i] 为null和不为null
              if ((p = tab[i = (n - 1) & hash]) == null)
                  tab[i] = newNode(hash, key, value, null);//tab[i] 为null，直接将新的key-value插入到计算的索引i位置
              else {//tab[i] 不为null，表示该位置已经有值了
                  Node<K,V> e; K k;
                  if (p.hash == hash &&
                      ((k = p.key) == key || (key != null && key.equals(k))))
                      e = p;//节点key已经有值了，直接用新值覆盖
                  //该链是红黑树
                  else if (p instanceof TreeNode)
                      e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                  //该链是链表
                  else {
                      for (int binCount = 0; ; ++binCount) {
                          if ((e = p.next) == null) {
                              p.next = newNode(hash, key, value, null);
                              //链表长度大于8，转换成红黑树
                              if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                                  treeifyBin(tab, hash);
                              break;
                          }
                          //key已经存在直接覆盖value
                          if (e.hash == hash &&
                              ((k = e.key) == key || (key != null && key.equals(k))))
                              break;
                          p = e;
                      }
                  }
                  if (e != null) { // existing mapping for key
                      V oldValue = e.value;
                      if (!onlyIfAbsent || oldValue == null)
                          e.value = value;
                      afterNodeAccess(e);
                      return oldValue;
                  }
              }
              ++modCount;//用作修改和新增快速失败
              if (++size > threshold)//超过最大容量，进行扩容
                  resize();
              afterNodeInsertion(evict);
              return null;
         }

   • 流程：
     ①、判断键值对数组 table 是否为空或为null，否则执行resize()进行扩容；
     ②、根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加，转向⑥，如果table[i]不为空，转向③；
     ③、判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向④，这里的相同指的是hashCode以及equals；
     ④、判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向⑤；
     ⑤、遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可；
     ⑥、插入成功后，判断实际存在的键值对数量size是否超过了最大容量threshold，如果超过，进行扩容。
     ⑦、如果新插入的key不存在，则返回null，如果新插入的key存在，则返回原key对应的value值（注意新插入的value会覆盖原value值）

   • 图示
     
     put过程图

2. Hashmap的原理，增的情况后端数据结构如何位移

3. hashMap怎么获取有几个元素，底层实现是什么

   • 代码

    public int size() {
        return size;
    }
    // 计算
    if (++size > threshold)//超过最大容量，进行扩容 -58
    resize();                                       -59

• 数组上有5个元素，而某个链表上有3个元素，问此HashMap的 size 是多大？
  分析第58,59 行代码，很容易知道，只要是调用put()方法添加元素，那么就会调用 ++size(这里有个例外是插入重复key的键值对，不会调用，但是重复key元素不会影响size),所以，上面的答案是 7。

  1. 为什么在1.8中链表大于8时会转红黑树？ |2
     因为泊松分布，拉链法哈希冲突累积到七个元素后，通过泊松分布计算得到第八个冲突元素出现的概率极低，几乎不可能出现，但只要出现了就树形化提高查询效率（前提是数组长度已经到了64，否则先扩容）

  2. 红黑树的概念：
     https://mp.weixin.qq.com/s/sPIE54UmvNgINZIATQKyew

• 红黑树：https://blog.csdn.net/tanrui519521/article/details/80980135

  1. 为什么要用红黑树？而不用平衡二叉树？ |2
• 在Java 8之前的实现中是用链表解决冲突的，在产生碰撞的情况下，进行get时，两步的时间复杂度是O(1)+O(n)。因此，当碰撞很厉害的时候n很大，O(n)的速度显然是影响速度的。
• 因此在Java 8中，利用红黑树替换链表，这样复杂度就变成了O(1)+O(logn)了，这样在n很大的时候，能够比较理想的解决这个问题

5-resize

1. 扩容机制

   • 先介绍 JDK1.7的扩容源码，便于理解，然后在介绍JDK1.8的源码。

     //参数 newCapacity 为新数组的大小
         void resize(int newCapacity) {
             Entry[] oldTable = table;//引用扩容前的 Entry 数组
             int oldCapacity = oldTable.length;
             if (oldCapacity == MAXIMUM_CAPACITY) {//扩容前的数组大小如果已经达到最大(2^30)了
                 threshold = Integer.MAX_VALUE;///修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
                 return;
             }
             Entry[] newTable = new Entry[newCapacity];//初始化一个新的Entry数组
             transfer(newTable, initHashSeedAsNeeded(newCapacity));//将数组元素转移到新数组里面
             table = newTable;
             threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);//修改阈值
         }
         void transfer(Entry[] newTable, boolean rehash) {
             int newCapacity = newTable.length;
             for (Entry<K,V> e : table) {//遍历数组
                 while(null != e) {
                     Entry<K,V> next = e.next;
                     if (rehash) {
                         e.hash = null == e.key ? 0 : hash(e.key);
                     }
                     int i = indexFor(e.hash, newCapacity);//重新计算每个元素在数组中的索引位置
                     e.next = newTable[i];//标记下一个元素，添加是链表头添加
                     newTable[i] = e;//将元素放在链上
                     e = next;//访问下一个 Entry 链上的元素
                 }
             }
         }

   • JDK1.7中首先是创建一个新的大容量数组，然后依次重新计算原集合所有元素的索引，然后重新赋值。如果数组某个位置发生了hash冲突，使用的是单链表的头插入方法，同一位置的新元素总是放在链表的头部，这样与原集合链表对比，扩容之后的可能就是倒序的链表了。

   • 1.8源码

     final Node<K,V>[] resize() {
             Node<K,V>[] oldTab = table;
             int oldCap = (oldTab == null) ? 0 : oldTab.length;//原数组如果为null，则长度赋值0
             int oldThr = threshold;
             int newCap, newThr = 0;
             if (oldCap > 0) {//如果原数组长度大于0
                 // 超过最大值就不再扩充了，就只好随你碰撞去吧
                 if (oldCap >= MAXIMUM_CAPACITY) {//数组大小如果已经大于等于最大值(2^30)
                     threshold = Integer.MAX_VALUE;//修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
                     return oldTab;
                 }
                 //原数组长度大于等于初始化长度16，并且原数组长度扩大1倍也小于2^30次方
                 // 没超过最大值，就扩充为原来的2倍
                 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                          oldCap >= DEFAULT_INITIAL_CAPACITY)
                     newThr = oldThr << 1; // 阀值扩大2倍
             }
             else if (oldThr > 0) //旧阀值大于0，则将新容量直接等于就阀值
                 newCap = oldThr;
             else {//阀值等于0，oldCap也等于0（集合未进行初始化）
                 newCap = DEFAULT_INITIAL_CAPACITY;//数组长度初始化为16
                 newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//阀值等于16*0.75=12
             }
             //计算新的阀值上限
             if (newThr == 0) {
                 float ft = (float)newCap * loadFactor;
                 newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                           (int)ft : Integer.MAX_VALUE);
             }
             threshold = newThr;
             @SuppressWarnings({"rawtypes","unchecked"})
                 Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
             table = newTab;
             if (oldTab != null) {
                 //把每个bucket都移动到新的buckets中
                 for (int j = 0; j < oldCap; ++j) {
                     Node<K,V> e;
                     if ((e = oldTab[j]) != null) {
                         oldTab[j] = null;//元数据j位置置为null，便于垃圾回收
                         if (e.next == null)//数组没有下一个引用（不是链表）
                             newTab[e.hash & (newCap - 1)] = e;
                         else if (e instanceof TreeNode)//红黑树
                             ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                         else { // preserve order
                             Node<K,V> loHead = null, loTail = null;
                             Node<K,V> hiHead = null, hiTail = null;
                             Node<K,V> next;
                             do {
                                 next = e.next;
                                 //原索引
                                 if ((e.hash & oldCap) == 0) {
                                     if (loTail == null)
                                         loHead = e;
                                     else
                                         loTail.next = e;
                                     loTail = e;
                                 }
                                 //原索引+oldCap
                                 else {
                                     if (hiTail == null)
                                         hiHead = e;
                                     else
                                         hiTail.next = e;
                                     hiTail = e;
                                 }
                             } while ((e = next) != null);
                             //原索引放到bucket里
                             if (loTail != null) {
                                 loTail.next = null;
                                 newTab[j] = loHead;
                             }
                             //原索引+oldCap放到bucket里
                             if (hiTail != null) {
                                 hiTail.next = null;
                                 newTab[j + oldCap] = hiHead;
                             }
                         }
                     }
                 }
             }
             return newTab;
         }

   • 相比于JDK1.7，1.8使用的是2次幂的扩展(指长度扩为原来2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”

6-线程安全

|线程不安全|

1. HashMap线程安全吗？为什么不安全？不安全怎么办？ |3

   • 线程不安全的，其主要体现：
     1）在jdk1.7中，在多线程环境下，扩容时会造成死循环（环形链）或数据丢失。
     2）在jdk1.8中，在多线程环境下，会发生数据覆盖的情况。
   • 过程分析：线程不安全
     分析过程结合阅读

2. hashMap1.8有什么改动

3. 如何resize，最后细节到是否覆盖旧值的参数

4. HashMap在并发情况下发生resize会出现什么问题？

5. 举例说明hashmap1.7循环依赖的产生

6. 如何优化使得HashMap线程安全/如何实现线程安全的hashmap？

7-remove

1. 删除元素小于8？
   6

2. Hashmap的原理，删的情况后端数据结构如何位移

   • 删：当遍历Map需要删除的时候,不可以for循环遍历,否则会产生并发修改异常CME,只能使用迭代器iterator.remove()来删除元素,或者使用线程安全的concurrentHashMap来删除Map中删除元素(concurrentHashMap和迭代器Iterator遍历删除)
     https://www.cnblogs.com/zhangnf/p/HashMap.html

8-get

1. 查找元素

   • ①、通过 key 查找 value
     首先通过 key 找到计算索引，找到桶位置，先检查第一个节点，如果是则返回，如果不是，则遍历其后面的链表或者红黑树。其余情况全部返回 null。

     public V get(Object key) {
             Node<K,V> e;
             return (e = getNode(hash(key), key)) == null ? null : e.value;
         }
         final Node<K,V> getNode(int hash, Object key) {
             Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
             if ((tab = table) != null && (n = tab.length) > 0 &&
                 (first = tab[(n - 1) & hash]) != null) {
                 //根据key计算的索引检查第一个索引
                 if (first.hash == hash && // always check first node
                     ((k = first.key) == key || (key != null && key.equals(k))))
                     return first;
                 //不是第一个节点
                 if ((e = first.next) != null) {
                     if (first instanceof TreeNode)//遍历树查找元素
                         return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                     do {
                         //遍历链表查找元素
                         if (e.hash == hash &&
                             ((k = e.key) == key || (key != null && key.equals(k))))
                             return e;
                     } while ((e = e.next) != null);
                 }
             }
             return null;
         }

   • ②、判断是否存在给定的 key 或者 value

public boolean containsKey(Object key) {
        return getNode(hash(key), key) != null;
    }
    public boolean containsValue(Object value) {
        Node<K,V>[] tab; V v;
        if ((tab = table) != null && size > 0) {
            //遍历桶
            for (int i = 0; i < tab.length; ++i) {
                //遍历桶中的每个节点元素
                for (Node<K,V> e = tab[i]; e != null; e = e.next) {
                    if ((v = e.value) == value ||
                        (value != null && value.equals(v)))
                        return true;
                }
            }
        }
        return false;
    }

1. 22
   
   • HashMap并没有直接提供getNode接口给用户调用，而是提供的get函数，而get函数就是通过getNode来取得元素的。
   • get(key)方法时获取key的hash值，计算hash&(n-1)得到在链表数组中的位置first=tab[hash&(n-1)],先判断first的key是否与参数key相等，不等就遍历后面的链表找到相同的key值返回对应的Value值即可
     https://blog.csdn.net/tuke_tuke/article/details/51588156
     https://www.cnblogs.com/leesf456/p/5242233.html

9-遍历

1. 如何遍历hashmap

2. equals()和hashCode()的都有什么作用？-
   通过对key的hashCode()进行hashing，并计算下标( n-1 & hash)，从而获得buckets的位置。如果产生碰撞，则利用key.equals()方法去链表或树中去查找对应的节点

3. 如果HashMap的大小超过了负载因子(load factor)定义的容量，怎么办？-
   如果超过了负载因子(默认0.75)，则会重新resize一个原来长度两倍的HashMap，并且重新调用hash方法。

TreeMap

|1.8TreeMap源码|

LinkedHashMap

|1.8LinkedHashMap源码|

3-Set

Set类怎么保证唯一的，add方法底层实现

HashSet

|源码解析|

1. hashset实现原理?

   • 源码解析
   • 基于HashMap实现的，HashSet底层使用HashMap来保存所有元素，相关HashSet的操作，基本上都是直接调用底层HashMap的相关方法来完成，
   • https://blog.csdn.net/guoweimelon/article/details/50804799
     https://blog.csdn.net/zhaojie181711/article/details/80480421

2. 重复set
   往set里面put一个学生对象，然后将这个学生对象的学号改了，再put进去，可以放进set么？并讲出为什么

   • 不可以放进，hashcode不变
     https://www.cnblogs.com/Spades7/p/8206671.html

3. 假设现在一个学生类，有学号和姓名，我现在hashcode方法重写的时候，只将学号参与计算，会出现什么情况？
   1）可能有相同hashcode，但不是一个对象
   2）只要 hashcode 不相等就玩儿完，不用再去调用复杂的 equals 了。提升容器使用效率。
   2）equals()和hashCode()有一个契约：

   • 如果两个对象相等的话，它们的hashcode必须相等；
   • 但如果两个对象的hashcode相等的话，这两个对象不一定相等。
     https://blog.csdn.net/pigcircle_1988/article/details/84911272

4. hashset为什么不是线程安全的，描述场景

   2） hashSet

   • hashSet的底层：hashMap 16,0.75
   • 你确定hashSet的底层？肯定是，add，
     hashSet的add由hashmap的普通实现，只管key，value设置为present常数

LinkedHashSet

|1.8LinkedHashSet源码||

2-迭代器

5.迭代器和for循环的区别

1. 集合类用了那些设计模式
   
   • 迭代器模式
     https://blog.csdn.net/Lammonpeter/article/details/82142020
     https://blog.csdn.net/lunb17/article/details/97940313

6-collections

1. Arrays工具类怎么用？

2. collections有哪些？

5-集合区别

1. 数组和集合的区别

2. Vector与list区别

3. collection与collections区别

   • Collection:
     -- 集合类的上层接口。
     -- Interface，包含了一些集合的基本操作。
     -- Set接口和List接口的父接口
   • Collections：
     -- 集合框架的帮助类，
     -- 包含一些对集合的排序，搜索以及序列化的操作。
     -- 本质，Collections是一个类
     https://blog.csdn.net/zlczsw/article/details/100118405
     https://www.cnblogs.com/jxxblogs/p/11547898.html

4. List与Set的区别？ |2
   （List有序可重复、Set无序且不可重复）

   • 两个接口都是继承自Collection：
     ① List可重复，Set中不允许重复；
     ② List是有序集合，会保留元素插入时的顺序，Set是无序集合。
     ③ List可以通过下标来访问，而Set不能。
     https://www.cnblogs.com/helloworldcode/p/12122072.html

5. List、Vector区别

   • java中,collection集合中是有List和vector（都是接口）
   • List是在jdk1.2以后推出的，而Vector是在jdk1.0推出的
   • List采用的是异步处理方式，性能高，而Vector采用的是同步处理方式，性能低
   • List属于非线程安全，Vector属于线程安全

6. Arraylist与Vector区别

   • ArrayList 是 List 的主要实现类，底层使用Object[]存储，适用于频繁的查找工作，线程不安全 ；
   • Vector 是 List 的古老实现类，底层使用 Object[] 存储，线程安全的。

7. HashMap与HashTable区别

   • HashMap
     -- 线程不安全；
     -- 是一个接口,是 Map的一个子接口,
     -- 是将键映射到值得对象,不允许键值重复,允许空键和空值;
     -- 非线程安全, HashMap的效率要较 HashTable 的效率高一些.
   • HashTable
     -- 线程安全的集合；
     -- 不允许 null 值作为一个 key 值或者 Value 值;
   • HashTable 是 sychronize(同步化),多个线程访问时不需要自己为它的方法实现同步,而HashMap在被多个线程访问的时候需要自己为它的方法实现同步;

※ 2-JVM（Java Virtual Machine）※

-- jvm学习：https://www.zybuluo.com/songhanshi/note/1733752

1. 配置过java启动设置吗
   没有，我只用过-xms等指令改过JVM参数，和jinfo看参数
   -XMX -XSS -XMN

2. 说说对象创建到消亡的过程
   https://blog.csdn.net/u012312373/article/details/46718911
   https://blog.csdn.net/qq_25005909/article/details/78981512

JMM规定了内存主要划分为主内存和工作内存两种。此处的主内存和工作内存跟JVM内存划分（堆、栈、方法区）是在不同的层次上进行的，如果非要对应起来，主内存对应的是Java堆中的对象实例部分，工作内存对应的是栈中的部分区域，从更底层的来说，主内存对应的是硬件的物理内存，工作内存对应的是寄存器和高速缓存。
1. 线程的工作内存指的是什么，在内存的哪个地方
* JVM将内存组织为主内存和工作内存两个部分。
* 主内存主要包括本地方法区和堆。每个线程都有一个工作内存，主要包括两个部分，一个是属于该线程私有的栈和对主存部分变量拷贝的寄存器(包括程序计数器PC和cup工作的高速缓存区)。
① 所有的变量都存储在主内存中，对于所有线程都是共享的。
② 每条线程都有自己的工作内存，工作内存中保存的是主存中某些变量的拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存中的变量。
③ 线程之间无法直接访问对方的工作内存中的变量，线程间变量的传递均需要通过主内存来完成。
待完善：https://aalion.github.io/2019/12/08/concurrency12/
https://www.jianshu.com/p/679ad52eca05

一、概述

1. JRE和JDK的区别？

   • JDK(Java Development Kit)
     -- Java程序设计语言、Java虚拟机、Java类库这三部分统称为JDK，
     广义上JDK常来代指整个Java技术体系；
     -- Java的开发工具，提供了编译和运行Java程序所需的各种资源和工具；
     -- 不仅可以开发Java程序，也同时拥有了运行Java程序的平台；
   • JRE(Java Runtime Enviroment)
     -- Java运行环境，包括：虚拟机+java的核心类库；
     -- 只能运行Java程序，不包含开发工具(编译器、调试器等)。

2. JVM了解么？

   • 是什么
     虚拟机是一种抽象化的计算机，通过在实际的计算机上仿真模拟各种计算机功能来实现。Java虚拟机有自己完善的硬体架构，如处理器、堆栈、寄存器等，还具有相应的指令系统。Java虚拟机屏蔽了与具体操作系统平台相关的信息，使得Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。
   • 系统
     一个Java虚拟机实例在运行过程中有三个子系统来保障它的正常运行，分别是类加载器子系统， 执行引擎子系统和垃圾收集子系统。

3. 主流：HotSpot VM

   • Sun/OracleJDK和OpenJDK中的默认Java虚拟机，也是目前使用范围最广的Java虚拟机。
   • HotSpot虚拟机中含有两个即时编译器
     -- 编译耗时短但输出代码优化程度较低的客户端编译器（简称为C1）
     -- 编译耗时长但输出代码优化质量也更高的服务端编译器（简称为C2）
     -- 在分层编译机制下与解释器互相配合来共同构成HotSpot虚拟机的执行子系统

二、自动内存管理

2. Java内存区域与内存溢出异常

1- Java内存区域

1. JVM的内存模型可以说下吗？
   (说一下Java虚拟机内存区域划分、各区域的介绍、1.8&1.7版本迭代)

2. Java虚拟机内存的各个区域？
   Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干个不同的数据区域。（运行时数据区域，强调对内存空间的划分

   • 程序计数器（线程隔离
   • Java虚拟机栈（线程隔离
   • 本地方法栈（线程隔离
   • Java堆（线程共享
   • 方法区（线程共享
     
     -- 灰色：线程私有，几乎不存在垃圾回收
     -- 橘色：GC的作用区域需要有垃圾回收。
     JVM内存区域和Java内存模型
     https://www.cnblogs.com/czwbig/p/11127124.html (图、解释)
     https://jingyan.baidu.com/article/4f34706e623281e387b56d84.html

3. Java虚拟机内存的各个区域-分
   【1】程序计数器?

   • 空间较小
   • 线程私有，生命周期与线程相同;
   • 当前线程所执行的字节码的行号指示器;
   • 字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，是程序控制流的指示器;
   • 辅助完成分支、循环、跳转、异常处理、线程恢复等基础功能;
   • 线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器;
   • 线程Java方法，这个计数器记录的是正在执行的虚拟机字节码指令的地址，
     执行的是本地（Native）方法，这个计数器值则应为空（Undefined）
   • 唯一无OutOfMemoryError情况的
     【2】 Java虚拟机栈?
   • 线程私有，生命周期与线程相同，同程序计数器
   • 作用：
     描述的是Java方法执行的线程内存模型：每个方法被执行的时候，Java虚拟机都会同步创建一个栈帧用于存储数据。每一个方法被调用直至执行完毕的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。
   • 存储：
     栈帧（Stack Frame）存储：局部变量表、操作数栈、动态连接、方法出口等信息;
     局部变量表存储：
     ① 编译期可知的各种Java虚拟机基本数据类型（boolean、byte、char、short、int、float、long、double）;
     ② 对象引用（reference类型，它并不等同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是指向一个代表对象的句柄或者其他与此对象相关的位置）;
     ③ returnAddress类型（指向了一条字节码指令的地址）.
     局部变量表存储空间：
     局部变量表中的存储空间以局部变量槽（Slot）来表示，其中64位长度的long和double类型的数据会占用两个变量槽，其余的数据类型只占用一个
   • 异常：
     StackOverflowError异常：如果线程请求的栈深度大于虚拟机所允许的深度
     OutOfMemoryError异常：如果Java虚拟机栈容量可以动态扩展，当栈扩展时无法申请到足够的内存时
     【3】本地方法栈
   • 与虚拟机栈作用相似，
   • 与虚拟机栈区别：
     -- 虚拟机栈为虚拟机执行Java方法（也就是字节码）服务
     -- 本地方法栈则是为虚拟机使用到的本地（Native） 方法服务。
   • 异常：
     与虚拟机栈一样，本地方法栈也会在栈深度溢出或者栈扩展失败时分别抛出StackOverflowError和OutOfMemoryError异常。
     【4】Java堆（Java Heap）
   • 虚拟机所管理的内存中空间最大的，所有线程共享的一块内存区域，在虚拟机启动时创建；
   • 存储：对象实例（几乎所有；
   • 垃圾收集器管理的内存区域；
   • 分配内存的角度看，所有线程共享的Java堆中可以划分出多个线程私有的分配缓冲区 （TLAB），以提升对象分配时的效率；
   • Java堆可被实现成固定大小的或可扩展的，当前主流的Java虚拟机都是按照可扩展来实现的（通过参数-Xmx和-Xms设定）；
   • 异常：
     OutOfMemoryError异常：如果在Java堆中没有内存完成实例分配，且堆也无法再扩展时，Java虚拟机将会抛出OutOfMemoryError异常。
     【5】方法区（Method Area）
   • 堆的一个逻辑部分
   • 存储：已被虚拟机加载的类型信息、常量、静态变量、即时编译器编译后的代码缓存等数据。（字符串常量池？
   • 永久代概念：用永久代来实现方法区
   • JDK6，逐步改为采用本地内存（Native Memory）来实现方法区
   • JDK8，完全废弃永久代的概念，改用与JRockit、J9一样在本地内存中实现的元空间（Meta- space）来代替。
   • OutOfMemoryError异常：方法区无法满足新的内存分配需求时
     【5.1】方法区-运行时常量池（Runtime Constant Pool）
   • 方法区的一部分
   • 存储：编译期生成的各种字面量与符号引用、由符号引用翻译出来的直接引用
     -- Class文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息是常量池表，用于存放编译期生成的各种字面量与符号引用，这部分内容将在类加载后存放到方法区的运行时常量池中。
     -- 除了保存Class文件中描述的符号引用外，还会把由符号引用翻译出来 的直接引用也存储在运行时常量池中
   • 异常：
     和方法区一样受方法区内存的限制，当常量池无法再申请到内存时会抛出OutOfMemoryError异常。
     【6】直接内存
   • 非虚拟机运行时数据区的一部分以及非内存区域
   • 放这里的原因：这部分内存也被频繁地使用，也可能导致OutOfMemoryError异常
   • OutOfMemoryError异常:各个内存区域总和大于物理内存限制

4. 常量池、运行时常量池、字符串常量池中都存储的什么

   • ans：常量池 .class文件的一部分，字面量和符号引用 |运行时常量池 方法区 加载后的常量池数据 |字符串常量池 方法区 是一组指针指向堆中的String对象的内存地址
   • 常量池、运行时常量池、字符串常量池
   • 字符串常量池（一组指针指向Heap中的String对象的内存地址）
     ：为避免每次都创建相同的字符串对象及内存分配，JVM内部对字符串对象的创建的优化

5. 内存模型，堆和栈都有什么？
   （问法不够准确，此处只问内存模型，应该是JMM，后面又问到堆栈应该是想问JVM内存，先按照JVM的角度回答，持续关注...）

   • 经常有人把Java内存区域笼统地划分为堆内存（Heap）和栈内存（Stack），这种划分方式直接继承自传统的C、C++程序的内存布局结构，在Java语言里就显得有些粗糙了，实际的内存区域划分要比这更复杂。不过这种划分方式的流行也间接说明了程序员最关注的、与对象内存分配关系最密切的区域是“堆”和“栈”两块。其中，“堆”在稍后笔者会专门讲述，而“栈”通常就是指这里讲的虚拟机栈，或者更多的情况下只是指虚拟机栈中局部变量表部分。
   • 堆：对象实例；
   • 栈：局部变量表、操作数栈、动态连接、方法出口等信息（z-详细见上）

6. JVM堆内存划分
   (Java垃圾回收：

   • 永久代（方法区
   • 老年代（堆
   • 新生代（堆
     -Eden区
     -From Survivor
     -To Survivor
   • 无论是哪个区域，存储的都只能是对象的实例，将Java 堆细分的目的只是为了更好地回收内存，或者更快地分配内存。
     http://www.shaoqun.com/a/99944.html

2- 对象创建过程

1. new一个对象？ -jvm3

   • Java虚拟机遇到一条字节码new指令
   • 首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号引用，并且检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有，那必须先执行相应的类加载过程；
   • 在类加载检查通过后，接下来虚拟机将为新生对象分配内存。
     对象所需内存的大小在类加载完成后便可完全确定，为对象分配空间的任务实际上便等同于把一块确定大小的内存块从Java堆中划分出来。
   • 内存分配完成之后，虚拟机必须将分配到的内存空间（但不包括对象头）都初始化为零值，如果使用了TLAB的话，这一项工作也可以提前至TLAB分配时顺便进行。
   • 接下来，Java虚拟机还要对对象进行必要的设置
     -- 例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码（实际上对象的哈希码会延后到真正调用Object::hashCode()方法时才计算）、对象的GC分代年龄等信息。这些信息存放在对象的对象头（Object Header）之中。
     -- 根据虚拟机当前运行状态的不同，如是否启用偏向锁等，对象头会有不同的设置方式。
   • 虚拟机的视角，新的对象已经产生。
   • Java程序的视角，对象创建才刚刚开始。
     -- 构造函数，即Class文件中的()方法还没有执行，所有的字段都为默认的零值，对象需要的其他资源和状态信息也还没有按照预定的意图构造好。
     -- 一般来说（由字节码流中new指令后面是否跟随invokespecial指令所决定，Java编译器会在遇到new关键字的地方同时生成这两条字节码指令，但如果直接通过其他方式产生的则不一定如此），new指令之后会接着执行()方法，按照程序员的意愿对对象进行初始化，这样一个真正可用的对象才算完全被构造出来。

2. jvm怎么知道对象属于哪个类？

   • jvm3：对象头信息：用于存储对象自身的运行时数据，如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等，即“Mark Word”。、
     以及另外一部分是类型指针，即对象指向它的类型元数据的指针，Java虚拟机通过这个指针来确定该对象是哪个类的实例。
   • 推断：由对象头的类型指针获取。

3- OOM

|OutOfMemoryError异常-内存溢出异常|

1. 堆溢出？

   • 概念：
     Java堆用于存储对象实例，只要不断地创建对象，并且保证GC Roots到对象之间有可达到路径来避免垃圾回收机制清除这些对象，那么在对象数量达到最大堆的容量限制后就会产生内存溢出异
   • 原因：
     大量对象占据了堆空间，而这些对象都持有强引用，导致无法回收，当对象大小之和大于由-Xmx参数指定的堆空间大小时，溢出错误就自然而然地发生了。（jvms）
   • 例子:
     ① 内存中加载的数据量过于庞大，如一次从数据库取出过多数
     ② 集合类中有对对象的引用，使用完后未清空，使得JVM不能回
     ③ 代码中存在死循环或循环产生过多重复的对象实体；

2. 栈溢出？ （HotSpot-虚拟机栈和本地方法栈）

   • 概念：在《Java虚拟机规范》中描述了两种异常：
     1）如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出StackOverflowError异常。
     2）如果虚拟机的栈内存允许动态扩展，当扩展栈容量无法申请到足够的内存时，将抛出 OutOfMemoryError异常。
   • 原因：
     HotSpot虚拟机不支持扩展支持栈的动态扩展，只会在创建线程申请内存时就因无法获得足够内存而出现OutOfMemoryError异常，也只会因为栈容量无法容纳新的栈帧而导致StackOverflowError异常。（jvm3）
   • 当线程请求的栈深度超过虚拟机允许的栈深度时，便会抛出StackOverFlowError
     -- -Xss设置的参数是针对每一个栈的，而非JVM所有线程栈内存总大小。
     -- 每个方法的调用将创建一个栈帧。每一个方法调用时，都会创建一个栈帧，用于存储局部变量表、操作数栈、动态链接、方法出口等信息。
     -- SUM(每个栈帧大小)>栈大小发生栈溢出

3. 调整栈内存jvm参数知道吗？常用的jvm参数有那些？

   • 栈的参数配置

   指令	作用
   -Xss	指定线程的栈大小。栈是每个线程私有的内存空间。

4. 递归10w次会出现什么？（OOM）

   • 问题：栈溢出
   • 原因：
     -- 栈先进后出，方法压栈运行，递归过程先入的不能出栈，会存在栈空间中，这样就容易导致栈满而溢出。
     -- 线程内部的每个方法调用会创建一个栈帧，所以如果“栈帧的数量*每个栈帧的大小>栈大小”时便会发生“栈溢出”。
     -- 每当你调用一个方法，在这个方法执行前都会将之前的内存地址（也就是调用点）入栈，等被调用的方法执行完将地址出栈，程序根据这个数据返回调用点。
     若递归调用次数太多，就会只入栈不出栈，于是堆栈就被压爆了，此为栈溢出。
     递归函数调用的太深，需要太多的内存，递归里用到的局部变量存储在堆栈中，堆栈的访问效率高，速度快，但空间有限，递归太多变量需要一直入栈而不出栈，导致需要的内存空间大于堆栈的空间。
   • 解决：可以考虑采取循环的方式来解决，将需要的数据在关键的调用点保存下来使用。即用自己的数据保存方法来代替系统递归调用产生的栈数据。
   • 注：操作系统分配给一个进程的栈空间是2M，堆空间在32位机器上是4G。如果进程的栈空间使用超过了2M就会栈溢出，堆使用超过4G就会堆溢出。

5. 栈溢出异常，通过什么方式来解决？

   • HotSpot虚拟机不支持扩展支持栈的动态扩展
   • 解决
     -- 1）代码层面
     将递归改为循环或保存数据（降低层次，或变量设为全局变量，这样它会被存在堆里（或其它地方））
     -- 2）线上临时解决办法或者1）无法解决
     重新调整JVM参数-Xss，重启应用
     如-Xss将thread stack size变为2m
   • 如何设置
     -- 首先，操作系统分配给每个进程的内存是有限制的。那么：
     可用的栈内存=进程最大内存-堆内存-方法区内存-程序计数器内存-虚拟机本身耗费内存
     -- 而栈是线程私有的，那么可以认为：
     程序可建立的线程数量=可用栈内存/栈大小
     -- 这样当栈大小设置太大时，就会导致创建的线程数量太少。这样在多线程的情况下便可能发生“内存溢出”情况。
     -- 在x64位Linux操作系统上，JVM默认的栈大小为1024kb。
     由于我们线上的程序要支持高并发场景，所以栈的大小设置为256kb，这里仅供参考。

6. 怎么让方法区溢出?

   • “永久代(Perm)”（jdk1.6/1.7），“元空间(meta-space)”(jdk1.8)用来实现方法区

   • jvms:一个系统不断产生新的类，而没有回收，最终可能导致永久区溢出。

     // jdk1.6 -XX:MaxPermSize=5m
     public class PermOOM{
        public static void main(String[] args) {
            try {
                for (int i = 0; i <100000 ; i++) {
                // 每次循环都生成一个新的类（是类，而非对象实例）
                    CglibBean bean = new CglibBean("geym.jvm.ch3.perm.bean"+i,new HashMap());
                }
            }catch (Error e){
                e.printStackTrace();
            }
        }
     }
     // 结果
     // Exception in thread "main" java.lang.OutOfMemoryError: PermGen space 

   • 解决永久区溢出，从以下几个方面考虑（jvms）
     -- 增加MaxPermSize的值
     -- 减少系统需要的类的数量
     -- 使用ClassLoader合理地装载各个类，并定期进行回收

7. 遇到过的OOM？

   • 不断创建对象可以导致堆溢出 - 堆
   • 递归调用可以导致栈溢出 - 栈
   • 堆
     
   • 栈
     递归|单线程|多线程

8. OOM 如何排查以及优化/OOM问题怎么定位（线上？） -P50
   常规的处理方法（jvm3）

   • 首先通过内存映像分析工具对Dump出来的堆转储快照进行分析。
     第一步首先应确认内存中导致OOM的对象是否是必要的，也就是要先分清楚到底是出现了内存泄漏（Memory Leak）还是内存溢出（Memory Overflow）。
   • 如果是内存泄漏，可进一步通过工具查看泄漏对象到GC Roots的引用链，找到泄漏对象是通过怎样的引用路径、与哪些GC Roots相关联，才导致垃圾收集器无法回收它们，根据泄漏对象的类型信息以及它到GC Roots引用链的信息，一般可以比较准确地定位到这些对象创建的位置，进而找出产生内存泄漏的代码的具体位置。
   • 如果不是内存泄漏，换句话说就是内存中的对象确实都是必须存活的，那就应当检查Java虚拟机的堆参数（-Xmx与-Xms）设置，与机器的内存对比，看看是否还有向上调整的空间。再从代码上检查是否存在某些对象生命周期过长、持有状态时间过长、存储结构设计不合理等情况，尽量减少程序运行期的内存消耗。
   • 排查流程
     
   • 流程：https://www.cnblogs.com/c-xiaohai/p/12489336.html
     https://blog.csdn.net/ywlmsm1224811/article/details/91866707
     https://blog.csdn.net/wx1528159409/article/details/93530352#%E6%8E%92%E6%9F%A5%EF%BC%9A
     2）优化：
   • 使用更小的图片
   • StringBuilder来替代频繁的“+”
     https://blog.csdn.net/weixin_41101173/article/details/79716332

9. Java会不会内存泄露？怎样会泄露？

   • 内存泄漏（Memory Leak）
   • https://blog.51cto.com/12142907/2343854
   • https://blog.csdn.net/duoduo18up/article/details/81545958

10. Java 内存泄漏问题，解释一下什么情况下会出现？

    • Java使用的内存种类包含三种，这三种类型的内存都可能发生内存泄漏。
      • 堆内存泄漏，如果JVM 不能在java 堆中获得更多内存来分配更多java 对象，将会抛出java堆内存不足(java OOM) 错误。如果java 堆充满了活动对象，并且JVM 无法再扩展java 堆，那么它将不能分配更多java 对象。更多情况是程序设计有问题，生成的对象占用过多的堆内存造成堆内存泄漏。
      • 本地内存泄漏, 如果JVM 无法获得更多本地内存，它将抛出本地OOM错误。当进程用到的内存到达操作系统的最大限值，或者当计算机用完RAM 和交换空间时，通常会发生这种情况。当发生这种情况时，JVM处于本地内存OOM状态，此时虚拟机会打印相关信息并退出。本地内存泄漏根本原因是Java调用本地库或方法，这些本地库中的API有内存泄漏。
      • 加载类(字节码)的Perm内存不足.即指定的Permsize不足以加载系统运行使用的.class字节码文件，就发发生Perm内存不足的错误。

3. 垃圾回收

1. 垃圾回收，堆区为什么那么分

   • 不过无论从什么角度，无论如何划分，都不会改变Java堆中存储内容的共性，无论是哪个区域，存储的都只能是对象的实例，将Java堆细分的目的只是为了更好地回收内存，或者更快地分配内存。（jvm3）

2. Java垃圾回收简单讲一下，里面的算法？

   • 判断对象？标记算法？回收算法？收集器？

1-判断对象死亡

1. JVM 垃圾回收的是如何确定垃圾？

   • 什么是垃圾
     简单的说就是内存中已经不再被使用到的空间就是垃圾。
     

     Person p = null;

2. java垃圾回收，如何判断一个对象需要回收

   • 引用计数算法
   • 可达性分析算法
     具体：https://blog.csdn.net/weixin_38569499/article/details/85645517

3. 引用计数算法 和 可达性分析算法

   • 引用计数算法
     在对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加一；
     当引用失效时，计数器值就减一；任何时刻计数器为零的对象就是不可能再被使用的
   • 优点
     会占用了一些额外的内存空间来进行计数，原理简单，判定效率也很高，在大多数情况下它都是一个不错的算法。

   • 缺点
     必须要配合大量额外处理才能保证正确地工作，如单纯的引用计数就很难解决对象之间相互循环引用的问题。

     Object a = new Object();
     Object b = new Object();
     a=b;
     b=a;
     a=b=null; //这样就导致gc无法回收他们。

   • 可达性分析算法
     通过一系列称为“GC Roots”的根对象作为起始节点集，从这些节点开始，根据引用关系向下搜索，搜索过程所走过的路径称为“引用链”（Reference Chain），如果某个对象到GC Roots间没有任何引用链相连，或者用图论的话来说就是从GC Roots到这个对象不可达时，则证明此对象是不可能再被使用的。
     缺点：实现比较复杂、需要分析大量数据，消耗大量时间、分析过程需要GC停顿（引用关系不能发生变化），即停顿所有Java执行线程（称为"Stop The World"，是垃圾回收重点关注的问题）。

4. 是否知道什么是GC Roots？（jvm3）

   • 固定可作为GC Roots的对象：
     -- 在虚拟机栈（栈帧中的本地变量表）中引用的对象，譬如各个线程被调用的方法堆栈中使用到的参数、局部变量、临时变量等。
     -- 在方法区中类静态属性引用的对象，譬如Java类的引用类型静态变量。
     -- 在方法区中常量引用的对象，譬如字符串常量池（String Table）里的引用。
     -- 在本地方法栈中JNI（即通常所说的Native方法）引用的对象。
     -- Java虚拟机内部的引用，如基本数据类型对应的Class对象，一些常驻的异常对象（比如NullPointExcepiton、OutOfMemoryError）等，还有系统类加载器。
     -- 所有被同步锁（synchronized关键字）持有的对象。
     -- 反映Java虚拟机内部情况的JMXBean、JVMTI中注册的回调、本地代码缓存等。
   • 临时GC Roots
     -- 根据用户所选用的垃圾收集器以及当前回收的内存区域不 同，还可以有其他对象“临时性”地加入，共同构成完整GC Roots集合。
     -- 如后文将会提到的分代收集和局部回收（Partial GC），如果只针对Java堆中某一块区域发起垃圾收集时（如最典型的只针对新生代的垃圾收集），必须考虑到内存区域是虚拟机自己的实现细节（在用户视角里任何内存区域都是不 可见的），更不是孤立封闭的，所以某个区域里的对象完全有可能被位于堆中其他区域的对象所引用，这时候就需要将这些关联区域的对象也一并加入GCRoots集合中去，才能保证可达性分析的正确性。

5. 哪些对象可以作为gcroot（jvm2）

   • 1）虚拟机栈（栈帧中的本地变量表）中引用的对象
   • 2）方法区中类静态属性引用的对象
   • 3）方法区中常量引用的对象
   • 4）本地方法栈中JNI（即Native方法）引用的对象
     

     public class GCRootDemo{
         private static GCRootDemo2 t2;//第2种，static静态，一份全部实例变量共用？被加载进方法区，
                                       // Java7方法区为永久代；GCRootDemo2其他对象
         private static final GCRootDemo3 t3 = new GCRootDemo3(8);//static final常量引用
         public static void m1(){
             GCRootDemo t1 = new GCRootDemo();//第1种：m1方法在栈中，t1为方法中的局部变量
             System.gc();
             System.out.println("第一次GC完成");
         }
         public static void main(String[] args) {
             m1();
         }
     }

6. 引用？

   • ~
     强引用：只有强引用还存在，GC就永远不会收集被引用的对象。
     软引用：不占空间，gc不回收
     弱引用：WeakReference 调用gc直接回收 ★
     虚引用：PhantomReference 与队列结合使用，get不到
   • 强引用：最传统的“引用”的定义，是指在程序代码之中普遍存在的引用赋值，即类似“Object obj=new Object()”这种引用关系。无论任何情况下，只要强引用关系还存在，垃圾收集器就永远不会回收掉被引用的对象。
   • 软引用：用来描述一些还有用，但非必须的对象。只被软引用关联着的对象，在系统将要发生内存溢出异常前，会把这些对象列进回收范围之中进行第二次回收，如果这次回收还没有足够的内存，才会抛出内存溢出异常。在JDK1.2版之后提供了SoftReference类来实现软引用。
   • 弱引用：也是用来描述那些非必须对象，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生为止。当垃圾收集器开始工作，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。在JDK1.2版之后提供了WeakReference类来实现弱引用。
   • 虚引用：也称为“幽灵引用”或者“幻影引用”，是最弱的一种引用关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的只是为了能在这个对象被收集器回收时收到一个系统通知。在JDK1.2版之后提供 了PhantomReference类来实现虚引用。

7. 判断一个对象生存还是死亡？

   • 第一次标记
     　　如果对象进行可达性分析算法之后没发现与GC Roots相连的引用链，那它将会第一次标记并且进行一次筛选。
     　　筛选条件：判断此对象是否有必要执行finalize()方法。
     　　筛选结果：当对象没有覆盖finalize()方法、或者finalize()方法已经被JVM执行过，则判定为可回收对象。如果对象有必要执行finalize()方法，则被放入F-Queue队列中。稍后在JVM自动建立、低优先级的Finalizer线程（可能多个线程）中触发这个方法；
   • 第二次标记
     　　GC对F-Queue队列中的对象进行二次标记。
     　　如果对象在finalize()方法中重新与引用链上的任何一个对象建立了关联，那么二次标记时则会将它移出“即将回收”集合。如果此时对象还没成功逃脱，那么只能被回收了。
   • finalize() 方法
     　　finalize()是Object类的一个方法、一个对象的finalize()方法只会被系统自动调用一次，经过finalize()方法逃脱死亡的对象，第二次不会再调用；
     https://www.cnblogs.com/chenpt/p/9797126.html

2-垃圾收集算法

4.jvm卡表（Card Table）？
安全区域（Safe Region），记忆集

1. 垃圾回收算法有哪些

   • 标记-清除
   • 复制
   • 标记-整理
   • 分代收集算法

2. 垃圾回收算法，为什么老年代和新生代不同

   • 存活周期不同
     1）弱分代假说（Weak Generational Hypothesis）：绝大多数对象都是朝生夕灭的。 2）强分代假说（Strong Generational Hypothesis）：熬过越多次垃圾收集过程的对象就越难以消亡。

3. 垃圾收集算法新生代和老年代分别用什么算法

   • 回收新生代：大多使用复制算法
   • 回收老年代：使用“标记-清理”或“标记-整理”算法

4. 如果对象大部分都是存活的，少部分需要清除，用什么算法

   • 新生代中，每次垃圾收集时都发现有大批对象死去，只有少量存活，那就选用复制算法，只需要付出少量存活对象的复制成本就可以完成收集。
   • 老年代中，因为对象存活率高、没有额外空间对它进行分配担保，就必须使用“标记-清理”或“标记-整理”算法来进行回收。

5. 名词概念

   • 部分收集（Partial GC）：指目标不是完整收集整个Java堆的垃圾收集，又分为：
     ■ 新生代收集（Minor GC/Young GC）：指目标只是新生代的垃圾收集。
     ■ 老年代收集（Major GC/Old GC）：指目标只是老年代的垃圾收集。目前只有CMS收集器会有单独收集老年代的行为。另外请注意“Major GC”这个说法现在有点混淆，在不同资料上常有不同所指， 读者需按上下文区分到底是指老年代的收集还是整堆收集。
     ■ 混合收集（Mixed GC）：指目标是收集整个新生代以及部分老年代的垃圾收集。目前只有G1收集器会有这种行为。
   • 整堆收集（Full GC）：收集整个Java堆和方法区的垃圾收集。

6. 说说GC的流程

   • 流程看图：https://www.cnblogs.com/shuiyj/p/12640692.html

7. 什么时候对象会到老年代，老年代的更新机制
   

   • 分配
     默认的，Edem : from : to = 8 : 1 : 1 ( 可以通过参数 –XX:SurvivorRatio 来设定 )
   • 过程
     当对象在 Eden 出生后，在经过一次 Minor GC 后，如果对象还存活，并且能够被另外一块 Survivor 区域所容纳( 上面已经假设为 from 区域，这里应为 to 区域，即 to 区域有足够的内存空间来存储 Eden 和 from 区域中存活的对象 )，则使用复制算法将这些仍然还存活的对象复制到另外一块 Survivor 区域 ( 即 to 区域 ) 中，然后清理所使用过的 Eden 以及 Survivor 区域 ( 即 from 区域 )，并且将这些对象的年龄设置为1，以后对象在 Survivor 区每熬过一次 Minor GC，就将对象的年龄 + 1，当对象的年龄达到某个值时 ( 默认是 15 岁，可以通过参数 -XX:MaxTenuringThreshold 来设定 )，这些对象就会成为老年代。
     但这也不是一定的，对于一些较大的对象 ( 即需要分配一块较大的连续内存空间 ) 则是直接进入到老年代。
   • JVM 每次只会使用 Eden 和其中的一块 Survivor 区域来为对象服务，所以无论什么时候，总是有一块 Survivor 区域是空闲着的。 如此往复
     http://www.shaoqun.com/a/99944.html
     https://blog.csdn.net/yangyang12345555/article/details/79257171

3-回收器

1. 垃圾回收器了解吗？

   • 是什么？有哪些？做什么？

2. 为何需要垃圾回收？

   • Java垃圾收集机制为避免出现内存溢出异常。

3. 有哪些gc收集器?

   • 7个回收器
     新生代收集器：Serial、ParNew、Parallel Scavenge
     老年代收集器：CMS、Serial Old、Parallel Old
     整堆收集器： G1
     https://www.cnblogs.com/chenpt/p/9803298.html
     易懂：https://blog.csdn.net/weixin_43228814/article/details/88934939
     https://blog.csdn.net/qq_35246620/article/details/80522720

4. 垃圾回收器在哪块?

   • Java堆
   • 收集器应该将Java堆划分出不同的区域，然后将回收对象依据其年龄（年龄即对象熬过垃圾收集过程的次数）分配到不同的区域之中存储。
   • 在JVM体系结构中，与垃圾回收相关的两个主要组件是堆内存和垃圾回收器。堆内存是内存数据区，用来保存运行时的对象实例。垃圾回收器也会在这里操作。

5. 垃圾回收器（CMS)详细过程。哪个阶段出现STW？

   • 运作过程的四个步骤？
     1）初始标记（CMS initial mark）
     2）并发标记（CMS concurrent mark）
     3）重新标记（CMS remark）
     4）并发清除（CMS concurrent sweep）
   • 初始标记、重新标记：这两个步骤仍然需要“Stop The World”。
   • 初始标记：仅仅只是标记一下GC Roots能直接关联到的对象，速度很快；
   • 并发标记阶段：就是从GC Roots的直接关联对象开始遍历整个对象图的过程，这个过程耗时较长但是不需要停顿用户线程，可以与垃圾收集线程一起并发运行；
   • 重新标记阶段：为修正并发标记期间，因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间通常会比初始标记阶段稍长一些，但也远比并发标记阶段的时间短；
   • 并发清除阶段：清理删除掉标记阶段判断的已经死亡的对象，由于不需要移动存活对象，所以这个阶段也是可以与用户线程同时并发的。
     

6. 垃圾收集器CMS出现问题了怎么办？

   • 1）promotion failed – concurrent mode failure
     Minor GC后， 救助空间容纳不了剩余对象，将要放入老年带，老年带有碎片或者不能容纳这些对象，就产生了concurrent mode failure, 然后进行stop-the-world的Serial Old收集器。
     -- 解决办法：-XX:UseCMSCompactAtFullCollection -XX:CMSFullGCBeforeCompaction=5 或者调大新生代或者救助空间
   • 2）concurrent mode failure
     CMS是和业务线程并发运行的，在执行CMS的过程中有业务对象需要在老年带直接分配，例如大对象，但是老年带没有足够的空间来分配，所以导致concurrent mode failure, 然后需要进行stop-the-world的Serial Old收集器。
     -- 解决办法：+XX:CMSInitiatingOccupancyFraction，调大老年带的空间，+XX:CMSMaxAbortablePrecleanTime
   • 总结一句话：使用标记整理清除碎片和提早进行CMS操作。
   • 两个问题：promotion failed和concurrent mode failure
   • 解决：
     第一个，可以让CMS在进行一定次数的Full GC的时候进行一次标记整理算法。
     第二个，调低触发CMS GC执行的阀值。
     https://my.oschina.net/hosee/blog/674181

4-内存分配与回收策略

1. java内存管理？

   • Java技术体系的自动内存管理，最根本的目标是自动化地解决两个问题
     自动给对象分配内存以及自动回收分配给对象的内存。

2. 什么时候对象会到老年代，老年代的更新机制？

   • 大对象直接进入老年代
     -- 大对象就是指需要大量连续内存空间的Java对象，最典型的大对象便是那种很长的字符串，或者元素数量很庞大的数组
     -- 避免大对象的原因：
     在分配空间时，容易导致内存明明还有不少空间时就提前触发垃圾收集，以获取足够的连续空间才能安置好它们，而当复 制对象时，大对象就意味着高额的内存复制开销。
     -- HotSpot中-XX：PretenureSizeThreshold
     指定大于该设置值的对象直接在老年代分配，避免在Eden区及两个Survivor区之间来回复制，产生大量的内存复制操作。
   • 长期存活的对象将进入老年代
     -- 虚拟机给每个对象定义了一个对 象年龄（Age）计数器，存储在对象头中。
     -- 对象通常在Eden区里诞生，如果经过第一次 Minor GC后仍然存活，并且能被Survivor容纳的话，该对象会被移动到Survivor空间中，并且将其对象年龄设为1岁。对象在Survivor区中每熬过一次Minor GC，年龄就增加1岁，当它的年龄增加到一定程度（默认为15），就会被晋升到老年代中。
     -- -XX： MaxTenuringThreshold设置：对象晋升老年代的年龄阈值。
   • 动态对象年龄判定
     -- HotSpot虚拟机并不是永远要求对象的年龄必须达到-XX：MaxTenuringThreshold才能晋升老年代，如果在Survivor空间中相同年龄所有对象大小的总和大于Survivor空间的一半，年龄大于或等于该年龄的对象就可以直接进入老年代，无须等到-XX：MaxTenuringThreshold中要求的年龄。
     -- -XX：MaxTenuringThreshold=15
     -- 同年龄的，满足同年对象达到Survivor空间一半的规则

3. 操作系统层面是怎么分配内存的 91
   https://blog.csdn.net/qq_32635069/article/details/74838187

4. 监控、故障处理工具

1-jstack（（Stack Trace for Java））

1. jstack原理
   1）jstack定义-P111
   
   • jstack用于生成java虚拟机当前时刻的线程快照
   • 线程快照是当前java虚拟机内每一条线程正在执行的方法堆栈的集合，
   • 生成线程快照的主要目的是定位线程出现长时间停顿的原因，如线程间死锁、死循环、请求外部资源导致的长时间等待等。
   • 线程出现停顿的时候通过jstack来查看各个线程的调用堆栈，就可以知道没有响应的线程到底在后台做什么事情，或者等待什么资源。
     2）实现 -P110 ！！！
     JDK 1.5中，java.lang.Thread类新增了一个getAllStackTraces()方法用于获取虚拟机中所有线程的StackTraceElement对象。使用这个方法可以通过简单的几行代码就完成jstack的大部分功能，在实际项目中不妨调用这个方法做个管理员页面，可以随时使用浏览器来查看线程堆栈。
     3）使用
     jstack [ option ] pid 如，jstack -l 3500
     -l 长列表. 打印关于锁的附加信息。
     4）jsp（JVM Process Status Tool）
     可以列出正在进行的虚拟机进程，并显示虚拟机执行主类名称以及这些进程的本地虚拟机进程唯一ID（LVMID）---对应3）的pid
     如，jsp -l

三、虚拟机执行子系统

6. .class文件

7. 虚拟机类加载机制

1. java虚拟机类加载机制？
   
   • jvm3：Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。

1-时机

1. 类加载的顺序？

   • 一个类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期将会经历加载（Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（Using）和卸载（Unloading）七个阶段；
   • 其中，验证、准备、解析三个部分统称为连接（Linking）。
   • 加载、验证、准备、初始化和卸载这五个阶段的顺序是确定的，类的加载过程必须按照这种顺序按部就班地开始；
   • 解析阶段：在某些情况下可以在初始化阶段之后再开始，这是为了支持Java语言的运行时绑定特性（也称为动态绑定或晚期绑定）。
   • “开始”强调这些阶段通常都是互相交叉地混合进行的，会在一个阶段执行的过程中调用、激活另一个阶段。
   • 七个阶段的发生顺序如图：
     

2. 有哪些操作会触发类加载？

   • 《Java虚拟机规范》中并没有对在什么情况下需要开始类加载过程的第一个阶段“加载”进行强制约束。但对于初始化阶段，则严格规定了有且只有六种情况必须立即对类进行“初始化”（而加载、验证、准备自然需要在此之前开始）：
   • 对一个类型进行主动引用,“有且只有”这六种场景中的行为称为。除此之外的所有引用类型的方式都不会触发初始化，称为被动引用；
   • 【主动引用】
     1）遇到new、getstatic、putstatic或invokestatic这四条字节码指令时，如果类型没有进行过初始化，则需要先触发其初始化阶段。能够生成这四条指令的典型Java代码场景有：
     -- 使用new关键字实例化对象的时候。
     -- 读取或设置一个类型的静态字段（被final修饰、已在编译期把结果放入常量池的静态字段除外）的时候。
     -- 调用一个类型的静态方法的时候。
     2）使用java.lang.reflect包的方法对类型进行反射调用的时候，如果类型没有进行过初始化，则需要先触发其初始化。
     3）当初始化类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
     4）当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。
     5）当使用JDK 7新加入的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果为REF_getStatic、REF_putStatic、REF_invokeStatic、REF_newInvokeSpecial四种类型的方法句柄，并且这个方法句柄对应的类没有进行过初始化，则需要先触发其初始化。
     6）当一个接口中定义了JDK8新加入的默认方法（被default关键字修饰的接口方法）时，如果有这个接口的实现类发生了初始化，那该接口要在其之前被初始化。
   • 【被动引用】
     1）通过子类引用父类的静态字段，不会导致子类初始化
     2）通过数组定义来引用类，不会触发此类的初始化
     3）常量在编译阶段会存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此不会触发定义常量的 类的初始化
   • 图示：https://blog.csdn.net/L_Mr_l/article/details/81909995

2-过程

1. 类加载过程？

   • 概念：
     Java虚拟机中类加载的全过程，即加载、验证、准备、解析和初始化这五 个阶段所执行的具体动作。
   • 1）加载
     加载阶段，Java虚拟机需要完成以下三件事情：
     ① 通过一个类的全限定名来获取定义此类的二进制字节流。
     ② 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
     ③ 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。
   • 2）验证
     验证是连接阶段的第一步，这一阶段的目的是确保Class文件的字节流中包含的信息符合《Java虚拟机规范》的全部约束要求，保证这些信息被当作代码运行后不会危害虚拟机自身的安全。
     ① 文件格式验证
     ② 元数据验证
     ③ 字节码验证
     ④ 符号引用验证
   • 3）准备
     准备阶段是正式为类中定义的变量（即静态变量，被static修饰的变量）分配内存并设置类变量初始值的阶段。
     这些变量所使用的内存都应当在方法区中进行分配，但必须注意到方法区 本身是一个逻辑上的区域，在JDK7及之前，HotSpot使用永久代来实现方法区时，实现是完全符合这种逻辑概念的；而在JDK8及之后，类变量则会随着Class对象一起存放在Java堆中，这时候“类变量在方法区”就完全是一种对逻辑概念的表述了。
   • 4）解析
     Java虚拟机将常量池内的符号引用替换为直接引用的过程。
     -- 符号引用（Symbolic References）：
     符号引用以一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可。
     -- 直接引用（Direct References）：
     直接引用是可以直接指向目标的指针、相对偏移量或者是一个能间接定位到目标的句柄。
     ① 类或接口的解析
     ② 字段解析
     ② 方法解析
     ③ 接口方法解析
   • 5）初始化
     初始化阶段就是执行类构造器()方法的过程。

2. 详细说说类加载的过程，静态代码块执行在哪个阶段？
   静态代码块在初始化阶段执行
   https://blog.csdn.net/qq_36839438/article/details/106738514
   https://blog.csdn.net/qq_38159458/article/details/105865964

3-类加载器

1. 类加载器的4个种类
   1）启动类加载器：这个类加载器负责放在$<JAVA_HOME>\lib$目录中的，或者被-Xbootclasspath参数所指定的路径中的，并且是虚拟机识别的类库。用户无法直接使用。
   2）扩展类加载器：这个类加载器由$sun.misc.Launcher$AppClassLoader$实现。它负责$\lib\ext$目录中的，或者被java.ext.dirs系统变量所指定的路径中的所有类库。用户可以直接使用。 3）应用程序类加载器：这个类$由sun.misc.Launcher$AppClassLoader$实现。是ClassLoader中getSystemClassLoader()方法的返回值。它负责用户路径（ClassPath）所指定的类库。用户可以直接使用。如果用户没有自己定义类加载器，默认使用这个。
   4）自定义加载器：用户自己定义的类加载器。

2. 双亲委派模型
   双亲委派模型:

   • 定义：上述4种展示的类加载之间的层次关系称为xxx。
   • 优点：Java类随着它的类加载器一起具备了一种带有优先级的层次关系。
   • 双亲委托模型的工作过程是：如果一个类加载器（ClassLoader）收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委托给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中，只有当父类加载器反馈自己无法完成这个加载请求（它的搜索范围中没有找到所需要加载的类）时，子加载器才会尝试自己去加载。
     https://blog.csdn.net/qq_35758236/article/details/81115320

3. 为啥要双亲加载

   • 使用双亲委托机制的好处是：能够有效确保一个类的全局唯一性，当程序中出现多个限定名相同的类时，类加载器在执行加载时，始终只会加载其中的某一个类。

4. 双亲委派机制，怎么打破
   tomcat

四、程序编译与代码优化

1. 说一说为什么要有JIT
   JIT是经过一系列的分析和热点代码探测技术,对一部分class字节码编译成机器语言，以此提高性能，而解释器就是执行一句class字节码，就翻译成一句机器语言。JIT的存在，减少对热点代码的重复翻译。
   https://www.jianshu.com/p/ae0d47e770f0
   https://www.cnblogs.com/xuyatao/p/6914769.html

1. JVM堆上会不会产生线程安全问题 pP48

   • 对象的内存分配过程中，主要是对象的引用指向这个内存区域，然后进行初始化操作。Java堆确定出一块内存区域，用于给新建对象分配内存。
   • 在并发场景中，如果两个线程先后把对象引用指向了同一个内存区域，如何内存分配过程的线程安全性？
   • 一般有两种解决方案：
     1、对分配内存空间的动作做同步处理，采用CAS机制，配合失败重试的方式保证更新操作的原子性。
     2、每个线程在Java堆中预先分配一小块内存，然后再给对象分配内存的时候，直接在自己这块"私有"内存中分配，当这部分区域用完之后，再分配新的"私有"内存。
     方案1在每次分配时都需要进行同步控制，这种是比较低效的。
     方案2是HotSpot虚拟机中采用的，这种方案被称之为TLAB分配，即Thread Local Allocation Buffer。这部分Buffer是从堆中划分出来的，但是是本地线程独享的。
     TLAB时线程独享的，但是只是在“分配”这个动作上是线程独占的，至于在读取、垃圾回收等动作上都是线程共享的。
     https://juejin.im/post/5d4250def265da03ab422c79

2. 那比如你在项目里写了一个Class A，然后在某一个jar包里也有一个Class A,比如com.a.A，那么这两个class你觉得哪个先被加载，会出现什么问题（不会，求了答案，告诉我说他也不清楚，就是考考我对这块有没有自己的理解😑）

3. 字节码是什么?
   字节码：Java程序无须重新编译便可在多种不同的计算机上运行。
   字节码（Byte-code）是一种包含执行程序，由一序列 op 代码/数据对组成的二进制文件，是一种中间码。 javap -c

※ 3-并发编程 ※

|并发笔记|javaGuide|javaGuide|

一、预备知识

1. 一个进程是怎么跑起来的？

   • 程序如何运行：程序（源文件）在硬盘上，需要把程序加载进内存，然后由CPU去执行相应的指令去操作寄存器中的数据（从内存中装载进来），比如加减乘除什么的。
   • 写->硬盘；运行->内存；指令操作->cpu寄存器

2. 操作系统进程间通信(IPC)？

   • 共享内存是最快的IPC方式
   • 进程间通信(Java和os有区别)：
     ① 消息队列(MessageQueue)
     ② 共享内存(SharedMemory) :实现
     ③ 信号量(Semphore)
     ④ 套接字(Socket)
     ⑤ 管道(PIPE)
     ⑥ 命名管道(FIFO)

3. 进程间数据共享吗，为什么

   • 为什么：多个进程同时修改数据共享的那个数据时，会出现数据不安全性，解决办法是加锁；
   • 实现：
     -- ① multiprocessing.Manager模块、② multiprocessing.Queue（代码启动的进程子进程之间）、
     -- 跨电脑、跨代码的进程间通信：
     ③ 消息中间件：kafak（大数据的消息中间件）、rebbitmq、memcache

4. 线程进程(协程)区别？ |3 结合具体的操作系统windows/mac/linux？

   • jg:从JVM的角度来说一下线程和进程之间的关系，下图:
     一个进程中可以有多个线程，多个线程共享进程的堆和方法区 (JDK1.8 之后的元空间)资源，但是每个线程有自己的程序计数器、虚拟机栈 和本地方法栈。
   • 总结：
     -- 线程是进程划分成的更小的运行单位,一个进程在其执行的过程中可以产生多个线程。
     -- 线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。
     -- 线程执行开销小，但不利于资源的管理和保护；而进程正相反。
     

5. 缓存一致性问题？

   • 假设有两个线程（线程 1 和线程 2）分别执行下面的方法，x 是共享变量：

     public class Example {
          int x = 0;
          public void count() {
              x++; //1
              System.out.println(x)//2
              }
     }

   • 多核CPU：
     如果是多核CPU运行多线程，每个核都有一个L1缓存，如果多个线程运行在不同的内核上访问共享变量时，每个内核的 L1 缓存将会缓存一份共享变量。
     

   • 1,1 的运行结果：
     

6. 有没有了解过缓存一致性协议，CPU-Cache角度？

   • 解决缓存不一致问题
   • 是一种广泛使用的支持写回策略的缓存一致性协议，该协议被应用在Intel奔腾系列的CPU中；
     -- MESI分别代表缓存行数据所处的四种状态，通过对这四种状态的切换，来达到对缓存数据进行管理的目的。

7. 什么是强一致性?
   结合Happens-before规则，可以将一致性分为以下几个级别：

   • 严格一致性（强一致性）：所有的读写操作都按照全局时钟下的顺序执行，且任何时刻线程读取到的缓存数据都是一样的，Hashtable 就是严格一致性；
     
   • 顺序一致性：多个线程的整体执行可能是无序的，但对于单个线程而言执行是有序的，要保证任何一次读都能读到最近一次写入的数据，volatile可以阻止指令重排序，所以修饰的变量的程序属于顺序一致性；
     
   • 弱一致性：不能保证任何一次读都能读到最近一次写入的数据，但能保证最终可以读到写入的数据，单个写锁+无锁读，就是弱一致性的一种实现。

二、并发理论基础

1. 线程安全

1. Java并发中会遇到那些问题？

   • ans：安全、活跃、性能
   • 1-安全性：
     -- 问题：会出现原子性问题、可见性问题和有序性问题线程不安全问题。
     -- 有多个线程会同时读写同一数据，需要一一考虑原子性问题、可见性问题和有序性问题
     -- 数据竞争：当多个线程同时访问同一数据，并且至少有一个线程会写这个数据的时候，如果我们不采取防护措施，那么就会导致并发Bug
     -- 竞态条件：指的是程序的执行结果依赖线程执行的顺序
     -- 解决：锁
   • 2-活跃性：
     -- 概念：指的是某个操作无法执行下去。
     -- 活跃性问题：死锁、活锁、饥饿
     ① 死锁：发生“死锁”后，线程会互相等待，而且会一直等待下去，技术上表现形式是线程永久地“阻塞”了。
     ② 活锁：线程没发生阻塞，但仍存在执行不下去的情况。
     解决：尝试等待等待一个随机时间
     ③ 饥饿：指的是线程因无法访问所需资源而无法执行下去的情况。
     三种解决方案：
     一是保证资源充足，二是公平地分配资源，三就是避免持有锁的线程长时间执行。
     -- 一、三的适用场景比较有限，因为很多场景下，资源的稀缺无法解决的，持有锁的线程执行的时间也很难缩短。
     -- 公平地分配资源
     并发编程里，主要使用公平锁，一种先来后到的方案，线程的等待是有顺序的，排在等待队列前面的线程会优先获得资源。
   • 3-性能问题
     -- 衡量标准：吞吐量、延迟和并发量
     -- 尽量减少串行
     -- 避免锁带来的性能问题

2. 什么是线程安全问题？
   1)《深入理解Java虚拟机》原文：
   当多个线程访问同一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替运行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获取正确的结果，那这个对象是线程安全的。
   2)线程安全的问题原因
   一般是主内存和工作内存数据不一致性、重排序导致。
   3)例子
   ① 数据不一致
   在i++一组指令执行过程中，cpu是有可能切换线程的，如果在当前线程t1被挂起之后其他线程修改了这个对象的a属性值，那么恢复线程执行时t1线程将会覆盖其他线程已经修改过的值。
   https://blog.csdn.net/yongjie910203/article/details/79763382
   ② 指令重排

3. java线程安全都体现在哪些方面

   • ans：原子性、可见性、有序性
   • 原子性：提供互斥访问，同一时刻只能有一个线程对数据进行操作，（atomic,synchronized）；
   • 可见性：一个线程对主内存的修改可以及时地被其他线程看到，（synchronized,volatile）；
   • 有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序，该观察结果一般杂乱无序，（happens-before原则）。

4. 说说怎么理解线程安全
   优：从底层CPU开始说

5. 怎么保证线程安全（三个方式） |2

   • 不在线程之间共享变量
   • 使变量修改为不可变的变量（final类型）
   • 访问共享变量时加上同步
   • 有共享变量可以通过什么方式来保证线程安全？
   • Java是如何保证其安全性的？
     答了C语言手动内存管理和JVM GC保证一定程度上的内存安全、内存不泄露

6. 线程安全怎么实现
   1)互斥同步(/阻塞同步)
   同步：共享数据在同一个时刻只被一条（/一些|信号量）线程使用。
   互斥：实现同步的一种手段，互斥实现方式主要是临界区(Critical Section)、互斥量(Mutex)和信号量(Semaphore)
   Java中实现：synchronized关键字、JUC中的重入锁（ReentrantLock）
   问题：线程阻塞和唤醒所带来的性能问题
   2)非阻塞同步
   3)无同步方案
   Java中实现：可重入代码、线程本地存储

7. java线程间通信? |2

   • 线程间通信的模型有两种：共享内存和消息传递
   • 共享内存：volatile 关键字、synchronized关键字同步、JUC工具类 CountDownLatch
   • 消息传递：Object类的wait() 和 notify() 方法
     待完善：https://aalion.github.io/2019/12/28/concurrency11/
     https://blog.csdn.net/jisuanji12306/article/details/86363390
     https://www.cnblogs.com/lgyxrk/p/10404839.html

8. 说说java保证线程间同步的方法 | 2
   使用同步方法 public synchronized void save(){}
   使用同步代码块synchronized(object){}
   使用特殊域变量(volatile)实现线程同步
   使用重入锁ReetrantLock实现线程同步
   使用局部变量实现线程同步 ThreadLocal
   使用阻塞队列实现线程同步 LinkedBlockingQueue
   使用原子变量实现线程同步AtomicInteger
   线程间的同步的方式有哪些呢?
   🙋 ：线程同步是两个或多个共享关键资源的线程的并发执行。应该同步线程以避免关键的资源使用冲突。操作系统一般有下面三种线程同步的方式：
   互斥量(Mutex)：采用互斥对象机制，只有拥有互斥对象的线程才有访问公共资源的权限。因为互斥对象只有一个，所以可以保证公共资源不会被多个线程同时访问。比如 Java 中的 synchronized 关键词和各种 Lock 都是这种机制。
   信号量(Semphares) ：它允许同一时刻多个线程访问同一资源，但是需要控制同一时刻访问此资源的最大线程数量
   事件(Event) :Wait/Notify：通过通知操作的方式来保持多线程同步，还可以方便的实现多线程优先级的比较操

9. 单例模式？哪种单例模式最好？

   • https://blog.csdn.net/qq_38734403/article/details/106976266

10. 单例模式双重检验的问题？

2. JMM

|并发知识|

0-JMM

1. Java内存模型(Java Memory Model,JMM) -P39
   1) Java线程间的通信采用的是共享Java内存模型(简称JMM)，JMM决定一个线程对共享变量的写入何时对另一个线程可见.
   2) Java内存模型
   

   • JMM本身是一种抽象的概念，并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。
   • JMM三大特性：可见性、原子性、有序性
   • Java内存模型把内存分成了两部分：线程栈区和堆区
     

     JVM中运行的每个线程都拥有自己的线程栈，线程栈包含了当前线程执行的方法调用相关信息，我们也把它称作调用栈。线程栈还包含了当前方法的所有本地变量信息。
     堆区包含了Java应用创建的所有对象信息，不管对象是哪个线程创建的，其中的对象包括原始类型的封装类（如Byte、Integer、Long等等）。不管对象是属于一个成员变量还是方法中的本地变量，它都会被存储在堆区。

2. 谈谈JMM（sxt2） 参考：volitile部分

   • JMM（Java内存模型,Java Memory Model）本身是一种抽象的概念并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。
   • JMM三大特性：为线程安全得到保证
     ① 可见性：主内存有更改，工作内存第一时间被通知改变
     ② 原子性：
     ③ 有序性
   • JMM关于同步的规定
     1、线程解锁前，必须把共享变量的值刷新回主内存；
     2、线程加锁前，必须读取主内存的最新值到自己的工作内存；
     3、加锁解锁是同一把锁；
   • 由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存（有些地方称为栈空间），工作内存是每个线程的私有数据区域，而Java内存模型中规定所有的变量都存储在主内存，主内存是共享内存区域，所有的线程都可以访问，但线程对变量的操作（读取赋值等）必须在工作内存中进行，首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后在将变量写回主内存，不能直接操作主内存中的变量，各个线程的工作内存中存储着主内存中的变量副本拷贝，因此不同的线程间无法访问对方的工作内存，线程间的通信必须通过主内存来完成。
     
   • 注：存储 硬盘<内存(<缓存Cache) 主内存、线程自己的工作内存

1-volatile

1. 说说volatile？（sxt2）

   • volatile是Java提供的轻量级的同步机制（轻量级synchronized）
   • 三个特性：① 保证内存可见性 ② 不保证原子性 ③ 禁止指令重排序
     (Volatile 变量具有 synchronized 的可见性特性,但是不具备原子特性。防止指令重排。)
   • Ⅰ 可见性
     1.① 保证内存可见性（sxt2）volatile有什么特点，怎么保证可见性的
     volatile可以保证可见性，及时通知其他线程，主物理内存的值已被修改。
   • 可见性的保证是基于 CPU 的内存屏障指令, 抽象为 happens-before 原则，确保一个线程的修改能对其他线程是可见的。
   • volatile保证了修饰的共享变量在转换为汇编语言时，会加上一个以lock为前缀的指令，当CPU发现这个指令时，立即会做两件事情：
     将当前内核中线程工作内存中该共享变量刷新到主存；
     通知其他内核里缓存的该共享变量内存地址无效；
   • happens-before
     ① 作用：指定两个操作之间的执行顺序。即：如果A线程的写操作a与B线程的读操作b之间存在happens-before关系，尽管a操作和b操作在不同的线程中执行，但JMM向程序员保证a操作将对b操作可见。
     ②示例：A happens-before B： A操作的结果将对B可见，且A的执行顺序排在B之前。

2. 另一个线程改动了变量(volatile修饰的)，先写到工作内存还是主内存

   • volatile修饰的变量在被修改后会处理器直接将结果stroe和write进主内存，同时使得其他线程的工作内存缓存失效，实现可见性
     https://www.sohu.com/a/399318783_120591934

3. Ⅱ 非原子性
   ② 不保证原子性（sxt2）
   1） 不保证原子性，会出现写丢失（写覆盖），线程太快
   2）i++在多线程下是非线程安全的，如何不加synchronized解决？

   • volatile 的一个重要作用就是和 CAS 结合，保证了原子性，详细的可以参见 java.util.concurrent.atomic 包下的类，比如 AtomicInteger。
     https://blog.csdn.net/weixin_40460171/article/details/106473323
   • jdk1.8的并发包来说，底层基本上就是通过Usafe和CAS机制来实现的。
     https://baijiahao.baidu.com/s?id=1647621616629561468&wfr=spider&for=pc

4. volatile不保证原子性的原因

   • i++被拆分3个指令：（字节码）Ⅰ 执行getfield拿到原始n；Ⅱ 执行iadd进行加1；Ⅲ 执行putfile写吧累加后的值写回
   • 写覆盖：拷贝回自己的内存空间，每个人都拿到0，写回到主内存时，线程1写回到的时候被挂起了，线程2歘的写回了。然后线程1恢复后又写回了一遍，把原来的1给覆盖了。
   • 解决:AtomicInteger 保证原子性
     addAndget[++i]、getAndAdd[i++]
     decrementAndGet、getAndDecrement【加1】

5. Ⅲ 禁止指令重排
   ③ 禁止指令重排序（sxt2）

   • 为了提高性能，编译器和处理器常常会对指令进行重排序。一般分为如下3种：
     
   • 处理器在进行指令重排时，必须考虑指令之间的数据依赖（数据依赖不可重排）
   • 重排示例2
     多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。
     

     public class Test{
     int a = 0;
     boolean flag = flse;
     public void method1(){
         a = 1;      // 这两个语句会发生编译器重排
         flag = true;
     }
     public void method2(){
         if(flag){
             a = a + 5;
             sout("retVale:" + a);
         }
     }
     }

6. volatile如何禁止指令重排（sxt2）

   • volatile实现进制指令重排优化，从而避免多线程环境下程序出现乱序执行的现象。
   • 首先了解一个概念，内存屏障（Memory Barrier）又称内存栅栏，是一个CPU指令，它的作用有两个：
     ① 保证特定操作的顺序
     ② 保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）
     由于编译器和处理器都能执行指令重排的优化，如果在指令间插入一条Memory Barrier则会告诉编译器和CPU，不管什么指令都不能和这条Memory Barrier指令重排序，也就是说 通过插入内存屏障禁止在内存屏障前后的指令执行重排序优化。 内存屏障另外一个作用是刷新出各种CPU的缓存数，因此任何CPU上的线程都能读取到这些数据的最新版本。（注，即可见性）
     
     即就是过在Volatile的写和读的时候，加入屏障，防止出现指令重排的
     (
     在每个volatile写操作的前面插入一个StoreStore屏障；
     在每个volatile写操作的后面插入一个StoreLoad屏障；
     在每个volatile读操作的后面插入一个LoadLoad屏障；
     在每个volatile读操作的后面插入一个LoadStore屏障。
     注意：volatile写是在前面和后面分别插入内存屏障，而volatile读操作是在后面插入两个内存屏障
     )
   • 线程安全获得保证
     ① 工作内存与主内存同步延迟现象导致的可见性问题
     可通过synchronized或volatile关键字解决，他们都可以使一个线程修改后的变量立即对其它线程可见
     ② 对于指令重排导致的可见性问题和有序性问题
     可以使用volatile关键字解决，因为volatile关键字的另一个作用就是禁止重排序优化

7. Ⅳ 怎么用
   volatile在哪里使用（sxt2）
   volatile 常用于多线程环境下的单次操作(单次读或者单次写)。
   1） 双重检测（Double Check Lock，DCL）：（https://blog.csdn.net/qq_38734403/article/details/106976266）

   • 问题：DCL机制不一定线程安全，原因是有指令重排序的存在，加入volatile可以禁止指令重排。
   • instance = new SingletonDemo();可以分为以下3步骤完成（伪代码）
     

     memory = allocate(); //1.分配对象内存空间
     instance(memory); //2.初始化对象
     instance = memory; //3.设置instance指向刚分配的内存地址，此时instance != null

   步骤2和步骤3***不存在数据依赖关系*，而且无论重排前还是重排后程序的执行结果在单线程中没有改变，因此这种重排优化是允许的。

   memory = allocate(); //1.分配对象内存空间
   instance = memory; //3.设置instance指向刚分配的内存地址，此时instance != null,但是对象还没有初始化完成！
   instance(memory); //2.初始化对象

   但是指令重排只会保证穿行语义的执行的一致性（单线程），但并不会关心多线程间的语义一致性。所以当一条线程访问instance不为null时，由于instance实例未必已初始化完成，也就造成了线程安全问题。

8. volatile的特性？ |2

   • 三个特性：① 保证内存可见性 ② 不保证原子性 ③ 禁止指令重排序

9. Volatile实现原理/底层实现？ &作用

   • 可见性的保证是基于 CPU 的内存屏障指令,抽象为happens-before原则
   • volatile的一个重要作用就是和 CAS 结合，保证了原子性
   • Volatile的写和读的时候，加入屏障，防止出现指令重排

10. 怎么保证可见性的?

    • 如上

11. 禁止重排序的场景？

    • volatile 常用于多线程环境下的单次操作(单次读或者单次写)。

12. 单例模式中volatile的作用？

    • 禁止指令重排。

13. 共享变量 long a当两个线程来读a的时候会发生什么？

    • long存储的前32bit和后32bit可能不是同时更新
    • volatile 除了保证可见性和有序性, 还解决了 long 类型和 double 类型数据的 8 字节赋值问题.
      虚拟机规范中允许对 64 位数据类型, 分为 2 次 32 位的操作来处理, 当读取一个非 volatile 类型的 long 变量时,如果对该变量的读操作和写操作不在同一个线程中执行, 那么很有可能会读取到某个值得高 32 位和另一个值得低 32 位.
      详细：

2-synchronized

|synchronized底层|

1. volatile和synchronized的区别？
   区别

2. Synchronized 和 lock的区别？
   见-Lock&Condition部分

3. synchronized怎么用：答：四种用法，

   • synchronized是是一种同步锁：
     1）修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
     2）修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
     3）修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
     4）修饰一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。
   • 各种修饰实现例子

4. synchronize(A.class)什么情况？会不会竞争锁？

   • 修饰一个类

5. 修饰静态方法时锁的是什么资源？答：类
   1）当synchronized修饰一个static方法时，多线程下，获取的是类锁(即Class本身，注意:不是实例)，
   作用范围是整个静态方法，作用的对象是这个类的所有对象。
   2）当synchronized修饰一个非static方法时，多线程下，获取的是对象锁(即类的实例对象)，
   作用范围是整个方法，作用对象是调用该方法的对象
   3）类锁和对象锁区别

   • 类锁和对象锁,一个是类的Class对象的锁,一个是类的实例的锁。
   • 对于普通同步方法，锁是当前实例对象。
   • 对于静态同步方法，锁是当前类的Class对象。
   • 对于同步方法块，锁是Synchonized括号里配置的对象。

6. synchornized的底层原理？ |3

   • ⭐参考-很底层
   • Java虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现，无论是显式同步还是隐式同步都是如此。
     -- 显式同步-同步代码块：有明确的 monitorenter 和 monitorexit 指令,即同步代码块
     -- 隐式同步-同步方法：synchronized修饰的同步方法是Java中同步用的最多；由方法调用指令读取运行时常量池中方法的ACC_SYNCHRONIZED标志来隐式实现的
     （1）synchronized同步代码块：synchronized关键字经过编译之后，会在同步代码块前后分别形成monitorenter和monitorexit字节码指令，在执行monitorenter指令的时候，首先尝试获取对象的锁，如果这个锁没有被锁定或者当前线程已经拥有了那个对象的锁，锁的计数器就加1，在执行monitorexit指令时会将锁的计数器减1，当减为0的时候就释放锁。如果获取对象锁一直失败，那当前线程就要阻塞等待，直到对象锁被另一个线程释放为止。
     （2）同步方法：方法级的同步是隐式的，无须通过字节码指令来控制，JVM可以从方法常量池的方法表结构中的ACC_SYNCHRONIZED访问标志得知一个方法是否声明为同步方法。当方法调用的时，调用指令会检查方法的ACC_SYNCHRONIZED访问标志是否被设置，如果设置了，执行线程就要求先持有monitor对象，然后才能执行方法，最后当方法执行完（无论是正常完成还是非正常完成）时释放monitor对象。在方法执行期间，执行线程持有了管程，其他线程都无法再次获取同一个管程。
     https://blog.csdn.net/javazejian/article/details/72828483
     （3） Synchronized 修饰方法如何实现锁原理
   • JVM 中的同步是基于进入和退出管程（Monitor）对象实现的。每个对象实例都会有一个Monitor，Monitor可以和对象一起创建、销毁。Monitor 是由 ObjectMonitor 实现，而ObjectMonitor 是由 C++ 的 ObjectMonitor.hpp 文件实现。
   • 当多个线程同时访问一段同步代码时，多个线程会先被存放在 EntryList 集合中，处于block状态的线程，都会被加入到该列表。接下来当线程获取到对象的 Monitor 时，Monitor 是依靠底层操作系统的 Mutex Lock 来实现互斥的，线程申请 Mutex 成功，则持有该 Mutex，其它线程将无法获取到该 Mutex。如果线程调用 wait() 方法，就会释放当前持有的 Mutex，并且该线程会进入 WaitSet 集合中，等待下一次被唤醒。如果当前线程顺利执行完方法，也将释放 Mutex。
     

7. synchronized在1.6之后的改动？

   • JDK1.6 对锁的实现引入了大量的优化，如偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化等技术来减少锁操作的开销。
   • 锁主要存在四种状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。

8. JDK1.8是如何对synchronzied进行优化的 |2

9. synchronized怎么实现线程安全的
   同步方法、同步代码块 + 原理
   https://www.jianshu.com/p/7ddb0956590c
   不一定安全：https://www.cnblogs.com/liyunfeng17/p/10891293.html

10. synchronized可重入实现
    定义：
    synchronized是可重入锁：
    当一个线程再次请求自己持有对象锁的临界资源时，这种情况属于重入锁。
    在java中synchronized是基于原子性的内部锁机制，是可重入的，因此在一个线程调用synchronized方法的同时在其方法体内部调用该对象另一个synchronized方法，也就是说一个线程得到一个对象锁后再次请求该对象锁，是允许的，这就是synchronized的可重入性。需要特别注意另外一种情况，当子类继承父类时，子类也是可以通过可重入锁调用父类的同步方法。
    实现：
    synchronized是基于monitor实现的，因此每次重入，monitor中的计数器仍会加1。
    每个锁关联一个线程持有者和一个计数器。当计数器为0时表示该锁没有被任何线程持有，那么任何线程都都可能获得该锁而调用相应方法。当一个线程请求成功后，JVM会记下持有锁的线程，并将计数器计为1。此时其他线程请求该锁，则必须等待。而该持有锁的线程如果再次请求这个锁，就可以再次拿到这个锁，同时计数器会递增。当线程退出一个synchronized方法/块时，计数器会递减，如果计数器为0则释放该锁。

11. 还知道哪些加锁方式（重入锁）和 Synchronized 有哪些不同?

    • java中常用的可重入锁
      ① synchronized
      ② java.util.concurrent.locks.ReentrantLock
    • 区别-见-Lock部分

锁升级

1. 对象头

   • 对象实例在堆内存中被分为了三个部分：对象头、实例数据和对齐填充。
   • Java 对象头由 Mark Word、指向类的指针以及数组长度三部分组成。
   • 锁升级功能主要依赖于 Mark Word 中的锁标志位和释放偏向锁标志位，
     

2. 偏向锁

   • 偏向锁主要用来优化同一线程多次申请同一个锁的竞争。
   • 偏向锁的作用就是，
     当一个线程再次访问这个同步代码或方法时，该线程只需去对象头的Mark Word 中去判断一下是否有偏向锁指向它的 ID，无需再进入 Monitor去竞争对象了。当对象被当做同步锁并有一个线程抢到了锁时，锁标志位还是 01，“是否偏向锁”标志位设置为 1，并且记录抢到锁的线程 ID，表示进入偏向锁状态。
   • 升级
     一旦出现其它线程竞争锁资源时，偏向锁就会被撤销。偏向锁的撤销需要等待全局安全点，暂停持有该锁的线程，同时检查该线程是否还在执行该方法，如果是，则升级锁，反之则被其它线程抢占。
   • 在高并发场景下，当大量线程同时竞争同一个锁资源时，偏向锁就会被撤销，发生stop the word 后， 通过添加 JVM参数关闭偏向锁来调优系统性能，
     -XX:-UseBiasedLocking // 关闭偏向锁（默认打开）
     或
     -XX:+UseHeavyMonitors // 设置重量级锁

3. 轻量级锁

   • 概念
     当有另外一个线程竞争获取这个锁时，由于该锁已经是偏向锁，当发现对象头 Mark Word中的线程 ID 不是自己的线程ID，就会进行 CAS操作获取锁，如果获取成功，直接替换Mark Word 中的线程 ID 为自己的ID，该锁会保持偏向锁状态；如果获取锁失败，代表当
     前锁有一定的竞争，偏向锁将升级为轻量级锁。
   • 场景
     轻量级锁适用于线程交替执行同步块的场景，绝大部分的锁在整个同步周期内都不存在长时间的竞争。

4. 自旋锁与重量级锁

   • 前提
     轻量级锁CAS抢锁失败，线程将会被挂起进入阻塞状态。如果正在持有锁的线程在很短的时间内释放资源，那么进入阻塞状态的线程无疑又要申请锁资源。
   • 自旋次数
     从 JDK1.7 开始，自旋锁默认启用，自旋次数由 JVM 设置决定，不建议设置的重试次数过多，因为 CAS重试操作意味着长时间地占用 CPU。
   • 重量级锁
     自旋锁重试之后如果抢锁依然失败，同步锁就会升级至重量级锁，锁标志位改为 10。在这个状态下，未抢到锁的线程都会进入 Monitor，之后会被阻塞在 _WaitSet 队列中。
   • 在锁竞争不激烈且锁占用时间非常短的场景下，自旋锁可以提高系统性能。一旦锁竞争激烈或锁占用的时间过长，自旋锁将会导致大量的线程一直处于 CAS 重试状态，占用 CPU 资源，反而会增加系统性能开销。所以自旋锁和重量级锁的使用都要结合实际场景。

5. 其他锁优化
   1）动态编译实现锁消除 / 锁粗化
   除了锁升级优化，Java 还使用了编译器对锁进行优化。

   • JIT 编译器在动态编译同步块的时候，借助了一种被称为逃逸分析的技术
   • JIT 编译器在编译这个同步块的时候不会生成 synchronized 所表示的锁的申请与释放的机器码，即消除了锁的使用。
   • JIT 编译器将会把这几个同步块合并为一个大的同步块，从而避免一个线程“反
     复申请、释放同一个锁“所带来的性能开销。
     2） 减小锁粒度
   • 将一个数组和队列对象拆成多个小对象，来降低锁竞争，提升并行
     度。
   • 最经典的减小锁粒度的案例就是 JDK1.8 之前实现的 ConcurrentHashMap 版本。
   • ConcurrentHashMap 就很很巧妙地使用了分段锁 Segment 来降低锁资源竞争。

6. 锁升级过程?（具体实现） |4

   • 锁一共有4种状态，级别从低到高依次是：无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态，这几个状态会随着竞争情况逐渐升级。锁可以升级但不能降级，意味着偏向锁升级成轻量级锁后不能降级成偏向锁。
   • 这种锁升级却不能降级的策略，目的是为了提高获得锁和释放锁的效率。
   • 升级：
     1) 线程A在进入同步代码块前，先检查MarkWord中的线程ID是否与当前线程ID一致，如果一致（还是线程A获取锁对象），则无需使用CAS来加锁、解锁。
     2) 如果不一致，再检查是否为偏向锁，如果不是，则自旋等待锁释放。
     3) 如果是，再检查该线程是否存在（偏向锁不会主动释放锁），如果不在，则设置线程ID为线程A的ID，此时依然是偏向锁。
     4) 如果还在，则暂停该线程，同时将锁标志位设置为00即轻量级锁（将MarkWord复制到该线程的栈帧中并将MarkWord设置为栈帧中锁记录）。线程A自旋等待锁释放。
     5) 如果自旋次数到了该线程还没有释放锁，或者该线程还在执行，线程A还在自旋等待，这时又有一个线程B过来竞争这个锁对象，那么这个时候轻量级锁就会膨胀为重量级锁。重量级锁把除了拥有锁的线程都阻塞，防止CPU空转。
     6)如果该线程释放锁，则会唤醒所有阻塞线程，重新竞争锁。
     https://blog.csdn.net/dh798417147/article/details/102515788
     https://www.jb51.net/article/186708.htm

7. 重量级锁和之前的锁的本质区别？

   • 概念+过程
   • 区别

3-final

1. final、finally、finalize区别？

   • final
     final修饰类，表示该类不可以被继承
     final修饰变量，表示该变量不可以被修改，只允许赋值一次
     final修饰方法，表示该方法不可以被重写
   • finally
     finally是java保证代码一定要被执行的一种机制。
     比如try-finally或try-catch-finally，用来关闭JDBC连接资源，用来解锁等等
   • finalize
     finalize是Object的一个方法，它的目的是保证对象在被垃圾收集前完成特定资源的回收。
     不过finalize已经不推荐使用，JDK9已经标记为过时。

2. final可以修饰方法嘛？

3. final修饰基础类型与引用的区别？

4. volatile和final的共同点

   • 首先：对于一些需要快速读写的数据，可以从内存读取到CPU的寄存器中操作
   • final 关键字声明的变量，会被CPU添加到寄存器中，读写都很快速
   • volatile 它是被设计用来修饰被不同线程访问和修改的变量， 禁止把该变量放到CPU的寄存器中，防止多线程访问出现错乱问题
     1、JMM保证final变量初始化时的有序性、禁止编译器和处理器重排序。
     2、final作为不可变对象，正确初始化后(没有this逃逸)，能够保障可见性。
     3、volatile能够保障单次操作的原子性
     4、volatile能够保障变量的可见性

3-锁机制

1. 锁（总）

1. 分布式锁
   分布式锁一般有三种实现方式：1.数据库锁；2.基于Redis的分布式锁；3. 基于ZooKeeper的分布式锁。

2. 线程同步的方式？
   ① synchronized
   ② Condition
   ③ CountDownLatch、CyclicBarrier

3. java锁及实现

   • volatile、synchronized、CAS
   • 锁-是为了解决并发操作引起的脏读、数据不一致的问题。
     https://www.jianshu.com/p/e674ee68fd3f

4. java锁机制
   1) 所熟知的Java锁机制无非就是Sychornized 锁 和 Lock锁 （对象头知识，偏向锁，轻量级锁，重量级锁）

   • Lock 同步锁是基于 Java 实现的，而 Synchronized是基于底层操作系统的 Mutex Lock实现的，每次获取和释放锁操作都会带来用户态和内核态的切换，从而增加系统性能开销。
     https://www.jianshu.com/p/e674ee68fd3f
     2) 在 Java 多线程编程当中，提供了多种实现 Java 线程安全的方式：
   • 最简单的方式，使用 Synchronization 关键字
   • 使用 java.util.concurrent.atomic 包中的原子类，例如 AtomicInteger
   • 使用 java.util.concurrent.locks 包中的锁
   • 使用线程安全的集合 ConcurrentHashMap
   • 使用 volatile 关键字，保证变量可见性（直接从内存读，而不是从线程 cache 读
     https://www.cnblogs.com/theworld/p/12056452.html
     https://www.jianshu.com/p/e674ee68fd3f

5. 都有什么锁？说说乐观锁悲观锁是什么，怎么实现，volatile关键字，CAS，AQS原理及实现。
   1）锁的分类：

   • 公平锁、非公平锁
   • 互斥锁、读写锁
   • 乐观锁、悲观锁
     synchronized，retreenLock， ReadWriteLock
     4）CAS，AQS原理及实现

6. 锁的应用

7. 使用锁保证线程安全

2. 死锁

1. 死锁编码及定位分析（sxt2）

2. 死锁
   1）概念

   • 死锁是指多个进程循环等待彼此占有的资源而无限期的僵持等待下去的局面。
   • 即A使用A资源并等待使用B资源，B使用B资源并等待使用A资源
     2）必要条件
   • 互斥条件、不可抢占条件、占有且等待条件、循环等待条件
     3）死锁处理
     一般有死锁的预防、死锁避免、死锁的检测与恢复三种方法。
     详见：https://blog.csdn.net/zhang123bl/article/details/89850646
     4)死锁示例？ |写一个死锁的例子？
     

     /**
     * 开启了两个线程threadA, threadB,
     * 其中threadA占用了resource_A, 并等待被threadB释放的resource _B
     * threadB占用了resource _B正在等待被threadA释放的resource _A
     * 因此threadA,threadB出现线程安全的问题，形成死锁。
     */
     public class D011_DeadLockDemo {
     private static String resourceA ="A";
     private static String resourceB="B";
     public static void main(String[] args) {
         deadLock();
     }
     public static void deadLock(){
         Thread threadA = new Thread(new Runnable() {
             @Override
             public void run() {
                 synchronized(resourceA){
                     System.out.println("get resource A");
                     try {
                         Thread.sleep(3000);
                         synchronized(resourceB){
                             System.out.println("get resource B");
                         }
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             }
         });
         Thread threadB = new Thread(new Runnable() {
             @Override
             public void run() {
                 synchronized (resourceB){
                     System.out.println("get resource B");
                     synchronized (resourceA){
                         System.out.println("get resource A");
                     }
                 }
             }
         });
         threadA.start();
         threadB.start();
     }
     }

   死锁：https://www.runoob.com/java/thread-deadlock.html

3. 死锁是什么（sxt2）
   1）产生死锁主要的原因
   ① 系统资源不足、② 进程运行推进的顺序不合适、③ 资源分配不当
   2） 代码、

   class HoldLockThread implements Runnable{
   private String lockA;
   private String lockB;
   public HoldLockThread(String lockA, String lockB) {
       this.lockA = lockA;
       this.lockB = lockB;
   }
   @Override
   public void run() {
       synchronized (lockA){
           System.out.println(Thread.currentThread().getName() + "\t 自己持有" + lockA + "\t 尝试获得" + lockB);
           try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
           synchronized (lockB){
               System.out.println(Thread.currentThread().getName() + "\t 自己持有" + lockA + "\t 尝试获得" + lockB);
           }
       }
   }
   }
   public class DeadLockDemo {
   public static void main(String[] args) {
       String lockA = "lockA";
       String lockB = "lockB";
       new Thread(new HoldLockThread(lockA,lockB) ,"ThreadAAA").start();
       new Thread(new HoldLockThread(lockB,lockA) ,"ThreadBBB").start();
   }
   }

   打印：

   打印
   ThreadAAA   自己持有：lockA    尝试获得：lockB
   ThreadBBB   自己持有：lockB    尝试获得：lockA

4. 死锁怎么定位。
   3） 解决(sxt2)
   ① jps 定位进程号
   ② jstack 找到死锁查看
   linux ps -ef|grep XXxxxx ls -l
   windows jps=java ps 只查看java jps -l
   

   • 另：https://blog.csdn.net/zp357252539/article/details/104292521

5. 有没有遇到过死锁，咋解决的
   解决死锁问题的方法是：一种是用synchronized，一种是用Lock显式锁实现。

线程排查

1. 排查CPU占满的Java线程
   产生CPU100%的原因：某一程序一直占用CPU是导致CPU100%的原因，大概有以下几种情况：
   1)Java 内存不够或溢出导致GC overhead问题, GC overhead 导致的CPU 100%问题;
   2)死循环问题. 如常见的HashMap被多个线程并发使用导致的死循环, 或者死循环;
   3)某些操作一直占用CPU
   步骤：
   1)jps 获取Java**进程的PID。
   2)top -Hp PID 查看对应进程的哪个线程**占用CPU过高。该进程内最耗费CPU的线程
   3)echo "obase=16;PID" | bc 将线程的PID转换为16进制,大写转换为小写。
   4)jstack pid >> java.txt 导出CPU占用高进程的线程栈
   jstack 2444 >stack.txt或者jstack 进程id | grep 16进制线程id
   在Java.txt中查找转换成为16进制的线程PID。找到对应的线程栈。
   辅助
   命令参考
   grep "99b" stack.txt -A 25
   grep -C 5 foo file 显示file文件里匹配foo字串那行以及上下5行
   grep -B 5 foo file 显示foo及前5行
   grep -A 5 foo file 显示foo及后5行
   对线程状态进行分析。
   新建( new )、可运行( runnable )、运行( running )、阻塞( block )、死亡( dead )

4-Java线程

1. 生命周期--- 存疑
   线程状态如下所示：
   1) 死锁，Deadlock（重点关注）
   2) 执行中，Runnable
   3) 等待资源，Waiting on condition（重点关注，等待什么资源）
   4) 等待获取监视器，Waiting on monitor entry（重点关注）
   5) 暂停，Suspended
   6) 对象等待中，Object.wait() 或 TIMED_WAITING
   7) 阻塞，Blocked（重点关注）
   8) 停止，Parked
   

2. Java线程的状态？ |3

   • Java语言中线程共有六种状态，分别是：
     1）NEW（初始化状态）
     2）RUNNABLE（可运行 / 运行状态）
     3）BLOCKED（阻塞状态）
     4）WAITING（无时限等待）
     5）TIMED_WAITING（有时限等待）
     6）TERMINATED（终止状态）
   • 在操作系统层面，Java线程中的BLOCKED、WAITING、TIMED_WAITING是一种状态，即休眠状态。Java线程处于这三种状态之一，那么这个线程就永远没有CPU的使用权。
   • 所以Java线程的生命周期可以简化为下图：
     
   • 其中，BLOCKED、WAITING、TIMED_WAITING可以理解为线程导致休眠状态的三种原因。

3. 线程的状态及转换方式？

   • RUNNABLE与BLOCKED的状态转换
     -- RUNNABLE转BLOCKED：一种场景会触发，线程等待synchronized的隐式锁。
     -- BLOCKED转RUNNABLE：当等待的线程获得synchronized隐式锁时，就又会从BLOCKED转换到RUNNABLE状态。
   • RUNNABLE与WAITING的状态转换
     三种场景会触发：
     ① 获得synchronized隐式锁的线程，调用无参数的 Object.wait() 方法。
     ② 调用无参数的Thread.join()方法。其中的join()是一种线程同步方法，例如有一个线程对象threadA，当调用A.join()的时候，执行这条语句的线程会等待threadA执行完，而等待中的这个线程，其状态会从 RUNNABLE 转换到 WAITING。当线程 thread A 执行完，原来等待它的线程又会从 WAITING 状态转换到 RUNNABLE。
     ③ 调用 LockSupport.park() 方法。调用LockSupport.park()方法，当前线程会阻塞，线程的状态会从 RUNNABLE 转换到 WAITING。调用 LockSupport.unpark(Thread thread) 可唤醒目标线程，目标线程的状态又会从 WAITING 状态转换到 RUNNABLE。
   • RUNNABLE与TIMED_WAITING的状态转换？
     五种场景会触发：
     ① 调用带超时参数的 Thread.sleep(long millis) 方法；
     ② 获得synchronized 隐式锁的线程，调用带超时参数的 Object.wait(long timeout) 方法；
     ③ 调用带超时参数的 Thread.join(long millis) 方法；
     ④ 调用带超时参数的 LockSupport.parkNanos(Object blocker, long deadline) 方法；
     ⑤ 调用带超时参数的 LockSupport.parkUntil(long deadline) 方法。
   • NEW到RUNNABLE状态？
     Java刚创建出来的Thread对象就是NEW状态。
     从NEW状态转换到RUNNABLE状态，只要调用线程对象的start()方法就可以
   • 从RUNNABLE到TERMINATED状态？
     -- 线程执行完run()方法后，会自动转换到TERMINATED状态，当然如果执行run()方法的时候异常抛出，也会导致线程终止。
     -- 强制中断run()方法的执行，调用 interrupt()方法。

4. 阻塞和等待的区别？

   • 定义+何时触发？
   • BLOCKED：一个线程因为等待临界区的锁被阻塞产生的状态
   • WAITING：一个线程进入了锁，但是需要等待其他线程执行某些操作。时间不确定

5. sleep和wait有什么区别？

   • 对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。
     Thread类的方法：sleep(),yield()等
     Object的方法：wait()和notify()等
   • sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。
     在调用sleep()方法的过程中，线程不会释放对象锁。
   • 而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备
     获取对象锁进入运行状态。
   • 参考：https://www.cnblogs.com/hongten/p/hongten_java_sleep_wait.html

2-单线程

1. 线程实现的3种方式? |3
   1）通过继承Thread类，重写run方法；
   2）通过实现runable接口；
   3）通过实现callable接口。(和Future)
   ④ 线程池获取：ThreadPoolExecutor

   public class CreateThreadDemo {
    public static void main(String[] args) {
        //1.继承Thread
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("继承Thread");
                super.run();
            }
        };
        thread.start();
        //2.实现runable接口
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("实现runable接口");
            }
        });
        thread1.start();
        //3.实现callable接口
        ExecutorService service = Executors.newSingleThreadExecutor();
        Future<String> future = service.submit(new Callable() {
            @Override
            public String call() throws Exception {
                return "通过实现Callable接口";
            }
        });
        try {
            String result = future.get();
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
   }

2. 继承Thread和实现Runnable接口的区别，这两者的继承关系

   • 实现：通过继承Thread类，重写Thread的run()方法，将线程运行的逻辑放在其中;通过实现Runnable接口，实例化Thread类
   • 如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。继承Thread是多个线程分别完成自己的任务，实现了Runable是多个线程共同完成一个任务。
     实现Runnable接口比继承Thread类所具有的优势：
     1）：适合多个相同的程序代码的线程去处理同一个资源
     2）：java只能单继承,可以避免java中的单继承的限制
     3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立,
     4)如果只想重写 run() 方法，而不重写其他 Thread 方法，那么应使用 Runnable 接口
     https://www.cnblogs.com/CryOnMyShoulder/p/8028122.html

3. Callable和Runnable的区别？

   • Runnable vs Callable
     -- Runnable自 Java 1.0 以来一直存在，但Callable仅在 Java 1.5中引入,目的就是为了来处理Runnable不支持的用例。
     -- Runnable 接口不会返回结果或抛出检查异常，但是Callable接口可以。所以，如果任务不需要返回结果或抛出异常推荐使用 Runnable 接口，这样代码看起来会更加简洁。
   • 工具类 Executors 可以实现 Runnable 对象和 Callable对象之间的相互转换。（Executors.callable（Runnable task）或 Executors.callable（Runnable task，Object resule））。
     

     // ① Runnable.java
     @FunctionalInterface
     public interface Runnable {
        /** 被线程执行，没有返回值也无法抛出异常*/
         public abstract void run();
     }
     // ② Callable.java
     @FunctionalInterface
     public interface Callable<V> {
         /**计算结果，或在无法这样做时抛出异常。
          * @return 计算得出的结果 @throws 如果无法计算结果，则抛出异常*/
         V call() throws Exception;
     }

4. 创建线程的方式：延伸至优劣，底层实现

   • 优劣
     采用继承Thread类方式：
     （1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。
     （2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。
     采用实现Runnable接口方式：
     （1）优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
     （2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。
     https://blog.csdn.net/Touch_2011/article/details/6891026

5. run和start的区别

   • 调用start方法实现多线程，而调用run方法没有实现多线程
   • 一般会在run实现方法体，
   • run还是在主线程中执行，会和调用普通方法一样，按照顺序执行，不会进入run里的代码块。
   • start方法，则会在主线程中重新创建一个新的线程，等得到cpu的时间段后则会执行所对应的run方法体的代码。
     https://blog.csdn.net/QQ2899349953/article/details/81772104