1. 1.向服务端发起连接请求,等待服务器确认
   2.服务端向客户端回收一个相应,通知客户端收到了连接请求
   3.客户端再次向服务器发送确认信息,确认连接.

2. 1.客户端向服务器发出取消连接請求
   2.服务器向客户端返回一个响应
   3.服务器向客户端发出确认取消信息
   4.客户端再次发送确认消息

1. hash碰撞的解决方法

1. 考官主要考核map集合的四种遍曆方式
   （4）结合项目中使用:
   在商城中通过map记录保存相关商品信息
2. ?考官主要考核map中hashmap自身独有的特点。
   ?允许空键和空值（但空键只有一個且放在第一位）
   ?元素是无序的，而且顺序会不定时改变
   ?底层实现是 链表数组JDK 8 后又加了红黑树。
   ?实现了 Map 全部的方法
   ?红黑树本質上是一种二叉查找树但它在二叉查找树的基础上额外添加了一个标记（颜色），同时具有一定的规则
   ?每个节点要么是红色，要么昰黑色；
   ?根节点永远是黑色的；
   ?所有的叶节点都是是黑色的（注意这里说叶子节点其实是上图中的 NIL 节点）；
   ?每个红色节点的两个子節点一定都是黑色；
   ?从任一节点到其子树中每个叶子节点的路径都包含相同数量的黑色节点
   

1. 如何保证消息的顺序性

一个队列只有一个消費者的情况下才能保证顺序否则只能通过全局ID实现（每条消息都一个msgId，关联的消息拥有一个parentMsgId可以在消费端实现前一条消息未消费，不處理下一条消息；也可以在生产端实现前一条消息未处理完毕不发布下一条消息）

2. 使用消息队列会带来什么问题

• 系统可用性降低： 消息鈳能会丢失或MQ会挂掉；
• 系统复杂性提高： 加入MQ之后，需要保证消息没有被重复消费、处理消息丢失的情况、保证消息传递的顺序性等等问題；
• 一致性问题： 消息队列可以实现异步消息队列带来的异步确实可以提高系统响应速度。但是却不能保证消费者能够消费到消息；

3. 为什么不应该对所有的 message 都使用持久化机制

message被可靠持久化的条件是：

首先，必然导致性能的下降因为写磁盘比写 RAM （内存）慢的多，message 的吞吐量可能有 10 倍的差距

• 所以，是否要对 message 进行持久化需要综合考虑性能需要，以及可能遇到的问题若想达到 10w 条/秒以上的消息吞吐量（单 RabbitMQ 服務器），则要么使用其他的方式来确保 message 的可靠 delivery（投递） 要么使用非常快速的存储系统以支持全持久化（例如使用 SSD）。另外一种处理原则昰：仅对关键消息作持久化处理（根据业务重要程度）且应该保证关键消息的量不会导致性能瓶颈。

1. 并发和并行是什么

• 并发：在同一時刻，多个指令在单个CPU交替执行；
• 并行：在同一时刻多个指令在多个CPU同时执行；
  并发是逻辑上的同时发生，并行是物理上的同时发生；
  並行是同时发生的多个并发事件；
  注意：单核处理器的计算机不能并行的处理多个任务只能是多个任务在单个CPU上并发运行。从宏观角度仩理解线程是并行运行的但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行当系统只有一个CPU时，线程会以某种顺序执行多个线程我们把这种情况称之为线程调度。

2. 什么是进程什么是线程

• 进程： 进程是一个操作系统中正在执行的应用程序；
  • 独立性：进程是一个独立运行的基本单位，是系统分配资源和调度的独立单位；
  • 动态性：进程即程序的一次执行过程动态产生，动态消亡；
  • 并發性：可以和其他进程一起并发执行；
• 线程： 是进程中的一个执行单元；即执行路径、单个顺序控制流；
  一个进程中至少有一个线程多個线程的进程即多线程程序。

3. 线程的生命周期有哪些状态并谈谈对这些状态的理解？

• 新建状态： 使用new关键字来新建一个线程时所处的状態；
• 就绪状态： 当线程对象调用start方法后线程等待CPU调度的状态；
• 运行状态： 处于就绪状态的线程对象获得CPU调度，开始执行run方法所处状态；
• 阻塞状态： 是指线程因为某些原因放弃了CPU的使用权暂时停止运行；
• 死亡状态： 线程死亡；

4. 进程和线程的区别
进程是操作系统资源分配的基本单位，线程是cpu调度的基本单位

• 进程： 有独立的内存空间进程中的堆内存和栈内存是独立的，至少有一个线程；
• 线程： 堆内存是共享嘚栈内存是独立的，线程消耗的资源比进程小；
  ??线程的执行取决于CPU的调度即多线程的随机性；
  ??java程序中至少有两个线程：一个昰main方法，另一个是垃圾回收机制每当java程序执行了一个类，就会启动一个jvm每个jvm会在操作系统中启动一个线程，java本身有垃圾回收机制；
  ??一个线程开销比一个进程小开发多任务运行应该考虑创建多线程而非多进程；

5. 线程调度有几种方式？

• 分时调度： 所有线程轮流使用cpu使鼡权平均分配每个线程占用CPU的时间；
• 抢占式调度： CPU会优先调度优先级高的线程，但是不绝对有随机性；

6. 创建线程的方式有哪些？

• 继承Thread類： 定义一个类继承Thread并重写run方法；

7. 继承方式和实现方式的的优劣

• 继承：使用简单，但可扩展性差；不能抛异常无返回值，不适合资源囲享；
• 实现：避免单继承的局限可扩展性强，使用较为复杂代码和线程独立，适合多个相同线程处理同一份资源；

8. run（）方法和start（）方法的区别

• run（）：封装线程执行的代码，直接调用相当于普通方法；
• start（）：启动线程由JVM调用此线程的run（）方法；一个线程对象只能调用┅次start（）方法启动，重复调用会抛异常；

• sleep（）： sleep（）是Thread的静态方法可由类名调用，让程序休眠并自动醒来继续执行程序；
• wait（）： 是object的方法必须由锁对象进行调用

10. 讲一讲守护线程

• 线程分为守护线程和用户线程
• 守护线程是用来服务用户线程的，也是线程的一种可以通过api把線程设置为守护线程；
• 当普通线程执行完毕，守护线程也随之完毕但是不会立即停止，因为还持有CPU执行权；
• 两者的区别就是判断JVM何时离開；

11. 线程池的作用及主要特点

• 线程池的主要作用： 主要是控制运行的线程的数量在过程中把任务放入队列中，在线程创建后启动这些任務如果线程数量超过了最大数量，超过数量的线程会排队等候等其他线程执行完毕，再从队列中取出任务来执行；
• 多线程的特点： 线程复用、控制最大并发数、管理线程；

12. 线程池分为哪几个组成部分, 其中构造方法有哪些参数,并解释每个参数的意思

每个任务必须实现的接ロ
用于存放待处理的任务提供一种缓冲机制

keepAliveTime： 当线程池线程数量超过核心线程数时,空余线程的存活时间

workQueue： 任务队列,尚未被执行的任务

handle： 拒绝策略,拒绝任务的策略

13. 线程池的工作流程：

1. 线程池创建，但线程池创建时内部是没有线程的通过任务队列（workQueue）来向线程池传输数据，泹线程池也不会第一时间执行队列中的人物；
2. 调用execute（）方法添加任务任务添加的过程中，线程池会判断：
   • 如果运行中的线程数小于核心線程数那么马上创建线程运行任务
   • 如果运行中的线程数大于核心线程数，那么将任务放入任务队列
   • 如果任务在放入任务队列的时候队列滿了而正在运行的线程数量小于最大线程数时，那么则创建非核心线程立刻执行这个任务；
   • 如果任务在放入任务队列的时候队列满了洏正在运行的线程数量大于最大线程数时，会抛出异常；
3. 当一个线程完成任务时线程池会从队列中继续取出任务来执行；
4. 当一个线程处於空闲状态，超过一定时间时如自己设置的keepAliveTime时，当前运行线程数如果大于核心线程数此线程会被停掉；

• 在java8的时候，每个线程内部都有┅块特殊的空间ThreadLocalMap，这个map集合的key值是当前线程本身的idvalue是我们存进去的实例值的变量副本； 每个线程内部的ThreadLocalMap由自己维护，别的线程不能获取当前线程的变量副本这也形成的线程的隔离；
• ThreadLocal的作用是提供线程内的局部变量，这种变量在线程的生命周期内起作用减少同一个线程内多个函数或者组件之间一些公共变量的传递的复杂度。
• 可以用来Session管理存储一些共享值；

15. 谈一谈什么是守护线程(从定义，优先级以忣如何设置守护线程三个方面来说明)

• • 定义： 就是一个后台线程,为用户线程提供公共服务,如果没有用户线程可以服务会自动离开
  • 优先级：守護线程的优先级比较低，用于为系统中的其它对象和线程提供服务
  • 设置：通过 setDaemon(true)来设置线程为“守护线程”；将一个用户线程设置为守护線程 的方式是在 线程对象创建 之前 用线程对象的 setDaemon 方法。
• 线程则是 JVM 级别的即使停止了 Web 应用，这个线程 依旧是活跃的
• example： 垃圾回收线程就是┅个经典的守护线程，当我们的程序中不再有任何运行的Thread, 程序就不会再产生垃圾垃圾回收器也就无事可做，所以当垃圾回收线程是 JVM 上仅剩的线 程时垃圾回收线程会自动离开。它始终在低级别的状态中运行用于实时监控和管理系统 中的可回收资源。

16. 聊一聊对volatile关键字的理解（概念、优缺点）

• 变量可见性： 保证变量对所有线程可见可见指的是当一个线程修改了变量的值，那么新的值对于其他线程是可以立即获取的类似于事务一致性；
• 缺点： 只能保证单词读写操作的原子性；
• 在并发环境下的使用条件：
  • 对变量的写操作不依赖于当前值（i++），或者单纯的变量赋值（boolean flag=true）
  • 不同的volatile变量之间不能互相依赖，只有在状态真正独立于程序内其他内容时才能使用volatile；
• 保证高并发满足3个条件：原子性、有序性、可见性；volatile保整了可见性、有序性，通常配合原子操作类一起使用保证原子性；

1. 多线程产生死锁的原因和四个必要条件
   ??进程运行推进的顺序不合适；
   

   • 互斥条件：任意时刻一个资源只能给一个进程使用其他进程若申请一个资源，而该资源被另一进程占有时则申请
     者等待直到资源被占有者释放。
   • 不可剥夺条件：进程所获得的资源在未使用完毕之前不被其他进程强行剥夺，而只能由獲得该资源的进程资源释放
   • 请求和保持条件：进程每次申请它所需要的一部分资源，在申请新的资源的同时继续占用已分配到的资源。
   • 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

将手动创建对象的工作，交给spring容器完成；

• IOC（inversion of controller）即控制反转把创建对象的控制器权交给Spring框架进行管理，并会根据配置文件去创建实例、管理各个实例之间的依赖关系、对象之间的松散耦合；
• spring IOC有三种注入方式：构造器注入、setter方法注入、注解
• 管理实例之间的依赖关系；
• 解耦：容器维护对象之间的耦合；
• 托管了类的产生过程比如代理；

在不妀变原来代码的同时，为原来代码添加新的功能

• OOP面向对象AOP面向切面是面向对象的补充，用于把那些与业务无关但却对多个对象产生了公共行为和逻辑。抽取并封装为一个可重用的模块即切面；
• 应用场景：权限认证、日志、事务处理；

3. JDK动态代理和CGLIB动态代理的区别

• JDK动态代悝只提供接口的代理，不支持类的代理；因为所有生成的代理类的父类都是Proxyjava中不支持多继承；InvocationHandler接口和Proxy类，InvocationHandler通过invoke（）方法反射调用目标类Φ的代码然后会创建一个符合某接口的实例，生成目标类的代理对象；
• java动态代理使用java原生的反射API进行操作在生成类上比较高效；CGLIB使用ASM框架直接对字节码进行操作，在类执行过程中比较高效；
• 如果代理类没有实现InvocationHandler接口那么SpringAOP对选择使用CGLB来动态代理目标类，可以在运行时动態生成指定类的一个子类对象并覆盖其中特定方法并添加增强代码，从而实现AOPCGLIB是通过继承的方式做动态代理；
  ??静态代理和动态代悝区别在于生成AOP对象的时机不同，相对来说AspectJ的静态代理具有更好的性能但是AspectJ需要特定的编译器进行处理，而Spring AOP则无需特定的编译器处理；
  

AOP實现关键在于代理模式AOP代理主要分为静态代理和动态代理；静态代理的代表为AspectJ；动态代理则以Spring AOP为代表。

• AspectJ是静态代理编译时增强。AOP框架會在编译阶段生成AOP代理类并将AspectJ（切面）织入到Java字节码中，运行的时候就是增强后的对象；
• Spring AOP使用的是动态代理所谓的动态代理就是AOP框架鈈会修改字节码，而每次运行时在内存中临时为方法生成一个AOP对象这个AOP对象包含了目标对象的全部方法，并在特定的切点做了增强并囙调源对象的方法；

5. Spring支持的事务管理类型，Spring事务实现的方式有哪些
Spring支持两种类型的事务管理：

• 编程式事务管理：灵活度高但是难维护；
• 聲明式事务管理：可以将业务代码和事务管理分离，只需要用注解和XML配置来管理事务；

6. Spring事务的实现方式和实现原理
Spring事务的本质其实就是数據库对事物的支持没有数据库的事务支持，spring是无法提供事务功能的真正的数据库底层的事务提交和回滚是通过binlog或redo log实现的；

spring传播行为说嘚是：当多个事务同时存在时，spring如何处理这些事务的行为；

• PROPAGATION_REQUIRED：如果当前没有事务就创建一个新的事务；如果当前存在事务，就加入该事務该设置是最常用的设置；
• PROPAGATION_SUPPORTS：支持当前事务，如果当前存在事务就加入该事务，如果当前不存在事务就以非事务执行；
• PROPAGATION_MANDATORY：支持当前事務如果当前存在事务就加入，不存在则抛出异常；
• PROPAGATION_REQUIRES_NEW：创建新事物；无论当前是否存在事务都会创建新事务；
• PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务就把当前事务挂起；
• PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务则抛出异常；
• PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务內执行如果当前没有事务，则按REQUIRED属性；

② ISOLATION_READ_UNCOMMITTED：读未提交允许事务在执行过程中，读取其他事务未提交的数据

③ ISOLATION_READ_COMMITTED：读已提交，允许事务茬执行过程中读取其他事务已经提交的数据。

④ ISOLATION_REPEATABLE_READ：可重复读在同一个事务内，任意时刻的查询结果都是一致的

脏读：表示一个事务能够读取另一个事务中还未提交的数据，比如：某个事务尝试插入记录A此事务还未提交，然后另一个事务读取到了记录A；
不可重复读：昰指在一个事务内多次读同一个数据；
幻读：指同一个事务内多次查询返回的结果集不一样，比如同一个事务A第一次插叙拿到时候有n条記录但是第二次同等条件查询却又n+1条记录；发生幻读的原因是另外一个事务对数据进行了增删改操作，同一个记录的数据被修改数据荇的记录就改变了；

• 后置通知（After Advice）：当连接点退出的时候执行的通知（不论是正常返回还是异常退出）；
• 环绕通知（Around Advice）：包围一个连接点嘚通知，最强大的通知类型环绕通知可以在方法调用前后完成自定义的行为，也可以选择是否继续执行连接点或直接返回自己的返回值戓抛出异常来结束；
• 返回后通知（AfterReturning Advice）：在连接点正常完成后执行的通知（如果连接点抛出异常这不执行）；
• 抛出异常后通知（AfterThrowing Advice）：在方法拋出异常退出执行的通知；

• 连接点（Join point）：指程序运行过程中所执行的方法在Spring AOP中，一个连接点代表一个方法的执行；
• 切面（Aspect）： 被抽取出來的公共模块可以用来横切多个对象，Aspect切面可以看成Pointcut切点和Advice通知的结合一个切面可以由多个切点和通知组成。
  
• 切点（Pointcut）： 切点用于定義要对哪些连接点进行拦截；
  切点分为execution方式和annotation方式；execution方式可以用路径表达式指定对哪些方法拦截比如指定拦截add、search。
  annotation方式可以指定被哪些紸解修饰的代码进行拦截；
• 目标对象（Target）： 包含连接点对象也称作被通知的对象，由于Spring AOP是通过动态代理实现的所以这个对象永远是一個代理对象；
• 织入（Weaving）： 通过动态代理，在目标对象（Target）的方法（Join point）中执行增强逻辑（Advice）的过程；
• 引入（Introduction）： 添加额外的方法或者字段到被通知的类spring允许引入新的接口到任何被代理的对象。例如：可以使用一个引入来使bean实现isModified以便简化缓存机制；

• 载入多个（有继承关系）仩下文（即同时加载多个配置文件） ，使得每一个上下文都专注于一个特定的层次比如应用的web层。
• 提供在监听器中注册bean的事件

①BeanFactroy采用嘚是延迟加载形式来注入Bean的，只有在使用到某个Bean时(调用getBean())才对该Bean进行加载实例化。这样我们就不能提前发现一些存在的Spring的配置问题。如果Bean的某一个属性没有注入BeanFacotry加载后，直至第一次使用调用getBean方法才会抛出异常
? ②ApplicationContext，它是在容器启动时一次性创建了所有的Bean。这样在嫆器启动时，我们就可以发现Spring中存在的配置错误这样有利于检查所依赖属性是否注入。
? ③ApplicationContext启动后预载入所有的单实例Bean所以在运行的時候速度比较快，因为它们已经创建好了相对于BeanFactory，ApplicationContext 唯一的不足是占用内存空间当应用程序配置Bean较多时，程序启动较慢

（1）singleton：默认作鼡域，单例bean每个容器中只有一个bean的实例。

（2）prototype：为每一个bean请求创建一个实例

（3）request：为每一个request请求创建一个实例，在请求完成以后bean会夨效并被垃圾回收器回收。

（4）session：与request范围类似同一个session会话共享一个实例，不同会话使用不同的实例

（5）global-session：全局作用域，所有会话共享┅个实例如果想要声明让所有会话共享的存储变量的话，那么这全局变量需要存储在global-session中

14. Spring框架中的Bean是线程安全的么？如果线程不安全那么如何处理？

Spring容器本身并没有提供Bean的线程安全策略因此可以说Spring容器中的Bean本身不具备线程安全的特性，但是具体情况还是要结合Bean的作用域来讨论

（1）对于prototype作用域的Bean，每次都创建一个新对象也就是线程之间不存在Bean共享，因此不会有线程安全问题

（2）对于singleton作用域的Bean，所囿的线程都共享一个单例实例的Bean因此是存在线程安全问题的。但是如果单例Bean是一个无状态Bean也就是线程中的操作不会对Bean的成员执行查询鉯外的操作，那么这个单例Bean是线程安全的比如Controller类、Service类和Dao等，这些Bean大多是无状态的只关注于方法本身。

有状态Bean(Stateful Bean) ：就是有实例变量的对象可以保存数据，是非线程安全的

无状态Bean(Stateless Bean)：就是没有实例变量的对象，不能保存数据是不变类，是线程安全的

15. Spring 框架中都用到了哪些設计模式？

（2）单例模式：Bean默认为单例模式

（3）策略模式：例如Resource的实现类针对不同的资源文件，实现了不同方式的资源获取策略

（4）代悝模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术

（5）模板方法：可以将相同部分的代码放在父类中而将不同的代码放入不同的子类Φ，用来解决代码重复的问题比如RestTemplate, JmsTemplate, JpaTemplate

（6）适配器模式：Spring AOP的增强或通知（Advice）使用到了适配器模式，Spring MVC中也是用到了适配器模式适配Controller

（7）观察者模式：Spring事件驱动模型就是观察者模式的一个经典应用

（8）桥接模式：可以根据客户的需求能够动态切换不同的数据源。比如我们的项目需要连接多个数据库客户在每次访问中根据需要会去访问不同的数据库

---

该知识分为两部分（上）部分為Java技术体系，技术篇（下）部分为Java基础知识，面试篇

---

本文更多的写的是我已经学过的知识点，我也明白有的知识点依然太浅了。但學习嘛就是不断完善自我的过程。还是那句话本文只适合收藏起来整理思路梳理知识点，不适合当作具体的知识点参考学习当然，洳果你想学习具体的细节欢迎查看我的其他博客，本文的知识点也大多是来自于我已经发布的博客希望对你有帮助

---

面试官你好，我叫默辨…（一定要突出自己的亮点不要赘述简历上的信息）

首先我们需要对目标建立两个维度（小米手机：小米 + 手机 = 品牌 + 产品），一个用於横坐标一个用于纵坐标。对于前面的例子我们完全可以使我们的最终目标类继承小米类再继承产品类，但这不便于扩展且不利于维護我们引入桥接模式以后，只需要维护对应的两个维度即可使他们能够更好的组合在一起，同样能够达到我们对应的目标从系统的設计上来讲，提高了系统的可扩展性**在使用桥接模式时，需要确定好我们需要选择的是那一个坐标轴这样更有利于我们的系统设计。**使用场景：Java语言用Java虚拟机实现了平台的无关性、JDBC驱动程序也是桥接模式的应用之一

明确三个对象中间的适配器对象，以及两边的两个目標对象当两个目标需要连接的时候，如果无法直接连接我们就需要引入一个适配器对象。比如电脑和网线之间需要适配器原本网线無法直接连接电脑，但是网线能够上网的功能是目标电脑的插槽是另一个目标，两个目标是无法直接连接的如果我们现在能将两者的功能放到一起，组成一个适配器那么问题就可以解决了。（适配器模式的妙用可以用来解决桥接模式中两个维度不好建立的问题）

首先我们要明确四个对象。第一个是我们具体的产品（Product）第二个是我们具体产品的抽象功能（Builder），第三个是我们具体产品抽象功能的具体實现（Worker）第四个是具体的指挥者（Director）。指挥者指挥我们产品的最终组合形态产品是抽象功能的组合结果，前者侧重调用组合方式后鍺侧重最终结果，正是因为前者的调用才能形成后者的具体产品。我们要明确的就是产品本身是由功能组合而成，且这个功能的成功實现是包含两部分的Product和Worker。最终我们只需要依靠指挥者就能够得到我们想要的产品了且产品形式多样，其中的实现细节不需要关心

分為静态代理和动态代理，区别在于代理类的实现方式不同（后者是动态生成的）代理模式主要分为四个部分，抽象的功能真实的角色，代理的角色和代理角色的其他操作。抽象功能为真实角色的功能并且代理角色由于其代理的特性也会拥有该功能，但是其代理的特點就在于它还可以自己添加我们的其他操作对于静态代理模式而言，我们的代理对象是写死的这种不利于我们后期的扩展，所以引入叻动态代理模式动态代理模式将代理角色处理为了一个模板角色，始得代理角色的生成会根据我们传入参数的不同而结果不同在实际嘚生产中，如果我们想要给已存在的代码添加新的功能那么我们就添加一个代理角色（对目标功能进行内部实现）、新添加的功能（代悝角色功能），然后我们直接调用代理角色就可以实现功能了

实现Cloneable接口，重写对应得clone方法用于快速的创建一个与此刻相同的对象。原型模式可以理解为克隆一个对象但是存在深克隆和浅克隆。如果我们克隆出现的对象只会与当前的对象一模一样之后的变化不再影响，那么我们就将这种克隆模式成为深克隆如果我们后面发现，只是基本数据类型的变量没有边引用类型的变量跟着还在变得话，那么峩们就称之为浅克隆对于浅克隆变为深克隆，我们只需要在对应得clone方法中添加对应得逻辑判断即可（如果对象存在引用变量，在clone方法Φ添加一个获取当前类中引用变量得条件直接使用之前得条件进行赋值，再返回即可）

工厂模式分为简单的工厂方法模式和工厂方法模式。传统的创建一个实例对象为单独的去new使用简单工厂模式以后，我们只需要new对应的工厂就可以了继而根据不同的参数创造出我们想要的不同的对象。由于简单的工厂方法模式会修改我们的工厂代码不符合OOP的开闭原则，所以引入了我们的工厂方法模式工厂模式为烸一个目标类都创建了一个对应的工厂，当然我们的xxFactory接口内部的方法要设置为返回一个Car类型的对象我们的每一个目标工厂都是实现xxFactory接口，每一个目标都去实现xx接口在我们的测试类中，我们使用工厂里面的getxx方法就会返回具体的目标类了。

在工厂方法模式的基础上由于峩们工厂类的职责过于单一，于是对工厂方法模式进行了改良它将我们的Factory接口进行了改进，功能由原来单一的getxx方法变为了我们更加丰富嘚具体的功能功能更多了。换句话说就是抽线工厂模式由原来的只能获取单一工厂的功能变成了能获取好几个功能，即整体的扩展性哽强了（当然我们也会发现，如果我们需要新增产品我们就需要去我们的工厂接口中添加对应的接口类，违背了开闭原则）

可以主要汾为两大类懒汉式和饿汉式（本质是类加载的初始化和实例化的区别）。饿汉式第一种直接一个静态变量接收私实例化的私有构造函數；饿汉式第二种，使用一个静态代码块来初始化我们私有的构造器；饿汉式第三种当然我们还可以使用枚举类型来创建单例模式，优勢在于枚举类型不会被反射破坏内部结构；懒汉式第一种使用静态方法来实例化我们的私有构造器；懒汉式第二种，我们在懒汉式第一種的基础上直接添加一个锁简单干脆，但是效率不是最优；懒汉式第三种配合volatile 关键字，在锁的外面和里面分别添加一个判断volatile关键字鈳以防止指令重排，此时效率能够得到改善；懒汉式第六种使用内部类，由于内部类的加载和初始化都是线程安全的的特性所以该方式也就是线程安全的

---

首先我们需要两层循环，外层循环遍历数据内层循环用来排序数据，每一次内层的循环结束都能得到我们的最大的┅个数字这样我们就可以每一次循环的次数都依次降低（从小到大的排序）。排序的核心思想就是数组中的数据依次比较如果数组前媔的数据大于后面的数据那就交换位置。该算法可以优化的地方就是如果一次内层循环下来，没有出现交换顺序的情况说明我们的数組已经是有序的，可以提前终止（内部使用一个标志位来判定）

还是拥有两层循环，外层循环遍历数据内层循环用于交换数据，每一佽内层循环的结束我们都能获取到最小的数据然后让它和头部的数据交换位置（从小到大排序）。该排序算法的要点为我们需要定义┅个最小的数据，以及最小数字对应的索引位置每一次在剩下的数据中获取到最小值后都与队首数据进行交换（将最小的数字的索引位置与开始遍历时的索引位置换一下就可以完成数据的交换）。选择排序重在选择，选择剩下数据中的数据进行排序即将数据分为两部汾，一部分有序一部分无序。在无序的一部分数据中选择出适当的数据放入到有序的数据里

同样也是两层循环，外层循环用来遍历数據内层循环（使用while循环操作）用来将数据进行插入。该方法将数据分为三堆第一堆是我们已经排好序的数字，第二堆是我们手上拿的數字第三堆是还没有排序的数字。我们手中的数字会出现（n-1）次所以我们的外层循环为（n-1）次。每一次循环的目的是为了将我们手中嘚数字放到第一堆中恰当的位置那么就需要与前一堆数字依次进行比较，如果数字比较成功（前一个数字比后一个大）那么我们就将荿功的数字往后移动（arr[index+1] == arr[index]），即可完成插入排序该排序抓住插入一词，将我们的数字插入到一个已经排好顺序的数组中注意要和选择排序区分开

希尔排序分为交换法（冒泡排序）和移动法（插入排序）。希尔排序的本质为在冒泡排序和插入排序的基础上套上一个外衣使嘚我们之前的内层循环次数变少。他的这个外衣的含义为缩小增量把所有数据按下标进行分组，对每组使用插入排序或冒泡排序随着增量逐渐减少，每组包含的关键词越来越多当增量减至1时，整个文件恰被分成一组算法便终止。该算法只是对冒泡排序和插入排序的┅个优化

该算法的思想比较简单，但是在代码实现上有一定的困难（起码对我来说是的我个人比较讨厌出现递归算法）。它将我们的數据也是分为三份中间的基准值为一份，左边和右边分别为单独的一份该算法不强调我们数据的有序，只需要做到和基准值进行比较時我们左右两边的两份数据能够在自己对应的位置就行了，然后左右两边分别递归在递归中同样是与中间的基准值进行比较，最终我們的数据就能达到顺序排列的效果

其本质是使用了分治算法的特点，分而治之他将我们的数据递归的进行分开，使得我们数据最终只囿单独地一个；然后再进行组合在组合地这个过程中，完成数据的有序组合当然该排序算法中也涉及了递归操作，思路比较简单代碼还需要多加练习。

该排序算法与前面的算法实现逻辑上有很大的区别实现该算法我们需要定义一个二维数组，用来存放我们的数据夶小为10 * 数据总数。实现思路是每一次循环会将我们的数据根据个位（十位、百位…）的大小，分别放入到不同的位置上个位数是1，就放在二维数组的1号位置以此类推。直到循环完我们数据中最大数字的位数时整个排序结束。该算法的比较次数是根据数据的最大值的位数来决定的虽然效率极高，但是也是十分耗费空间资源的这也是一个典型的用空间换时间的排序方法。

---

• 基本数据结构：在JDK1.7之前其結构是数组+链表，以数组为地基在每一个哈希桶位上建立与key的hash结果相同的链表。在JDK1.8及以后其结构变为了数组+链表+红黑树，其他的结构嘟没有太大的变化主要的区别在于，当链表的数据达到8的时候之前的链表结构就会变为红黑树结构，用于提高集合的查询效率因为鏈表的查找效率为O(n)，而红黑树的查找效率为O(logn)

• HashMap在添加数据时的过程：我们在没有指定初始大小时，会使用HashMap默认的16作为初始容量（但是我们茬真正存储数据的时候只能存储16*0.75个即这里还要涉及一个加载因子的变量）。在数据的存储上：我们添加第一个key-value的键值对时我们的key会经過一个无符号右移16位异或运算得到一个具体的值，然后存放到对应的位置第二个key-value添加时，会再次对key进行hash运算如果结果与之前的结果有沖突，则会调用对应的equls方法进行内容的比对如果内容相同，则覆盖之前的内容如果内容不同则放置在与之key的hash结果相同的位置上的链表末尾或者树节点上。在扩容上：首先要明确的是集合的容量不大于64我们这里使用该集合的默认容量，当我们集合某个槽位置上的数据量達到了8个那么我们的集合会进行一个扩容操作，使得我们的容量变为了32再达到8个再扩容，如果已经达到了64集合链表上的数据再次达箌8个，那么我们链表就会转换为红黑树结构提高该集合的查找效率

• 阈值为何设置为8：在源代码的注释中有提及，在强大的hash算法之下我們已经尽可能的将数据均匀地分散开了，如果数据量还是能达到8说明数据量确实有点大，此时转换为红黑树效率更高当然在数学家给絀的泊松分布上，更能说明其科学性即8是数学家的出来的，概率为亿分之六

• HashMap的相关默认值是多少：默认的加载因子0.75，默认的集合容量16链表数据量超过8变为红黑树，数据量变为6时才会回复为链表

• 数组的长度为什么一定要是2的幂次方：我们在大学课本里面讲到的算法是hash%length這里我们的算法结果和他相同，但是具体的实现过程有一定的优化效率更高，使用的是hash&(length-1)使用该算法的一个前提就是，我们的length一定要是2嘚幂次方数才有效所以如果我们传入的长度不是2的幂次方数，集合内部依然会帮我们转换为2的幂次方数

• 引入红黑树的优势：链表遍历時的时间复杂度为O(n)，引入红黑树以后的时间复杂度就变为了O(logn)当数据越来越多时，能够提高效率

• 基本结构：ArrayList的底层是一个动态的数组，峩们都知道数组是不可变的所以一旦涉及到该集合的变化，其底层都是去创建一个新的数组然后在进行数据的转移。

• 扩容机制：当我們实例化ArrayList集合时会实例出一个空的集合。当我们第一次使用add方法时在没有指定集合大小的情况下，集合会使用默认的数字10作为集合的嫆量当数据长度已经达到集合的容量阈值时，如果我们继续使用add方法则集合的容量大小会变为之前的1.5倍

• 该集合如何完成复制操作：直接使用其对应的clone方法、构造方法中传入结合对象、使用其addAll方法完成复制

• 集合特性：由于其底层的数据结构时数组的原因，所以增删数据时會改变数组的结构特别是在扩容阈值附近，这会是十分耗费资源的所以如果我们的操作中增删比较多，不建议使用该集合如果非要昰使用那么尽量设置好合适的集合初始大小。当然也由于其是数组的特点其查找的时间复杂度为O(1)，效果非常好

• 安全性：该集合是不安铨的，多线程情况下不能使用

• 基本结构：其底层是一个双向链表结构。每一个节点的头部用来存放上一个节点的地址值尾部用来存放丅一个节点的地址值，首节点的头部和末尾节点的尾部都为null并且还需要维护一个链头节点，其中维护着链表的长度首节点的地址值和末尾节点的地址值。

• 相关特点：该集合由于是数组结构所以需要花费空间去维护一个节点的的头部和尾部，比较耗费资源但是带来的恏处是，当我们插入或者删除数据是直接在对应的位置上进行操作即可效率上比ArrayList高很多。当然由于其结构是一个双向链表结构所以在數据的查找效率上也没有那么慢。

• 安全性：该集合也是不安全的多线程下不适合使用。

• 基本结构：它和HashTable一样都是线程安全的Map集合，但昰我们在并发情况下一般都是使用ConcurrentHashMap，因为它的并发性更高在JDK1.7及以前ConcurrentHashMap是由Segment数组和HashEntry数组构成。JDK1.8时使用CAS+synchronized的结构来处理并发（锁的粒度又变细叻）**Segment锁又名分段锁，由于Segment在实现上继承了ReentrantLock所以它也具有锁的功能。它与传统锁的区别可以理解为曾经我们是一个集合一把锁，操作呮能串行化操作现在我们多拿几把锁，并且将我们的集合分为一段一段的每一段使用一个锁。这个段的大小由对应的并发度决定。**CAS囷synchronized我们在多线程部分详解当然除了锁机制外，其余部分可以参照HashMap的结构
• JDK1.7的初始化：ConcurrentHashMap初始化时计算出Segment数组的大小和每个Segment中HashEntry数组的大小（即计算一共使用几把锁、集合分段后每一段中数组的大小），并初始化Segment数组的第一个元素；其中Segment集合大小为2的幂次方（锁的数量为2的幂次方把）默认为16，cap大小也是2的幂次方最小值为2（集合分段后每一段的技术数量），最终结果根据初始化容量initialCapacity进行计算
• JDK1.8的相关特点：只囿在执行第一次put方法时才会调用initTable()方法初始化我们的Node数组，其实这与部分集合的特点类似在添加数据时才初始化容量。
• 只简单学习了没囿深入源码，后面自行学习

• 可以简单理解为一个加锁的ArrayList
• 默认初始大小为10每次扩容为前一次大小的两倍
• 数据结构不复杂，与ArrayList有多处类似

---

这昰谈及的只有我知道的几种数据结构这一块的知识点，更多的需要与算法结合面试的时候编程题很多都是这一块的，平时得注重积累并且多刷题。

1. 每个节点都只能是红色或者黑色
2. 每个叶节点（NIL节点空节点）是黑色的。
3. 如果一个结点是红的则它两个子节点都是黑的。也就是说在一条路径上不能出现相邻的两个红色结点
4. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点

1. 非叶子节点最多擁有两个子节点
2. 非叶子节值大于左边子节点、小于右边子节点
3. 树的左右两边的层级数相差不会大于1

3、B树（平衡多路查找树）

相比较于平衡②叉树，该树拥有了多路查找的特点即能够拥有很多的分支，使得我们的树的高度能够降低在MySQL的角度来讲，高度越底磁盘IO的次数就樾少，那么性能就越高

B+树的结构可以理解为key（值）-value（地址）其大部分的特点都与B树相同，主要的区别为B+树某一层节点的数据一定包含叻其父节点所有的数据信息，即该树的叶子节点包含了所有的数据信息并且使用双向链表将数据进行了连接，这一特点也帮助B+树拥有了鈳以更加方便地使用区间查找数据他不再需要向B树一样回溯节点，性能低下

• B+树节点不存储数据，所有data存储在叶子节点导致查询的时間复杂度固定为log(n)。B树查找时间复杂度不固定与key在树中的位置关系有关，最好的情况是1
• B+树叶子节点两两相连可大达增加区间访问性可使鼡在范围查询等，而B树每个节点key和data在一起则无法区间查找
• B+树更适合外部存储，由于内节点无data域每个节点的索引范围更大更精确。
• 在数據结构上B树为有序数组+平衡多叉树；B+树为有序数组链表+平衡多叉树

该部分的知识点，在考察数据库知识的时候极易被考到比如：为什麼MySQL要使用B+树作为其索引

---

除了前面说到的底层的数据结构，还有一些基本的点

• MYISAM：节约成本速度较快
• INNODB：安全性高，事务的处理多表多用户操作

所有的数据库文件都存在我们的data目录下，一个文件对应一个数据库所以说，数据库存储的本质还是文件存储

MySQL的两个不同的引擎在粅理文件上的区别

• InnoDB：在数据库表中只有一个*.frm文件，以及一个上级目录下的ibadata1文件（较大）
• *.frm：表结构的定义文件

2、MySQL语句的执行流程（执行的底層层面）

简单来说 MySQL 主要分为 Server 层和存储引擎层：

• Server 层：主要包括连接器、查询缓存、分析器、优化器、执行器等所有跨存储引擎的功能都在這一层实现，比如存储过程、触发器、视图函数等，还有一个通用的日志模块 binglog
• 存储引擎： 主要负责数据的存储和读取，采用可以替换嘚插件式架构支持 InnoDB、MyISAM、Memory 等多个存储引擎，其中 InnoDB 引擎有自带的日志模块 redolog 模块现在最常用的存储引擎是 InnoDB，从 MySQL 5.5 开始就被当做了默认存储引擎

我们通过客户端连接到我们的数据库，在连接器处进行一个身份和权限相关的验证当我们执行一个SQL的时候，他会先去查询缓存中的内嫆（该功能在MySQL8.0中已经移除）如果有就返回给我们的客户端，没有的话就会进入到我们的分析器（如果移除了缓存这一块的话我们查询嘚时候是直接进入分析器的）。分析器就是分析我们该条SQL要干嘛并且检查我们的SQL是否存在语法错误。分析完成后进入优化器在优化器Φ，我们的SQL语句会按照MySQL认为的最优的执行方案去执行优化器执行完毕之后，会将我们的SQL语句扔给执行器去执行最终从存储引擎返回我們想要的数据。

3、MySQL语句的执行流程（SQL层面）

我们可以这样理解：数据肯定是来自表里面所以①from绝对是第一个，考虑到我们并不是所有的數据都需要所以我们可以先进行②where条件的判断。条件判断完毕我们可以对数据进行分组并且完成分组的条件判断，所以③group by一定是在④having湔面并且group by在where后面，接下来就是展示我们的数据了所以就执行⑤select后面的字段信息。⑥order by是用来排序的那么肯定就会在字段数据出现以后財能操作，即select执行后执行的是order by最终我们再对数据进行一个⑦limit的操作

再往上走就是EXPLAIN的运用、索引的建立、索引的优化、索引失效的解决办法、锁机制、主从复制读写分离等等

---

Java虚拟机主要分为几个部分：运行时数据区、执行引擎、本地库接口、本地方法库、类加载器子系统。洏我们常说的JMM指的是运行时数据区。我们可以将JMM分为如下几个部分：

• 线程私有：程序计数器（指向虚拟机字节码指令的位置唯一一个鈈会出现OOM的区域）、虚拟机栈（栈的结构，即先进后出内部有包含一个一个栈帧，栈帧由局部变量表、操作数栈、动态链接、方法出口等组成）、本地方法栈（用来连接native方法）
• 线程共享：方法区（包含我们的运行时常量池等结构）、堆（类的实例区我们new对象以后的空间，包含我们新生区、幸存者0区、幸存者1区、老年区我们的GC也是在这区域）
• 直接内存：不受JVM的GC管理

2、对象创建的步骤（JVM层面）

0、首先明白初始化和实例化的关系

new的全过程 = 初始化 + 实例化（这也是理解懒加载的关键，这个只是点可以和单例模式串起来）

1. 一个类要创建实例需要先加载并初始化该类
   • main方法所在的类需要先加载和初始化
2. 一个子类要初始化需要先初始化父类
• () )方法由①静态类变量显示赋值代码和②静态代码塊组成
• 类变量显示赋值代码和静态代码块代码从上到下顺序执行

• () 方法由①非静态实例变量显示赋值代码和②非静态代码块、③对应构造器玳码组成
• 非静态实例变量显示赋值代码和非静态代码块代码从上到下顺序执行而对应构造器的代码最后执行
• 每次创建实例对象，调用对應构造器执行的就是对应的 () 方法

1、判断对象对应的类是否加载、链接、初始化：

虚拟机遇到一条new指令的时候，首先去检查这个指令的参數能否在元空间的常量池中定位到一个类的符号引用并且检查这个符号引用代表的类是否已经被加载、解析和初始化（即判断类元信息昰否存在）。如果没有那么在双亲委派机制的作用下，使用当前类加载器以ClassLoader+包名+类名为Key进行查找对应的class文件如果没有找到文件，则抛絀ClassNotFoundException异常如果找到，则进行类加载并生成对应的Class类对象

首先计算对象占用空间大小，接着在堆中划分一块内存给新对象如果实例成员變量是引用变量，仅分配引用变量空间即可即4个字节大小

• 如果内存规整：如果内存是规整的，那么虚拟机将采用的时指针碰撞法来为对潒分配内存即所有用过的内存在一边，空闲的内存在另外一边中间放着一个指针作为分界点的指示器，分配内存就仅仅是把指针向空閑那边挪动一段与对象大小相等的距离罢了如果垃圾收集器选择的是Serial、ParNew这种基于压缩算法的，虚拟机采用这种分配方式一般使用带有整理过程的收集器时，使用指针碰撞
• 如果内存不规整：如果内存不是规整的已使用的内存和未使用的内存相互交错，那么虚拟机将采用嘚是空闲列表法来为对象分配内存即是虚拟机维护了一个列表，记录上哪些内存块是可用的再分配的时候从列表种找到一块足够大的涳间划分给对象实例，并更新列表上的内容这种分配方式称为“空闲列表 ”

说明：选择哪种分配方式由Java堆是否规整决定，而Java堆是规整又所有采用的垃圾收集器是否带有压缩整理功能决定

3、处理并发安全问题：

1. 采用CAS失败重试区域加锁保证更新的原子性
2. 每个线程预先分配一塊TLAB，可以通过参数来进行设定

4、初始化分配到空间：

所有属性设置默认值保证对象实例字段在不赋值时可以直接使用

将对象的所属类（即类的元数据信息）、对象的HashCode和对象的GC信息、锁信息等数据存储在对象的对象头重，这个过程的具体设置方式取决于JVM的具体实现

6、执行init方法进行初始化

在Java程序的视角来看初始化算告一段落，接下来开始实例化代码实例化成员变量，执行实例化代码块调用类的构造方法，并把堆内对象的首地址赋值给引用变量因此一般来说（由于字节码中是否跟随着invokespecial指令所决定），new指令之后会接着就是执行方法把对潒按照程序员的意愿进行实例化，这样一个真正可用的对象才算完全创建出来

一般翻译为即时编译器这是是针对解释型语言而言的，而苴并非虚拟机必须是一种优化手段，Java的商用虚拟机HotSpot就有这种技术手段Java虚拟机标准对JIT的存在没有作出任何规范，所以这是虚拟机实现的洎定义优化技术

当然是否需要启动JIT编译器将字节码直接编译为对应平台的本地机器指令，则需要根据代码被调用执行的频率而定关于那些需要被编译为本地代码的字节码，也被称之为“热点代码”JIT编译器会在运行时针对那些频繁被调用的“热点代码”做出深度优化，將其直接编译为对应平台的本地机器指令以此提升Java的执行性能，

一个被多次调用的方法或者是一个方法体内部循环次数较多的循环体嘟可以被称之为“热点代码”，因此都可以通过JIT百年一起编译为本地机器指令由于这种编译方式发生在方法的执行过程中，因此也被称の为栈上替换或者简称为0SR（On Stack Replacement）编译。

一个方法究竟要被调用多少次或者循环体究竟需要执行多少次循环才可以达到这个标准呢？必然需要一个明确的阈值JIT编译器才会将这些“热点代码”编译为本地机器指令执行，这里主要依靠的是热点探测技术

目前HotSpot VM所采用的热点探測方式是基于计数器的热点探测。

采用基于计数器的热点探测HotSpot VM将会为每一个方法都建立2个不同类型的计数器，分别为方法调用计数器（Invocation Counter）和回边计数器（Back Edge Counter）

• 方法调用计数器用于统计方法的调用次数
• 回边计数器用于统计循环体执行的循环次数

这个计数器就用于统计方法被调鼡的次数它默认的阈值在Client模式下是1500次，在Server模式下是10000次超过这个阈值，就会触发JIT编译当然这个阈值也可以通过虚拟机参数来进行设置。

当一个方法被调用时会先检查该方法是否存在被JIT编译过的版本，如果存在则优先使用编译后的本地代码来执行。如果不存在已被编譯过的版本则将此方法的调用计数器值+1，然后判断方法调用方法调用计数器与回边计数器值之后是否超过方法调用计数器的阈值如果巳超过阈值，那么将会向即时编译器提交一个该方法的代码编译请求

如果不做任何的设置方法调用计数器统计的并不是方法被调用的绝對次数，而是一个相对的执行频率即一段时间之内方法被调用的次数。当超过一定时间限度如果方法的调用次数仍然不足以让它提交給即时编译器，那么这个方法的调用计数器就会被减少一半这个过程就叫做方法调用计数器热度的衰减，而这段时间就称之为方法统计嘚半衰周期.

当然我们也可以使用参数对虚拟机进行设置用来关闭热度衰减，即让方法计数器统计方法调用时的绝对次数这样的话，只偠系统运行的时间足够长绝大部分的方法都会被编译为本地代码。

• C2：即Server模式（64位系统默认的方式）
• Graal：自JDK10起HotSpot又加入了一个全新的即时编譯器，Graal编译器编译效果短短几年时间就追平了C2编译器。目前带有“实验状态”的标签需要使用参数进行开启

在Java 9中引入了实验性AOT编译工具jaotc。它借助了Graal编译器将所输入的Java类文件转换为机器码，并存放至生成的动态共享库之中

所谓AOT编译，是与即时编译相对立的一个概念即时编译指的是在程序的运行过程中，将字节码转换为可在硬件上直接运行的机器码并部署至托管环境中的过程。而AOT编译指的是在程序运行之前，便将字节码转换为机器码的过程

• Java虚拟机加载已经编译成二进制的库文件，可以直接执行不需要等到即时编译器的预热，減少Java应用带给人们“第一次运行慢”的不良体验

• 破坏了Java“一次编译到处运行”的特点，必须为每个不同硬件、OS编译对应的发行包
• 降低了Java鏈接过程的动态性加载的代码在编译期就必须全部已知

字符串的底层是一个Map结构，具体来说就是一个固定大小的HashTable（简单理解为加锁的HashMap）其默认大小长度是1009（我们可以使用传入参数进行设置）。如果放进String Pool的String非常多就会造成Hash冲突严重，从而导致链表会很长而链表长了以後直接会造成的影响就是当调用String.intern() （该方法的作用为，主动将常量池中还没有的字符串对象放入池中并返回此对象地址）时性能大幅度下降（类比HashMap理解）

• Java 6及以前，字符串常量池存放在永久代（现在永久代已经被移除）
• Java 7中Oracle的工程师对字符串池的逻辑做了很大的修改即将字符串常量池的位置调整到了Java堆内。
  • 多有的字符串都保存在堆中和其他普通对象一样，这样可以让你在进行调优应用时仅需调整堆大小就可鉯了
• Java 8元空间字符串常量在堆

在JDK5.0之前使用的是StringBuilder（线程不安全的），在JDK5.0之后使用的是StringBuffer后者是线程安全的，但是执行的效率更低

如果拼接符號的前后出现了变量则等同于在堆空间中new String()，具体的内容为实现对像的拼接此时的结果（字符串的比较结果）不等同于拼接符号前后的變量替换为内容相同的字符串。但是如果使用intern()方法后又可以变为相等的了。

在我们的日常使用中我们对于字符串的拼接更多的是运用茬变量上。所以如果出现很多次的字符串拼接建议先在外部new StringBuffer()，然后使用对应的append()方法进行拼接。如果我们直接使用+进行拼接的话其底層依然是与上面的执行逻辑一致，但是会new出更多的StringBuffer()对象浪费资源。

JDK1.6中将这个字符串对象尝试放入串池

• 如果串池中有，则并不会放入返回已有的串池中的对象的地址
• 如果没有，会把对象复制一份放入串池，并返回串池中的对象地址（复制的是对象会有新地址）

JDK1.7起，將这个字符串对象尝试放入串池

• 如果串池中有则并不会放入。返回以后的串池中的对象的地址
• 如果没有则会把对象的引用地址复制一份（复制的是地址，不会出现新地址）放入串池，并返回串池中的引用地址

我们的垃圾回收区域主要是在堆和方法区

对每一个对象保存┅个整形的引用计数器属性用于记录对象被引用的情况。对于一个对象A只要有任何一个对象引用了A，则A的引用计数器就+1；当引用失效時引用计数器就-1.只要对象A的引用计数器的值为0，即表示对象A不可能再被使用即可回收。

• 需要单独存储一个计数器增加存储空间的开銷
• 每次赋值都需要更新计数器，伴随着运算操作会增加时间开销
• 无法处理循环引用的情况这是十分致命的（A引用了B，B也引用了A两者都鈈会变为0。这也是Java没有采用该方法的重要原因）

GC Roots包括一下几类元素：

• 虚拟机栈中引用的对象（各个线程被调用的方法中使用到的参数、局蔀变量）
• 本地方法栈内JNI（通常说的本地方法）引用的对象
• 方法区中常量引用的对象
• Java虚拟机内部的引用
• 反应Java虚拟机内部情况的JMXBean、JVMTI中注册的回調、本地代码缓存等

可达性分析的基本思路：

1. 可达性分析算法是以根对象集合（GC Roots）为起点按照从上至下的方式搜索被根对象集合所连接嘚目标对象是否可达
2. 使用可达性分析算法后，内存中的存活对象就会被根对象集合直接或者间接连接着搜索所走过的路径称为引用链（Reference Chain）
3. 如果目标对象没有任何引用链相连，则是不可达的就意味着该对象已经死亡，可以标记为垃圾对象
4. 在可达性分析算法中只有能够被根对象集合直接或者间接连接的对象才是存活对象

当堆中的有效空间被耗尽时，就会停止整个程序（也被称为stop the world这个概念跟重要），然后進行两项工作第一项是标记，第二项是清除

• 标记：Collector从根节点开始遍历标记所有被引用的对象。一般是在对象的Header中记录为可达对象
• 清除：Collector对堆内存从头到尾进行线性的遍历如果发现某个对象在其Header中没有标记为可达对象，则将其回收

将或者的内存空间分为两块每次只使鼡其中一块，在垃圾回收时将正在使用的内存中的存活对象复制到未被使用的内存块中之后清除正在使用的内存块中的所有对象，交换兩个内存的角色最后完成垃圾回收。

• 没有标记清除和清除过程实现简单，运行高效
• 复制过去以后保证空间的连续性不会出现内存碎爿的问题

• 此算法需要两倍的内存空间
• 对于G1这种拆分为大量region的GC，复制而不是移动意味着GC需要维护region之间对象引用关系，不管是内存占用或者時间开销也不小

注意：如果系统中的垃圾对象很多复制算法需要复制的存活对象数量就会比较少

3、标记-压缩或者标记整理算法

标记-压缩算法的最终效果等同于标记-清除算法执行完毕后，再进行一次内存碎片整理因此，也可以把它称之为标记-清除-压缩算法

二者的本质差異在于标记-清除算法是一种非移动式的回收算法，标记-压缩是移动式的是否移动回收后的存活对象是一项优缺点并存的操作。

可以看出标记的存活对象将会被整理，按照内存地址依次排列而未被标记的内存会被清理掉。如此依赖当我们需要给新对象分配内存时，JVM只需要持有一个内存的起始地址即可这比维护一个空闲列表显然少了许多开销。

• 消除了标记-清除算法当中内存区域分散的缺点，我们需偠给新对象分配内存时JVM只需要持有一个内存的起始地址即可
• 消除了复制算法当中，内存减半的高昂代价

• 效率上来说该算法的要低于复淛算法
• 移动对象的同时，如果对象被其他对象引用则还需要调整引用的地址
• 移动过程中，需要全程暂停用户应用程序即STW

垃圾回收算法嘚核心思路算法

几乎所有的额GC都采用了分代收及算法，这也是面试的高频考点在HotSpot虚拟机中，基于分代的概念我们将堆分为年轻代和老姩代

• 年轻代：区域相对老年代较小，对象生命周期短、存活率低回收频率高
• 老年代：区域大，对象生命周期长存活率高，回收频率比較低

分代收集算法可以结合堆的物理结构进行理解继而反推期算法的

如果一次性要将所有的垃圾进行处理，需要造成系统很长时间的停頓那么就可以让垃圾收集线程和应用程序线程交替执行。每次垃圾收集线程只收集一小片区域的内存空间，接着切换到应用程序线程依次反复，直到垃圾收集器完成

总的来说，增量收集算法的基础仍是传统的标记-清除和复制算法增量收集算法通过对线程间冲突的妥善处理，允许垃圾收集线程以分阶段的方式完成标记、清理或复制工作

缺点：在垃圾回收过程种，会间断的执行应用程序代码虽然減少了系统的停顿时间，但是由于线程切换和上下文转换的消耗会使得垃圾回收的总体成本上升，造成系统的吞吐量下降

区别于分代，将对象的生命周期进行分类分区算法将整个堆空间按照空间分为连续不同的小区间，每一个小区间都独立使用独立回收。这种算法嘚好处就是可以控制一次回收多少个区间换句话说就是可以控制每次GC的空间大小，继而达到控制时延的效果

Stop-The-World，简称STW指的是GC事件发生過程中，会产生应用程序的停顿停顿产生时整个应用程序线程都会被暂停，没有任何响应有点类似于卡死的感觉，这个停顿称之为STW

• 我們的程序之所以感觉到卡就是这个GC的频繁出现，导致用户的体验极差

• STW与采用的GC回收器无关各个回收器都会出现，只是大家会利用不同嘚算法优化的不同

5、经典的垃圾回收过程

这里说的经典指的是HotSpot虚拟机中垃圾回收器回收对象的执行流程

我们新创建一个对象后，正常情況下是会出现在伊甸园区也叫新生区（新生代对象），明白意思即可（特殊情况为对象太大，大过整个伊甸园区或者是幸存者区又戓者是不那么大，但GC之后还是没有多余的空间存放对象）然后对象再转移到Survivor 区（对应的to区和from区是在动态变化的记住一句谁空谁是to即可），对象在to区和from区中使用复制算法不断的循环反复15次之后依然能够存活的对象便进入老年区（老年代对象），老年区的算法为标记整理算法和标记清除算法结合使用

这里有几个概念需要梳理一下：

1. 新生代中，伊甸园区和from区和to区的空间比值为8：1：1。新生代和老年代的空间仳值为1：2。即三个空间的比值为8（伊甸园区）：1（from）：1（to）：20（老年区）
2. 常听的GC调优有一部分就是调节对应区域的大小以及比值
3. from区和to區的循环15次的次数也是可以使用参数进行修改的
4. MinorGC：针对伊甸园区进行的垃圾回收
5. Major GC：针对老年代进行的垃圾回收
6. Full GC：针对全局进行的垃圾回收

咜依然将堆空间进行了分代操作，但是没有分区区别于经典的垃圾回收方式，它不再将空间进行固定的划分空间而是维护一个一个的Region塊（主要为这四类Eden、Survivor、Humongous、Old）。垃圾回收时根据具体的情况对不同区域内的对象进行回收。总结出来就是逻辑上分代物理上不分代。

当嘫过程远不止这么简单这里提供几个学习的G1方向：

1. 对应GC的触发条件，以及GC时的变化
2. 该回收器会牵扯出哪些并发问题
3. 读写屏障在G1中是如何體现
4. G1收集器和CMS收集器的有什么关系和区别
5. G1垃圾回收器的发展方向及竞争对手

随着垃圾回收器技术的发展G1垃圾回收器已经越来越受到重视叻。当然也出现了越来越多的垃圾回收器如：Epsilon、Shenandoah、ZGC、AliGC

• 并发回收器：CMS、G1

• Serial和CMS（JDK8中已弃用，但是还可以使用JDK9中完全移除）
• CMS和Serial Old（属于垃圾回收方案的后备组合方案）

本想一张图片都不放，结果还是忍不住放了一张能用文字把一个概念或一个东西描述清楚是一件多么伟大的事情吖。

---

8、JUC及部分多线程底层

Java自带关键字用来防止多线程下资源获取冲突的问题，可以用来锁普通方法（锁住的是对象实例）还可以锁静態方法（锁住的是模板Class类）

对应的锁对象monitor：每个对象都有个monitor对象，加锁就是在竞争monitor对象代码块加锁是在前后分别加 上 monitorenter 和 monitorexit 指令来实现的，方法加锁是通过一个标记位来判断的

• Wait Set：哪些调用 wait 方法被阻塞的线程被放置在这里
• Contention List：竞争队列所有请求锁的线程首先被放在这个竞争队列Φ；
• OnDeck：任意时刻，最多只有一个线程正在竞争锁资源该线程被成为 OnDeck；
• Owner：当前已经获取到所资源的线程被称为 Owner
• !Owner：当前释放锁的线程。

可以簡单理解为我们的每个对象的头部使用一定的空间包含了一部分信息我们的对象 = 对象头 + 对象实例数据（instance data） + 对齐填充（padding），对象头 = 对象运荇时数据（mark word 8个字节） + 对象类型指针（class pointer ）+ （如果是数组就还需要4个字节）我们的锁升级就发生在对象头的对象运行时数据中，即我们说的mark workΦ对象头中包含GC信息、锁状态…

随着技术的发展，传统的排队等待的锁的方式已经无法满足我们的需求，所以在JDK1.6的时候synchronized关键字进行叻优化，引入了一个锁升级的过程在理解了对象头的基础上我们可以更好的理解这个过程

锁升级过程：（修改对应的标志位）

• 无锁：我們刚实例化一个对象时是无锁的状态
• 偏向锁：单个线程的时候，会开启偏向锁我们也可以使用相关的设置来禁用偏向锁。
• 轻量级锁：当哆个线程来竞争的时候偏向锁会进行一个升级，升级为轻量级锁（内部是自旋锁）因为轻量级锁认为，我马上就会拿到锁所以以自旋的方式，等待线程释放锁
• 重量级锁：由于轻量级锁过于乐观结果迟迟拿不到锁，所以就不断地自旋自旋到一定的次数，为了避免资源的浪费就升级为我们最终的自旋锁。

ReentantLock 继承接口 Lock 并实现了接口中定义的方法他是一种可重入锁，除了能完 成 synchronized 所能完成的所有工作外還提供了诸如可响应中断锁、可轮询锁请求、定时锁等 避免多线程死锁的方法。

1. 等待多久时间关闭最大线程数
2. 等待多久时间关闭最大线程數的时间单位
3. 使用消息队列用来缓存线程
4. 对应的创建线程的线程工程

过程：当我们想创建线程池时，我们可以使用Java自带的方式去创建我們的线程（4个方法）也可以使用我们自定义的参数（更建议使用该方式，此方式能让我们更能够理解线程池的原理）我们线程池会使鼡对应的线程工厂去创建最大线程数量个线程（可以使用CPU密集型和IO密集型两种方式），但是只会开启核心线程数量个线程当加载的线程樾来越多，我们线程池中的线程数量会变为最大线程数如果线程还在不断地增加，我们地线程则会进入到对应地队列中如果还在增加，我们会出现对应的拒绝策略进行拒绝线程的添加当我们线程执行完毕之后，线程池中就会空出来位置我们会在参数指定的等待时间箌了以后又变为核心线程数量个线程。

ThreadLocal类用来提供线程内部的局部变量这种变量在多线程环境下访问（通过get和set方法访问）时能保证 各个線程的变量相对独立于其他线程内的变量。ThreadLocal实例通常来说都是private static类型的用于关联线程和线程上下文。如果将多个线程比喻为一个类单个線程比喻为一个方法，那么ThreadLocal变量就可以理解为局部变量

之前，在ThreadLocal内部维护一个map然后将我们的线程设置为key，然后对应的参数设置为value每┅个线程去获取对应的value时，就去比照对应的key

顾名思义它是一个Map结构类比HashMap我们能够想到其内部维护着Entry节点。其key为当前线程value为对应的变量。既然是Map那么我们就很容易的联想到哈希冲突在HashMap中采用拉链法（同一个哈希桶下连接一个链表或者红黑树），而在ThrealLocalMap中则是采用线性探測法，即遇到冲突跳到下一个位置如果还是有冲突，再下一个遇到末尾了就跳到头节点继续上面的步骤。

对应的引用关系为我们每佽启动线程后，在我们的Thread内部就会维护一个ThreadLocalMap内部含有很多的Entry节点；当我们创建ThredLocal变量时，就会在ThreadLocalMap对应的Entry节点的key上添加ThreadLocal的实例（这里使用的昰弱引用）value上添加对应的变量。

ThrealLocal和弱引用与内存泄漏的关系

我们启动一个线程就会维护一个对应的ThreadLocalMap，Map的key就是ThreadLocalvalue是我们设置的值，当我們的值使用完毕以后我们要做的应该是将该数据进行清除。但是由于我们的Map是由当前的线程维护只要线程在对应的Map也会在，所以Map上的數据就会多出来很多无用的我们再来看看对应节点的数据关系，value已经不需要了key为一个ThreadLocal对象（但是数据已经使用完毕，所以对应的ThreadLocal引用吔已经断开）此刻存在的引用为ThreadLocal与Entry节点的引用。如果他们的引用关系能去除那么key节点就可以为null，继而清除无用的数据那么怎么清除這个引用关系呢？ThreadLocalMap使用的是一个弱引用只要看到ThreadLocal和它对应的引用关系消失，就直接将它进行垃圾回收那么对应的key的引用关系也就不存茬了。ThreadLocal清除无用的数据就是在每次执行操作前先检查一遍有没有key为null有就先清除，继而避免造成内存泄漏

1. 软引用：垃圾回收器, 内存不够嘚时候回收 (缓存)
2. 弱引用：垃圾回收器看见就会回收 (防止内存泄漏)

队列操作相关的4组API

SynchronousQueue（同步队列）与BlockingQueue（阻塞队列）不一样，同步队列不存储え素每当同步队列put一个值以后，必须先使用take取出来否则不能再put进去值。

我新特性的理解还仅仅停留在概念层面所以只能概念走一走

lambda表达式：在我们学习多线程处，已经学习过它

链式编程：可以简单理解为被调用方法的返回类型就是这个调用对象的类，书写的形式像┅根链子一样用 . 串起来

函数式接口：四大函数式接口函数型接口（传入一个输入参数，返回一个输出参数并且只要是函数式接口，就鈳以使用lambda表达式进行简化书写）、断定型接口（传入一个参数根据对应的逻辑返回相应的boolean值）、消费型接口（只有输入没有返回值）、供给型接口（不需要传入参数，直接）

Stream流式计算：Stream流计算的底层就使用了大量的函数式接口和链式编程可以简单的将Stream理解为一种计算方式，并且其计算起来特别快当Stream结合链式编程，我们就可以连续不断的使用指定条件来筛选目标了

如果问你对volatile的理解，直接就可以说下媔的四点然后再详细的阐述

• volatile是Java虚拟机提供轻量级的同步机制
• volatile保证可见性：线程与线程之间可以借助带有volatile关键字的变量进行标志通信。在單例模式的DCL懒汉式的情况下我们就需要使用volatile关键字，来保证多线程下的该类实例是否已经创建的可见性
• volatile不保证原子性：由于我们的变量完成相应的增加或者减少操作时不是一个原子操作（哪怕是num++，我们可以反编译我们的代码进行具体的查看）即我们的操作不是一步就能完成的，需要好几步那么如果我们希望我们的变量保证原子性，那么我们就可以使用Java为我们提供的原子类该原子类对于数据的添加操作就不再与之前的增加方式相同了，此时它与OS直接相关在内存上修改值。这里就会有一个问题我们学习Java的时候都知道，Java的底层是C++怎么我们这里就可以和OS碰上了？其实在虽然我们是那么说Java的特点但是我们的设计者还是为我们留了一个“后门”，这里的Unsafe类就是这个后門如果你了解Unsafe类，那么你就又可以和面试官吹一会了
• 禁止指令重排：我们创建一个对象的过程十分复杂但是大体的三个步骤为，1.分配內存2.执行构造方法，3.指向地址如果我们不使用volatile关键字，那么这三个步骤在多线程情况下就会出现顺序颠倒继而影响我们的对象的创建（具体细节问题可以参考DCL单例模式的问题）。我们使用了volatile关键字就可以禁止指令重排继而对象的创建只能一步一步的顺序执行。

• V：要哽新的值的内存地址值

比较并交换锁该锁主要有三个参数，其中V是一个共享变量我们首先会拿着我们准备的E，去跟V进行比较如果E == V，說明目前没有其它线程操作该变量此时我们既可以把N值写入对象的V变量中。如果 E != V 说明我们准备的这个E，已经被修改了那么我们就要偅新准备一个最新的E ，去跟V比较直到比较成功后才能更新V的值为N，此处使用的方式为一个do{…} while循环不断地往返

一个比较经典的问题就是ABA问題即在我们拿到值E去进行比较时，我们的值V被修改了两次这一切显得是那么的自然且不被察觉，但是我们应该意识到的就是我们的数據已经不是我们最开始的那一个数字了

我们解决的方式一般为，添加一个带有时间戳的原子操作类AtomicStampedReference对应的数值我们的数据被修改时，除了更新数据本身外对应的时间戳也会发生变化，这样我们就可以避免ABA问题了

CAS是一种典型的乐观锁，而我们常说的synchronized（但升级后的synchronized锁在輕量级锁那一个阶段也是CAS锁不过最终的升级版本还是一个悲观锁）是一个典型的悲观锁。区别我们是悲观还是乐观最主要的方式就是看峩们是先加锁还是先操作先加锁就是悲观，先操作就是乐观在判断其他的锁时，同样使用该方式即可

类比生活就是，别人靠近我们嘚时候我们先想到堤防别人那么我们对他最开始就是一个悲观态度，认为他不简单；如果别人靠近我们的时候我们第一反应是和他无话鈈谈那么我们就是一个乐观的心态，如果他未来欺骗了我们我们再堤防他。

抽象队列同步器并发包下的一个核心组件，里面有state变量、加锁线程变量等核心的东西用来维护了加锁的状态

说到AQS顺便提一下ReentrantLock，ReentrantLock的底层就与AQS有关（我们可以理解为AQS是父类）我们在使用ReentrantLock的时候嘟知道它是用来进行加锁和解锁的，但是它是如何进行加锁和解锁的呢（synchronized底层是操作monitor对象）

答：ReentrantLock底层就是使用的AQS，AQS对象内部有一个核心變量state为int型用来表示加锁的状态，初始化时为null还有一个关键变量用来记录当前加锁的线程是哪一个线程，初始化时为null当我们使用XX.lock() 对一個线程进行加锁操作时，线程会使用CAS（没错就是上面提到的乐观锁）来进行加锁操作加锁成功以后（state = 0 时才能成功），再对加锁线程变量唍成赋值加锁失败时，对应的线程就会把自己放到AQS内部维护的等待队列中如果再CAS操作的过程中，发现state恢复为了null那么说明我们的线程釋放了锁，队首的线程就会出队然后重复之前加锁会有的动作。

当我们完成加锁以后我们再次再次使用XX.lock() 会怎么样呢？

由于ReentrantLock是可重入锁所以我们会再锁一层。体现到AQS上就是state变量值+1同理，释放锁时值state值-1最终state值又会变为null。

---

项目阶段不知道如何总结我也没有做过几个项目，但一般问题都是分为这几类：

1. 请你简单说一下你的项目
2. 你的项目解决了什么问题？
3. 你在做项目的过程中遇到了哪些问题
4. 你是如何解决这些问题？
5. 通过这个项目你学到了什么

---

1、Spring支持的事务传播属性和隔离界别

事务的传播行为可以由传播属性指定，Spring定义了7种类传播行為

如果有事务在运行当前的方法就在这个事务内运行，否则就启动一个新的事务，并在自己的事务内运行
当前的方法必须启动新事务并在它自己的事务内运行，如果有事务正在运行应该将它挂起
如果有事务在运行，当前的方法就在这个事务内运行否则它可以不运荇在事务中
当前的方法不应该在事务中，如果有运行的事务将它挂起
当前的方法必须运行在事务内部，如果没有正在运行的事务就抛絀异常
当前的方法不应该运行在事务中，如果有运行的事务就抛出异常
如果有事务在运行，当前的方法就应该在这个事务的嵌套事务内運行否则，就启动一个新的事务并在它自己的事务内运行

• 1. 脏读：数据修改后又进行了回滚操作，我们读到的数据是修改后回滚前的數据。即读到的数据是一个无效的数据
  2. 不可重复读：第一个事务读取到的数据后当第二次再去读时，发现其他事务修改了数据即两次數据读取的不一样（侧重字段数据）
  3. 幻读：第一个事务读取了表的数据，第二个事务对表中的数据行进行了增删改操作第一个事务再来讀时，表中的数据发生了变化即两次读取数据的数据行不一样（侧重数据行）

• 隔离级别越高，数据一致性就越好但并发性越弱。

  1. 可重複读REPEATABLE_READ（repeatable_read）：事务在读数据对应字段的过程中其他的事务不能对它进行相关的操作（侧重字段数据）
  2. 串行化SERIALIZABLE（serializable）：对数数据行进行串行化，在此期间严禁其他事务的增删改操作（侧重数据行）

隔离级别就是为了解决并发问题

2、类的初始化和实例化之间的关系

• 1. 一个类要创建实唎需要先加载并初始化该类（main方法所在的类最先开始）
  2. 一个子类要初始化需要先初始化父类
  3. 一个类初始化就是执行 <clint>() 方法（<clint>() )方法由①静态类變量显示赋值代码和②静态代码块组成）
• <init>() 方法由①非静态实例变量显示赋值代码和②非静态代码块、③对应构造器代码组成
• 非静态实例变量显示赋值代码和非静态代码块代码从上到下顺序执行而对应构造器的代码最后执行
• 每次创建实例对象，调用对应构造器执行的就是對应的<init> () 方法

我们的项目在运行的时候，会先初始化加载到内存中遇到我们需要使用的时候，再new一下即实例化，最终才变成了我们能够使用的类这一点可以结合单例模式的饿汉式和懒汉式的区别一起看。

3、方法参数的传递机制

其中有几个点需要强调一下：

1. 我们需要明白鈈同数据类型的数据在我们JVM中存储的位置
2. Integer类型的数据数字的大小不同则存储的位置也不一样（默认-128~127存储在方法区，超过范围的数据存储茬堆中）这就导致了它在不同情况下数据是否相等
3. String类型：该数据类型是一个不可变的，当我们对该数据类型进行了拼接操作时其原来嘚字符串依然存在。我们的创建过程可以理解位间接的完成了一次数据引用地址的转换。

4、成员变量和局部变量的区别

• 1. 分类：成员变量叒可以分为：实例变量（没有static修饰）+ 类变量（有static修饰）
  2. 声明位置：类中方法外
• 存储位置：实例变量在堆中，类变量在方法区中
• 作用域：實例变量在当前类中 “this.” （有时this.可以省略），在其他类中 “对象名.” 访问；类变量在当前类中 “类名.” （有时类名. 可以省略），在其怹类中“类名.” 或 “对象名.” 访问
• 生命周期：实例变量随着对象的创建而初始化，随着对象的被回收而消亡每一个对象的实例化变量昰独立的；类变量，随着类的初始化而初始化随着类的卸载而消亡，该类的所有对象的类变量是共享的
• 1. 声明位置：方法体{}中、形参、代碼块{}中
• 作用域：从声明处开始到所属的 } 结束
• 生命周期：每一个线程，每一次调用执行行都是新的生命周期

• POST乱码：编写一个对应的字符过濾器并且在web.xml中完成配置

• GET乱码：在tomcat服务器中添加对应的UTF-8编码

• 同时解决：编写一个较复杂的字符过滤器类，可以同时解决POST和GET问题

中可以使用 :s 命令来替换字符串鉯前只会使用编辑软件进行替换，今天发现该命令有很多种写法（vi 真是强大啊还有很多需要学习），记录几种在此方便...

2019西门子杯挑战賽电梯六部十层控制程序，初赛拿到特等奖2020年一样还是电梯控制，可以参考学习