Java面试相关知识点

这篇笔记主要用来记录一个大牛的java相关知识点

一、计算机网络

网络上的知识，基本上以理论为主

1. OSI七层协议

物理层：用于信号传输，进行数模转换/模数转换，基本数据是：比特，网卡在这一层工作

数据链路层：定义格式化数据进行传输和为物理介质的控制，提供数据校验，基础数据是：帧，交换机在这一层工作

网络层：将网络地址翻译成物理地址并且决定传输的路径，基本数据是：数据包，路由器在这里工作（TCP/IP协议就在此层）

传输层：解决数据传输的稳定性，必要时将数据分割（TCP/UDP协议就工作在此层）

会话层：解决不同操作系统的通讯语法的问题

应用层：（HTTP协议就工作在此层）

OSI

2. TCP/IP协议族的四层协议

OSI七层协议知识一个概念性的框架，TCP/IP协议族是OSI七层模型的实现，但是它并没有完全按照OSI七层模型进行实现。

TCP/IP协议族

3. TCP和三次握手

IP协议是无链接的通讯协议，但是IP协议没有控制包的顺序和可靠性，因此需要上层的TCP协议进行控制。

TCP将上层的数据报文分割成适当大小的包交给网络层进行发送，为了保证顺序和可靠，TCP会对每个包进行编号，并且需要接收方发送ACK进行确认来确保不会丢包

3.1 TCP报文头

TCP报文头

3.2 三次握手

三次握手

相关的标识位如下：

• ACK：缺人需要表示1:确认有效 0:不含确认信息
• SYN：同步需要 SYN=1且ACK=0表示没有捎带确认的信息 SYN=1且ACK=1表示会稍带确认上一条数据
• FIN：结束标志

握手过程：

• C端发出SYN包（seq = x）请求建立链接，进入SYN-SENT状态
• S端收到刚刚的SYN包，发出确认包（ack = x+1），并且自己也发出一个SYN包（seq = y），请求确认，进入SYN-REVD状态
• C端收到S端的确认包和SYN包，再发送一个确认包（ack = y+1），这是进入ESTAB-LISHED状态，S端收到后也进入ESTAB-LISHED状态，开始传输数据

注意：第二次握手时S端收到首次发送C端的SYN包，发送确认包和自己的SYN包时如果S端没有收到ACK确认时，S端会不断重试，linux默认情况下会等待63秒

4.四次挥手

四次挥手

• 挥手过程
  • C端发送FIN包（seq = u）请求关闭链接，进入FIN-WAIT1状态
  • S端收到FIN包，并且发送确认包（ack = u+1），进入CLOSE-WAIT状态，C端收到后进入FIN-WAIT2状态，等待S端发送最后的数据
  • S端完成最后数据的发送后，发送FIN包（seq = w），并且再次确认（ack = u+1），发送后S端进入LAST-ACL状态
  • C端收到S端发送的FIN包后，发送确认包（ack = w+1），自己进入TIME-WAIT状态，经过两个延迟时间后正式关闭链接，S端收到后也会直接关闭链接
• 为啥需要有TIME-WAIT状态
  • 保证S端收到最后发送的ACK包，并且保证不会和后面的链接混淆
• 频繁出现大量CLOST-WAIT的原因
  • 在客户端应用层关闭Socket后，服务器忙于读写没有进一步发送第二个FIN包导致大量CLOST-WAIT积压

5.UDP和TCP的区别

5.1 UDP的特点

• UDP时非链接的，不支持错误重传，华东窗口等，只会尽可能快的传入网络中
• 不用维护链接状态，可以同时想多个客户端传输一样的信息
• UDP不保证可靠，保证速度
• UDP时面向报文的，不具备有序性，所有的事情会交给上层应用处理

6. TCP的滑动窗口

TCP的滑动窗口是为了解决TCP的流浪控制和乱序重排的问题，未来研究这个问题，我们先知道下面这两个概念

• RTT：发出需要确认的包到收到确认包到时间

• RTO：重传时间间隔（确认包的超时时间）

6.1 滑动窗口过程

滑动窗口发送

每次收到接受放确认的连续包后，窗口会进行滑动，框入更多的未发送数据

7. HTTP协议

主要特点：

• 支持客户/服务器模式
• 简单快速，只要发送请求方法和路径即可
• 无链接的，传输完数据就会断开链接
• 无状态的，两次链接的状体对方不可感知

7.1 HTTP请求/响应结构

• 请求报文结构如下

HTTP请求报文

• 响应报文结构如下

HTTP响应报文

7.2 Cookie和Session

• Cookie：服务器要求客户端保存的信息
• Session：根据客户端发送的session-id来在服务器中检索session信息
  • 使用cookie保存session-id
  • 使用url参数保存session-id

7.3 HTTPS

加入ssl层，加入安全套接层，提供安全和数据完整性的协议，通过身份验证和数据加加密的完整性

• 加密的方式
  • 对称加密：加密和解密使用同一个密钥，性能较高
  • 非对称加密：加密使用公钥，解密使用私钥
  • 哈希算法
  • 数字签名：证明某个消息是某人发送的，没有被篡改的
• HTTPS流程
  • 浏览器发送支持的加密算法发送服务器
  • 服务器选择一套浏览器支持的算法，发送相关证书给浏览器
  • 浏览器验证证书合法性，并且使用证书中的公钥加密传输用的对称加密对称加密的密码，发给服务器
  • 服务器使用私钥解密浏览器发送的对称加密密码

二、 数据库

1. 数据库设计和模块划分

如果我没来设计数据库，需要这样几部分

• 存储模块：将数据存入磁盘
• 存储管理：将物理数据组织和表述
  • 优化存储效能？一次性读取多行减少IO次数
• 缓存机制
• SQL接信息模块
• 日志管理：管理操作日志
• 用户权限模块
• 异常容灾难机制
• 索引模块
• 锁模块

2. 索引模块

为什么要使用索引？

相当于字典的目录，通过索引可以大幅提升查询速度

2.1 索引的数据结构

• 二叉查找树

  二叉树.png

  二叉查找树：对于树中的任意节点，比左子树的值大，比右子树的值小��

  平衡二叉树：根结点的左右子树高度相差不超过1

  查找效率：O(logn)，但是最多两个孩子的设定会大大增加树的深度，增加查找次数

• B树

  3阶段B树

  B树可以通过策略保证新增节点不会变成线性的（B树节点的分裂，合并）

• B+数（MySQL使用这种数据结构作为索引）

  B+树

  B+树的数据全部存储在叶子结点上，非叶子结点只用于索引，叶子结点的链表结构也便于做数据统计和全盘扫描

• Hash结构

  相当于Java的HashMap的索引方式，只需要O(1)的时间

  但是无法排序、范围操作，可能同一个哈希插入太多值造成效率不如哈希

2.2. 密集索引和稀疏索引的区别

• 密集索引：每一个搜索码都对应一个搜索值（只能有一个，相当于组件，相当于叶子结点保存了所有的信息）

• 稀疏索引：只为了索引某些相才建立的索引（叶子结点里只保存了数据的存储地址）

  在MySQL的MyISAM引擎里所有的索引都是稀疏索引

  MySQL的InnoDB引擎的索引有且仅有一个密集索引（主键 ==> 第一个唯一非空索引 ==> 生成隐藏的索引 ）

  因此在使用InnoDB的稀疏索引时会先找到对应的密集索引，再通过密集索引找到数据（两次索引）

2.3 SQL衍生问题

1. 如何优化慢SQL

   • 根据慢日志定位问题：修改mysql中的变量来开启慢日志（下面的操作在my.ini更改后就会永久保存）

     shwo variables like 'query'        #找到和查询有关的全局变量
     set global show_query_log = no #开启慢日志
     set global long_query_time = 1 #设置慢查询时间为1秒
     show status like '%slow_queries' #查看慢sql个数
     

   • 利用explan来分析select查询，用法就是在select前面加上explan就好了

     • 关注出现的type字段，如果是“index”或者"all"就表明查询是通过全表扫描完成的，需要优化

     • 关注extar字段

       [图片上传失败...(image-52b86-1584189158882)]

   • 修改SQL让其尽量使用索引或者添加索引

2. 联合索引最左原则

   • 最左匹配原则：A、B字段组成联合索引，当where A = xxx 和 where A = xxx and B = xxx时，会使用这个联合索引，但是当where B = XXX时，就不会使用这个索引了

   • 原因：联合索引建立时，会先对第一个字段进行排序，在这个顺序的基础上再对第二个字段进行陪许，因此第二个字段是局部有序的

     最左匹配

3. 索引是越多越好吗

   索引并不是越多越好。索引也需要维护并且占用空间。

3. 锁模块

3.1 MyISAM和InnoDB锁的区别

• MyISAM默认表级锁，不支持行级锁

• InnoDB默认行级锁：在使用索引时使用行级锁，不使用索引时使用表锁

  ---

  两种引擎适合的场景：

  MyISAM：频繁执行全表count、查询操作较多（只有表锁，效率低），写的操作较少、不需要事务

  InnoBD：增删改查都很频繁的系统、稳定性要求较高

3.2 锁的分类

• 锁的粒度划分：表级锁，行级锁，页级锁
• 锁的级别划分：读锁 = 共享锁，可以反复加上 写锁=独占锁，只能加上一次，且不能和读锁共存
• 加锁的方式划分：自动锁，显式锁
• 按操作划分：DML锁：对数据进行加锁 DDL锁：对表结构枷锁
• 使用方式划分：悲观锁：先取锁，再访问，乐观锁：只有提交更新时才会检测是否冲突

3.3 数据库事务的四大特性

• A：原子性：对于事务中的操作，要么全执行，要么全不执行（回滚）
• C：一致性：数据库中的数据在事务执行前后应保存一致
• I：隔离性：多个事务的并发执行不会相互影响（隔离等级）
• D：持久性：事务一旦提交，对系统的修改应该永久保存

3.4 事务并发访问产生的问题和隔离级别

• 事务并发访问可能引起的问题

  • 丢失修改：一个事务的更新覆盖了另一个事务的更新（在任何隔离级别（读未提交）下都可以防止）

    丢失修改

  • 脏读：读取到还未提交的事务修改的数据（可以在读已提交级别防止，该级别不允许读未提交的数据）

  • 不可重复读：事务A多次读取同一个数据，事务B在A读取时作出更新并提交导致A在多次读取时内容不一致（可以在可重复读级别防止，该级别确保别的事物的提交不会更改本次事务查询的结果）

  • 幻读：事务A多次读取若干行，事务B进行插入或者删除操作导致事务A多次读取的数据的数量不一致（可在Serializable级别防止，这个级别会让事务串行提交）

  事务隔离级别越高，事务的并发度越低，因此需要根据需求来确定隔离级别

  ---

  在MySQL的InnoDB中如何在可重复读中避免了幻读的？

  MySQL中存在两种读取数据的方式：当前读和快照读

  • 当前读：selete ... lock in share mode、delete、update、insert操作都为当前读，当前读会获取数据的最新版本
  • 快照读：不加锁的读selete为快照读，在“可重复读”的隔离级别下，读到的不是数据的最新版本。在“可重复读”的级别下，快照读读出的都是第一次执行这条语句的数据。

4. SQL关键语法

假设我们的表结构如下

表例子

4.1 Group By

根据查询结果进行分组查询，对每个组的数据进行聚合运算。

例子：查询所有同学的学号，姓名，选课数，和每个同学成绩的总和

selete s.student_id,stu.name,count(s.coures_id),sum(s.score)
    form score s，student stu
    where s.student_id = stu.student_id
    greop by student_id

4.2 Having

通常于Group By一起使用，给Group By 添加限定条件

例子： 查询所有平均分大于60分的同学的学号，姓名，选课数，和每个同学的平均成绩

selete s.student_id, stu.name, count(s.coures_id), avg(s.score)
    form score s，student stu
    where s.student_id = stu.student_id
    greop by student_id
    having avg(s.score) > 60

例子：查询使用没有学全所有课程的学号和姓名

selete s.student_id, stu.name
    from score s, student stu
    where s.student_id = stu.student_id
    group by s.student_id
    having count(*) < (
        select count(*) from course
    ) 

三、Redis

• Redis快的原因
  • Redis是完全基于内存的
  • 数据结构简单
  • 采用单线程和IO多路复用，不存在上下文切换问题

1 IO多路复用模型

• Select系统调用：可以监控多个IO的文件描述符，只用一个线程就可以完成多个IO的操作

2 Redis数据类型

• String：最基础的数据模型，是包括二进制的
• Hash：String元素组成的字典，可以方便的存入POJO
• List：String元素组成的队列，有序可重复
• Set：String元素组成的集合，无序不重复，集合可以交集并集的操作

3 相关问题

3.1 如何从redis中查询固定前缀的简直对

• 使用keys指令：keys会一次性获取所有参数，数据过大时可能会使服务器卡顿

• 使用Scan命令，相当于给返回数据分页，每次查询可以从上次结束的地方继续查询，但是可能会获取到重复的问题，而且给的的count并不会完全符合

  scan [开始行] match [匹配模式] count [个数]

3.2 实现分布式锁

• 使用 SETNT [key] [value]来设置一个值，设置成功返回1，失败返回0且不会被更改，再使用EXPIRE [key] [seconds]来设置过期时间「这种模式并没有原执性，使用set [key] [value] ex [seconds]来保证原子性」

3.3 避免同一时间大量的key过期

过期时间需要添加随机值

3.4 redis做一步队列（消息队列）

用list数据的pop操作和push的操作

• 使用BLPOP [key] [超时时间]来达到监听的效果
• 使用pub/sub主题订阅者模式做消息订阅的效果，用publish [topic] [msg]来发布消息，用subscribe [topic]来接受相关的消息，甚至不用创建频道。但是这个状态是无状态的，不保证送达，如果有更高的需求，就要使用专业的消息队列了

4 Redis持久化方式

4.1 RDB持久化

会在固定的间隔保存一次整个数据库的全量数据。使用save指令在主线程中进行RDB备份，使用bgsave指令使用fork的子线程完成备份

4.2 AOF持久化

相当于备份操作日志，每一个和写入有关的操作会被记录到一个文件中

四、Java相关知识点

1. ClassLoader

1.1 类从编译到执行的过程

• 编译器把.java文件编译成.class字节码文件
• ClassLoader将直接码读入内存中，转换为JVM中的Class对象
• JVM再使用Class对象将其实例化为对应的对象

1.2 ClassLoader

在JVM中，所有的类对象都是由ClassLoader进行加载的，主要功能是从class文件中的二进制数据流加载类对象，是Java的核心组件

• ClassLoader的种类

  • BootStrapClassLoader：是java的核心库，是C++编写的

  • ExtClassLoader：Java编写的，用于加载扩展库

  • APPClassLoader：Java编写，加载classpath下相关的文件

  • 自己定义的ClassLoader：用于定制化加载，只要传入的二进制流，就可以进行类的加载（从压缩包获取，从网络中获取等等）

    package com.libi.classloader;
    
    /**
     * @author :Libi
     * @version :1.0
     * @date :2020-03-05 20:56
     */
    public class MyClassLoader extends ClassLoader {
        private String path;
        private String classLoaderName;
    
        public MyClassLoader(String path, String classLoaderName) {
            this.path = path;
            this.classLoaderName = classLoaderName;
        }
    
        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            byte[] b = loadClassData(name);
            return defineClass(name, b, 0, b.length);
        }
    
        //从文件中读出class数据流，我这边不想写了
        private byte[] loadClassData(String name) {
            return null;
        }
    
        //如何通过自定义的ClassLoader进行类的加载
        public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
            //创建ClassLoader
            MyClassLoader myClassLoader = new MyClassLoader("path", "name");
            //生成类对象
            Class c = myClassLoader.loadClass("name");
            //生成实例
            Object o = c.newInstance();
        }
    }
    

• ClassLoader的双亲委派机制

  双亲委派机制

  ClassLoader中，加载类的部分源码如下

  protected Class<?> loadClass(String name, boolean resolve)
          throws ClassNotFoundException
      {
          synchronized (getClassLoadingLock(name)) {
              // 首先检查这个类是否被加载
              Class<?> c = findLoadedClass(name);
              if (c == null) {
                    //如果没有被加载那么委托它的父加载器，父加载器为空则委托Bootstrap加载器
                  long t0 = System.nanoTime();
                  try {
                      if (parent != null) {
                          c = parent.loadClass(name, false);
                      } else {
                          c = findBootstrapClassOrNull(name);
                      }
                  } catch (ClassNotFoundException e) {
                      // ClassNotFoundException thrown if class not found
                      // from the non-null parent class loader
                  }
  
                  if (c == null) {
                      // 如果父加载器仍然没有找到，就自己找
                      long t1 = System.nanoTime();
                      c = findClass(name);
  
                      // this is the defining class loader; record the stats
                      sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                      sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                      sun.misc.PerfCounter.getFindClasses().increment();
                  }
              }
              if (resolve) {
                  resolveClass(c);
              }
              return c;
          }
      }
  

• 为什么要使用双亲委派机制？

  避免一个类被加载多次，节约内存

1.3 类装载方式

类装改过程如下

类装载过程

• 隐试加载：new（顺带获取实例）
• 显示加载：
  • ClassLoader.loadClass：还没有完成链接，只完成加载
  • Class.forName：已经完成初始化

2. JVM内存模型

2.1 内存模型划分的区域

从线程的角度分类

Q45Q2XM6V~13}$7H5_N2N@8.png

• 程序计数器：相当于行号指示器，是线程独立的
• Java虚拟机栈：相当单个线程于虚拟机执行的调用栈，每个栈帧包括局部变量表，关键数，方法出口等信息
• 本地方法栈：调用本地方法是就会使用到本地方法栈

• 元空间（类似之前的永久代，元空间使用本地内存，但是永久代使用的是java管理的内存）
  • 字符串常量池存（现在代队内存中）在永久代中可能出现性能问题
  • 简化GC的操作
  • 永久代的大小指定不再成为问题
• Java堆

2.2 JVM常见问题

• JVM性能调优参数
  • -Xss：每个线程虚拟机栈的大小
  • -Xms：堆的初始大小
  • -Xmx：堆的最大大小
• 内存分配策略
  • 静态存储：编译时就可以确定的空间需求
  • 栈式存储：编译时未知，但是但是允许开始前夕可以确定
  • 堆式存储：运行时都无法确定使用的内存大小，完全动态分配

3. Java垃圾回收机制

3.1 判定为垃圾的算法

当一个java对象没有被任何对象引用时就会判定为垃圾

• 引用计数法

  • 任何对象里有引用计数器，当引用计数为0时，就会判定为垃圾
  • 优点：速度很快，不会影响程序、缺点：无法辨别循环引用的情况

• 可达性分析

  • 通过对象的引用链来判断是否可以从GC Root进行查找

    • GC Root：虚拟机栈、方法区的常量和静态引用的对象
    • JNI引用的对象
    • 活跃的线程对象
    可读性分析

3.2 垃圾回收算法

• 标记清除算法

  • 标记：扫描整个GC root，对存活的对象进行标记。清除：对整个堆进行扫描，清除不可达对象
  标记清除
  • 缺点：可能产生大量碎片空间导致无法利用

• 复制算法

  • 把整个堆空间分为对象面和空闲面，每次在创建对象在对象面，进行GC时把可用的对象复制到另一边

    复制算法

  • 解决的空间的碎片化问题，且适用于存活率较低的情况。但是会浪费50的空间，若存活率较高，则会产生大量复制操作，浪费时间。

• 标记整理算法

  • 标记：扫描整个GC root，对存活的对象进行标记。整理：移动存活的对象，移动到前端，再清除后面的所有的空间
    
    标记整理
  • 避免了空间的碎片，适用于存活率高的场景

3.3 分代收集算法

对内存进行分类，不同的空间使用不同的手机算法

空间划分

• 新生代的划分

  • Eden区：新创建的对象出生的区域
  • 两个Survivor区

  GC会先去清理Eden区域，把存活的对象放入Survivor区域，Survivor区域使用复制算法进行手机。当Survivor区域的对象连续存活一定时间后，将会进度老年代。

  当较大的对象会直接进入老年代

• 进入老年代的情况

  • 在Survivor区域存活次数超过一定数字时
  • Survivor区域装不下时
  • 新生成的大对象

• GC的分类

  Minor GC：用于新生代的GC

  Full GC： 用于老年代的GC，通常也会对新生代进行GC

  出发FullGC的条件

  • 老年代空间不足
  • 永久代空间不足
  • 预计下次MinorGC需要晋升到老年代的大小大于老年代的平均空间
  • 调用System.gc()

3.4 新生代的垃圾收集器

• 相关概念

  • Stop-the-World：JVM在执行GC时会停掉除了GC线程意外的所有线程
  • Safepoint：分析引用关系不会发生变化的时间点，只有程序执行到safepoint，gc才会停掉工作线程。如：循环跳转，方法调用等时间点

• Serial收集器：单线程收集器，必须停掉所有线程

serial

• ParNew收集器：多线程收集的Serial

parNew

• Parallel Scavengel收集器：面向吞吐量的GC，会尽可能后台完成任务
  • 吞吐量 = 运行时间/运行时间+GC停下来的时间

3.5 老年代收集器

• Serial Old收集器：单线程标记整理

serial old

• Parallel Old收集器：多线程的标记整理

parOld

• CMS收集器：可以后台运行一部分工作，使用标记清除算法

  CMS

CMS

• G1收集器
  • 是并行和并发的收集器
  • 可以分代收集

3.6 相关问题

• Java的finalize()方法有什么用

  这个方法会在将要被收集前调用，作用是让其有机会再次和GC Root链接（给其重生的机会）

• Java的强引用，弱引用，弱引用，虚引用

  • 强引用：宁可抛出OOM也不会释放掉还在被强引用的对象
  • 软引用：当内存不足时，即使对象还在被弱引用，这个对象也会被回收，用于高速缓存，可用于引用队列
  • 弱引用：每次GC都会被回收，但是因为GC线程优先级低，所以也不会被很快回收，可以配合引用队列
  • 虚引用：对GC来说和没有引用是一样的，用于跟踪对象的生命周期，必须配合引用队列

4. Java并发编程

4.1 java线程相关

• 进程和线程的区别

  进程是资源分配的最小单位，线程是cpu调度的最小单位。线程并没有被看作独立应用，只有独立的堆栈和局部变量，没有独立的地址空间

  线程和进程

• 如何给run()方法传递参数

  • 构造函数传参
  • 成员变量传参
  • 回调函数传参

• 如何处理线程的返回值

  • 主线程等待：使用Thread.join()的方法阻塞当前线程
  • 通过Callable接口实现：
    • 通过FutureTask类，传入Callable接口的实例，调用call()方法和get()方法，就可以获取到返回值
    • 通过线程池的submit()方法传入神经Callable接口的实例，通过返回的Future实例进行获得返回值

• 线程的状态

  • 新建（new）：创建后还没有启动的状态
  • 运行（Runnable）：线程正在运行或者等待cup时间
  • 等待（Waiting）：无限期等待，这个线程正在等待被唤醒
  • 有限等待（Time Waiting）：一定时间后会被系统自动唤醒
  • 阻塞（Blocked）：等改获取锁或者等待io
  • 结束（Terminated）：已经终止的线程，线程已经执行完成，不能再次运行
  线程的状态

• sleep()和wait()方法

  • wait方法用于让出锁（调用成为锁的对象的wait方法），可以让其他等待资源的线程获得锁
  • sleep方法只会让出cpu，锁的状态不会改变

• notify() 和notifyAll()

  • notifyAll会唤醒全部等待这个锁的线程，而notify只会唤醒一个
  • 这两个方法都不会释放自己的锁

• Thread.yiele()方法

  当前线程愿意让出cpu使用权，但是是否让出还是取决于调度器

• 如何中断线程

  • 已经被废弃的stop()方法，这个方法会暴力地停下线程，导致后续清理的问题
  • 调用interrupt()方法，希望线程结束。
    • 如果这时线程处在阻塞、等待的状态，那么就会马上抛出InterruptedException异常
    • 如果线程处于正常活动的状态，也只会把它的中断标志设置为true，线程仍会继续运行，至于要如何中断，需要自己实现

4.2 java中的锁

• synchronized的底层对锁的优化

  • 自适应自旋锁

    • 自旋：大部分情况下，线程只需要很短的时间就可以获取锁，这时进行线程状态切开销较大。因此通过让线程自行忙循环等待锁是否
    • 自适应自旋：自旋尝试的次数不再固定，由上一个获取到锁的自旋次数和现在拥有者的状态来决定。如果上一次线程是通过自旋获取到锁的，而且线程正在运行中，jvm就会认为自旋获取到锁的几率很大，就会增加自旋尝试次数

  • 锁消除：JIT编译时，会对上下文扫描，消除没有竞争的锁，避免不必要的开销

  • 锁粗化：如果对一个对象频繁进行加锁，也会消耗不少的资源，这时就会进行锁的粗化，扩大锁的范围

    ---

    锁的状态：无锁 ==> 偏向锁 ==> 轻量级锁 ===> (自旋锁？) ===> 重量级锁

  • 偏向锁：大多数情况总是一个线程获得了锁，因此一个线程获得锁后，锁就变成了偏向模式，该线程下一次获取锁事，不需要再做任何同步的操作就会获得锁。但是对于锁竞争比较激烈的场合并不适用

  • 轻量级锁：当第二个线程开始争夺锁后，锁的模式就升级成的轻量级模式。如果线程是交替执行同步快的时候，轻量级锁就会启动

  • 重量级锁：当有锁不再是两个线程交替执行而是开始等待时，锁就会变成重量级锁

• synchronized和ReentrantLock（重入锁）的区别

  • ReentrantLock是JUC包下的锁类，实现了多种实用的方法，基于AQS实现的
  • ReentrantLock一定要显示的释放锁，不然会导致该线程一直持有锁
  • ReentrantLock有比synchronized实现了更多的功能
    • 实现公平锁（给锁的顺序倾向于给等待时间最长的线程，比非公平锁性能降低）
    • 可以设置获取锁的超时时间
    • 判断是否有线程或特定线程是否在尝试获取该锁
    • 判断是否可以获得该锁
    • ReentrantLock的newCondition()方法获取的对象有awit()和singal()方法实现等待和通知操作
    • synchronized使用的是操作对象头中的MarkWord，ReentrantLock使用的是Unsafe类下的park()方法

4.3 JMM如何解决可见性的问题

• Java内存模型（JMM）：只是一个规范，它规定了程序中的变量访问内存的方式

  image.png
  • 所有的变量都存储在主内存中，所有的内存都可以共享访问。
  • 线程对变量的操作只能在工作内存中执行，线程把要操作的数据拷贝到自己的工作内存中，运行完成后再写回主内存，不会直接操作主内存

• 多线程共享内存可能会导致数据一致性的问题，因此JMM会对一些操作进行优化

  • 指令重排序：如果两个操作无法通过happens-before原则推导出来，才可以进行重排序

  • happens-before原则：A操作如果需要对B操作可见，则A，B存在happens-before原则。happens-before原则具体如下图
    

    image.png

    如果两个操作不满足上述任何一个规则，那么这两个操作就没有执行顺序上的保障，JVM会对这两个操作进行重排序。反之，如果A happens-before B，那么A的操作在B上就是可见的

  • volatile关键字：

    • 保障被其修饰的共享变量在所有线程中是可见的，对这个变量的任何改动都会立即反应到共享内存中
    • 禁止指令的重排序
    • 并不能保障操作的原子性，因此不能完全保障并发安全

  • volatile如何保障立即可见

    • 被volatie修饰的变量被改变时，JMM会立即刷新到主内存中
    • 每读一个volatile变量，JMM会对对应的工作内存置为无效，线程只能从主内存中读取

  • volatile如何保障禁止重排序

    • 插入内存屏障

4.4 乐观锁和CAS操作

• JUC包下提供了atomic包提供了很多原子性的数据类型和引用
• 缺点：
  • 如果循环时间太长，开销很大
  • 只能保障一个变量的原子性操作
  • ABA的问题

4.5 Java线程池

利用Executors提供的线程池可以满足不同场景的需求

线程池

• 使用线程池的原因

  • 减少创建线程的消耗，复用线程
  • 统一管理，调优和监控

• JUC的有关线程池的接口

  • Executor：只有executor()的方法，只是用于和任务提交和执行细节解耦

    public interface Executor {
        void execute(Runnable command);
    }
    

  • ExecutorService：扩展了Executer，提供了管理器和生命周期的方法

    public interface ExecutorService extends Executor {
    
        void shutdown();
    
        List<Runnable> shutdownNow();
    
        boolean isShutdown();
    
        boolean isTerminated();
    
        boolean awaitTermination(long timeout, TimeUnit unit)
            throws InterruptedException;
            //后面的代码略过
    }
    
    

  • ScheduledExecutorService：扩展ExecutorService，增加了Future和定时任务

• ThreadPoolExecutor线程池

  线程池
  • 线程池相关的参数
    • corePoolSize：核心线程数，长期驻留的线程数量
    • maximumPoolSize：线程可以创建的最大线程数量
    • woreQueue：当核心线程满了之后任务等待的队列。我们使用不同的队列，就会有不同的排列机制
    • keepAliveTime：当核心线程以外的线程闲置以后可以存活的时间
    • ThreadFactory：用于创建线程
    • handler：任务的拒绝策略
      • AbortPolicy：直接抛出异常
      • CallerRunsPolicy：使用调用者的线程执行任务
      • DiscardOldestPolicy：丢弃阻塞队列中最前的任务并且执行本任务
      • DiscardPOlicy：直接丢弃任务
      • 可也以自己实现RejectedExecutionHandler接口来自定义handler
  • 线程池中对任务的处理：
    • 如果当前线程数小于核心线程数，则创建一个线程执行（即使其他线程空闲）
    • 如果当前任务大于核心线程数，则封装后进入等待队列
    • 如果等待队列已满，则创建临时线程执行任务
    • 若当前线程数大于最大线程数，且阻塞队列已经满了，则通过handler定义的策略处理任务
  • 线程池的运行状态
    • Running：正在运行，线程池可以提交新的任务
    • Shutdown：正在停止，线程池不再接受新的任务，但是还会处理队列中的任务，调用线程池的shutdown()方法会使线程池进入这个状态
    • Stop：完全停止，线程池不再接受新的任务，也不处理队列中的任务，线程池中的线程会被中断，调用线程池的shutdownNow()方法或者shutdown状态的线程池执行完剩余任务会使线程池进入和这个状态
    • Tydying：所有的任务都已经终止了
    • Terminated：