文章目录

2022 Java秋招面试题-必备基础
- 一、语言基础
- - Java技术栈基础-语言基础
  - Java技术栈基础-spring
  - Java技术栈基础-netty
- 二、面向对象
- 三、存储
- - redis
  - mysql
- 四、网络
- 五、web服务、微服务、中间件
- 六、其他、资料

2022 Java秋招面试题-必备基础

一、语言基础

Java技术栈基础-语言基础

阿里巴巴Java开发手册 (黄山版)

在这个很卷的时代，这本阿里的java碧血剑谱，面试前，必须得刷一波吧~

java中是值传递还是引用传递？
双等号和equals的区别？
对于基本类型和引用类型 == 的作用效果是不同的：
基本类型：如果比较的是基本数据类型，则直接比较其存储的 “值”是否相等；
引用类型：如果比较的是引用类型的变量，则比较的是所指向的对象的地址；

追问？重写equals时要重写hashcode？那为什么非得重写hashcode呢？
例如String、Date等类对equals方法进行了重写，比较的是所指向的对象的内容。

hashCode() 方法被设计在 Object 类中，说明是希望所有的对象都能实现该方法，该方法是会返回一个对应于当前对象的一个整数，之所以所有对象都实现该方法是为了将来对象在查找时变得快捷。

如果我们想比较内容的话就需要在Student类里面重写equals方法和hashcode方法，这两个方法是属于Object里面的方法，任何类都隐式的继承了Object类。

那为什么非得重写hashcode呢？因为对象的比较有硬性规定：

应用执行期间，同一个对象内容不发生改变，经过多次调用，hashCode方法都必须始终返回同一个值。如果把对象重新copy到另外一个应用程序里，hashcode可以和上一个的不一样。
如果两个对象根据equals(Object)方法比较是相等的，那么所产生的的hashcode必须一样。
如果两个对象根据equals(Object)方法比较是不相等的，那么产生的hashcode可能一样，也可能不一样。
如果不重写，很明显是违反了第二条规定~
map和set

List接口有三个实现类：
LinkedList基于链表实现，链表内存是散列的，增删快，查找慢；
ArrayList基于数组实现，非线程安全，效率高，增删慢，查找快；
Vector基于数组实现，线程安全，效率低，增删慢，查找慢；

Set接口有两个实现类：
HashSet底层是由 Hash Map 实现，不允许集合中有重复的值，使用该方式时需要重写 equals()和 hash Code()方法；
TreeSet 需要排序
LinkedHashSet继承于 HashSet，同时又基于 LinkedHashMap 来进行实现，底层使用的是 LinkedHashMap

Map接口有四个实现类：
HashMap基于 hash 表的 Map 接口实现，非线程安全，高效，支持 null 值和 null 键；
HashTable线程安全，低效，不支持null值和null键；
TreeMap 排序
LinkedHashMap是 HashMap 的一个子类，保存了记录的插入顺序；
SortMap 接口TreeMap，能够把它保存的记录根据键排序，默认是键值的升序排序;

JVM、JDK与JRE的含义和区别？
String 是最基本的数据类型吗？
不是
解析：Java中的基本数据类型只有8个：byte，short，int，long，float，double，char，boolean，剩下的都是引用类型（reference type），枚举类型（enumeration type）也是引用类型。
HashMap红黑树原理
相比 jdk1.7 的 HashMap 而言，jdk1.8最重要的就是引入了红黑树的设计，红黑树除了插入操作慢其他操作都比链表快，当hash表的单一链表长度超过 8 个的时候，数组长度大于64，链表结构就会转为红黑树结构。当红黑树上的节点数量小于6个，会重新把红黑树变成单向链表数据结构。
为什么要这样设计呢？好处就是避免在最极端的情况下链表变得很长很长，在查询的时候，效率会非常慢。
ConcurrentHashMap: 线程安全版HashMap。

追问，ConcurrentHashMap是怎么实现线程安全的？

synchronized 关键字和 volatile 关键字

volatile 关键字是线程同步的轻量级实现，所以 volatile 性能肯定比synchronized关键字要好。但是 volatile 关键字只能用于变量而 synchronized 关键字可以修饰方法以及代码块。
volatile 关键字能保证数据的可见性，但不能保证数据的原子性。synchronized 关键字两者都能保证。
volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized 关键字解决的是多个线程之间访问资源的同步性。

追问，volatile的原理？
volatile主要通过汇编lock前缀指令，它会锁定当前内存区域的缓存（缓存行），并且立即将当前缓存行数据写入主内存（耗时非常短），回写主内存的时候会通过MESI协议使其他线程缓存了该变量的地址失效，从而导致其他线程需要重新去主内存中重新读取数据到其工作线程中。

JVM内存模型
VM内存模型主要分为三块：Java 堆内存(Heap)、方法区(Non-Heap)、JMV栈(JVM Stack)、本地方法栈（Native Method Stacks）、程序计数器（Program Counter Register）。

堆细分：新⽣代、⽼年代，对于新⽣代⼜分为：Eden区和Surviver1和Surviver2区；
对于JVM的⽅法区也可以称之为永久区，它储存的是已经被java虚拟机加载的类信息、常量、静态变量；Jdk1.8以后
取消了⽅法区这个概念，称之为元空间（MetaSpace）；
虚拟机栈是线程私有的，他的⽣命周期和线程的⽣命周期是⼀致的。⾥⾯装的是⼀个⼀个的栈帧，每⼀个⽅法在执⾏的时候都会创建⼀个栈帧，栈帧中⽤来存放（局部变量表、操作数栈、动态链接、返回地址）；
本地⽅法栈和虚拟机栈类似，不同的是虚拟机栈服务的是Java⽅法，⽽本地⽅法栈服务的是Native⽅法。

追问，堆内存的分配过程？

java为什么会内存泄漏？java内存泄漏的原因及解决办法
理论上来说，Java是有GC垃圾回收机制的，也就是说，不再被使用的对象，会被GC自动回收掉，自动从内存中清除。
但是，即使这样，Java也还是存在着内存泄漏的情况

长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露。
尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是Java中内存泄露的发生场景，

通俗地说，就是程序员可能创建了一个对象，以后一直不再使用这个对象，这个对象却一直被引用，即这个对象无用但是却无法被垃
圾回收器回收的，这就是Java中可能出现内存泄露的情况，例如，缓存系统，我们加载了一个对象放在缓存中(例如放在一个全局map
对象中)，然后一直不再使用它，这个对象一直被缓存引用，但却不再被使用。

检查java中的内存泄露，一定要让程序将各种分支情况都完整执行到程序结束，然后看某个对象是否被使用过，如果没有，则才能判定这个对象属于内存泄露。

wait() 和 notify()必须配合synchrozied关键字使用
线程安全的概念
线程安全是多线程编程时的计算机程序代码中的一个概念。在拥有共享数据的多条线程并行执行的程序中，线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行，不会出现数据污染等意外情况。

线程安全问题大多是由全局变量及静态变量引起的，局部变量逃逸也可能导致线程安全问题。

JAVA中sort()排序解析
Collections.sort调用的其实也是Arrays.sort()方法
java类加载机制
虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是虚拟机的类加载机制。
什么是双亲委派机制
双亲委派机制：
如果一个类加载器收到了类加载的请求，它不会自己加载，而是向上委托，让父类加载器去加载，每一层都如此，直到达到顶层。只有当父类加载器反馈自己无法完成加载请求，子类加载器才会尝试自己去加载，如果子类也加载不到，将报ClassNotFoundException异常。

类加载器：
从Java虚拟机的角度来看，只存在两种不同的类加载器：一种是启动类加载器，一种是继承抽象类java.lang.ClassLoader的。

启动类加载器（引导类加载器）Bootstrap ClassLoader：
由C/C++语言实现，该类加载器用于加载Java的核心库，用于提供JVM自身需要的类（加载包名为java、javax、sun等开头的）。
并不继承java.lana.ClassLoader，没有父加载器。为扩展类加载器和应用程序类加载器的父类加载器（这里的父类不指继承，请不要混淆）。

扩展类加载器Extension ClassLoader：
由Java语言编写，派生于ClassLoader类，父类加载器为启动类加载器（再次强调，此处的父类不指继承）。从java.ext.dirs系统属性所指定的目录中加载类库，或从JDK的安装目录的jre/lib/ext子目录（扩展目录）下加载类库。如果用户创建发JAR放在此目录下，也会自动由扩展类加载器加载。

应用程序类加载器（系统类加载器）Application ClassLoader：
由Java语言编写，派生于ClassLoader类，父类加载器为启动类加载器。它负责加载环境变量classpath或系统属性java.class.path指定路径下的类库。

双亲委派原则的好处：
1）避免重复加载同一个类；
2）防止用户任意修改java中的类；

追问， java自己写string类，可以吗？

如果当自己定义了一个String类，且包名也是java.lang，不会被加载。因为双亲委派机制，基于JVM的双亲委派机制，类加载器收到了加载类的请求，会把这个请求委派给他的父类加载器。而只有父类加载器自己无法完成加载请求时，子类才会自己加载。这样用户自定义的String类的加载请求就会最终达到顶层的BootStrap ClassLoader启动类加载器，
启动类加载器加载的是系统中的String对象，而用户编写的java.lang.String不会被加载。
如果自定义String和java自带的String不在同一个包下是可以加载的，但在应用的时候，需要用自己的类加载器去加载，否则，系统的类加载器永远只是去加载jre.jar包中的那个java.lang.String。

什么是泛型，我们为什么需要泛型？
JDK5提出了泛型这个概念，但是JDK5以前是没有泛型的。
把类型明确的工作推迟到创建对象或调用方法的时候才去明确的特殊的类型。

把类型当作是参数一样传递
<数据类型> 只能是引用类型

Java反射是什么？Java中为什么需要反射？反射要解决什么问题？
反射就是把java类中的各种成分映射成一个个的Java对象。
java怎么创建线程池？java线程的生命周期？java怎么创建线程？线程的生命周期？
线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方
式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
说明：Executors 返回的线程池对象的弊端如下：
1）FixedThreadPool 和 SingleThreadPool：
允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。
2）CachedThreadPool：
允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。
3）ScheduledThreadPool：Java 开发手册（黄山版）
允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。

java怎么创建线程？
jdk5之前有两种方式，一种是继承Thread类，另一种是实现Runnable接口。在jdk1.5后又为我们提供两种方式，一种是实现Callable接口，另一种就是使用线程池。

继承Thread类
继承Thread类需要我们重写run()方法，且将核心代码写到run方法中。
实现Runnable接口
实现Callable接口
使用线程池

threadlocal是什么？
ThreadLocal并不是一个Thread，而是Thread的局部变量。
ThreadLocal翻译成中文比较准确的叫法应该是：线程局部变量。或称为线程本地变量。
ThreadLocal是JDK包提供的，它提供线程本地变量，如果创建一乐ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个副本，在实际多线程操作的时候，操作的是自己本地内存中的变量，从而规避了线程安全问题。
java中异常怎么分类的的？
Throwable是所有异常的根，java.lang.Throwable
Throwable有两个直接子类，Error类和Exception类。
java的垃圾回收机制是什么？

Java技术栈基础-spring

什么是SpringIOC？如何理解SpringIOC？
IOC是inverse of control的简写，译为控制反转，是一种创建对象的思想。
就是将创建对象的权力交给Spring容器，其实就是让Spring容器帮你创建对象，而你不需要在javal代码中new对象了。

IoC是一种让服务消费者不直接依赖于服务提供者的组件设计方式,是一种减少类与类之间依赖的设计原则。
2. 什么是DI
所谓依赖注入，是指程序运行过程中，如果需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部的注入。

依赖注入（Dependency Injection），是这样一个过程：由于某客户类只依赖于服务类的一个接口，而不依赖于具体服务类，所以客户类只定义一个注入点。在程序运行过程中，客户类不直接实例化具体服务类实例，而是客户类的运行上下文环境或专门组件负责实例化服务类，然后将其注入到客户类中，保证客户类的正常运行。

SpringBoot 怎么使用事务？
SpringBoot也提供了数据库事务支持，其底层最终也是依靠数据库实现的。注@Transactional即可。

Java技术栈基础-netty

Netty 是什么？
Netty是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。
Netty是基于nio的，它封装了jdk的nio，让我们使用起来更加方法灵活。

Netty是最流行的NIO框架，它的健壮性、功能、性能、可定制性和可扩展性在同类框架都是首屈一指的。
典型的应用有：
阿里分布式服务框架 Dubbo，默认使用 Netty 作为基础通信组件，
还有 RocketMQ 也是使用 Netty 作为通讯的基础。
经典的 Hadoop 的高性能通信和序列化组件 Avro 的 RPC 框架，默认采用 Netty 进行跨界点通信，它的 Netty Service 基于 Netty 框架二次封装实现。

追问，Netty 怎么使用？

BIO、NIO和AIO的区别？
Java 中的 BIO、NIO和 AIO 理解为是 Java 语言对操作系统的各种 IO 模型的封装。

BIO：一个连接一个线程，客户端有连接请求时服务器端就需要启动一个线程进行处理。线程开销大。
将请求连接放入线程池，一对多，但线程还是很宝贵的资源。

Java IO的各种流是阻塞的。这意味着，当一个线程调用 read() 或 write() 时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了

NIO：NIO是一种同步非阻塞的I/O模型，在Java 1.4 中引入了NIO框架，对应 java.nio 包，提供了 Channel , Selector，Buffer等抽象。
一个请求一个线程，但客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
NIO是基于channel（通道）、buffer（缓冲区）操作的；selector（选择器）是用来监听channel的。

AIO：AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。

目前来说 AIO 的应用还不是很广泛，Netty 之前也尝试使用过 AIO，不过又放弃了。

二、面向对象

六大设计模式原则
设计模式七大原则中的“开闭原则”，也称为OCP原则
“开闭原则”是面向对象编程中最基础和最重要的设计原则之一。
开闭原则非常著名,只要是做面向对象编程的,甭管是什么语言,Java也好,C++也好,或者是Smalltalk,在开发时都会提及开闭原则。
其次,开闭原则是最基础的一个原则。

类、模块和函数（方法）等软件实体，应该对扩展开放，对修改关闭。

举例：
把创建Shape 类做成抽象类，并提供一个抽象的 draw 方法，让子类去实现即可，这样我们有新的图形种类时，只需要让新的图形类继承 Shape，并实现 draw 方法即可，使用方的代码就不需要修改了，从而满足了开闭原则。

什么是设计模式？为什么要使用设计模式？
设计模式，即Design Patterns，是指在软件设计中，被反复使用的一种代码设计经验。使用设计模式的目的是为了可重用代码，提高代码的可扩展性和可维护性。

为什么要使用设计模式？根本原因还是软件开发要实现可维护、可扩展，就必须尽量复用代码，并且降低代码的耦合度。设计模式主要是基于OOP编程提炼的。

什么是单例模式（Singleton）
保证一个类仅有一个实例，并提供一个访问它的全局访问点。

因为这个类只有一个实例，因此，自然不能让调用方使用new Xyz()来创建实例了。所以，单例的构造方法必须是private，这样就防止了调用方自己创建实例，但是在类的内部，是可以用一个静态字段来引用唯一创建的实例的。

说说你对工厂模式的理解？应用场景？
工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。

将对象的创建和对象本身的处理业务分离，这样可以降低耦合度，可以两者修改起来都相对容易。在调用工厂类方法时，由于是静态方法使得调用简单，直接通过类名调用传入正确的参数即可。

三、存储

redis

推荐刷一遍， Redis常见面试题总结与持久化

Redis支持的数据类型？
Redis支持五种数据类型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。

五种类型与类比java的模型
string --> String
hash --> Hashmap
list --> LinkList
set --> HashSet
sorted_set --> TreeSet

缓存穿透、缓存击穿、缓存雪崩

缓存穿透
缓存穿透的概念很简单，用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据库查询。发现也没有，于是本次查询失败。当用户很多的时候，缓存都没有命中，于是都去请求了持久层数据库。这会给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。
缓存击穿
这里需要注意和缓存穿透的区别，缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。
当某个key在过期的瞬间，有大量的请求并发访问，这类数据一般是热点数据，由于缓存过期，会同时访问数据库来查询最新数据，并且回写缓存，会导使数据库瞬间压力过大。
缓存雪崩
缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。和缓存击穿不同的是，缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。

缓存雪崩是指缓存由于某种原因（比如服务器宕机，网络不可达等）无法访问，造成所有请求直接打到MySQL，造成系统整体挂掉。

解决方案：
缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。
如果缓存数据库是分布式部署，将热点数据均匀分布在不同搞得缓存数据库中。
设置热点数据永远不过期。

缓存雪崩是因为大量数据在同一时间失效，造成数据大批量的访问数据库的现象。
解决办法是
方法一:可以设置数据的失效时间为一个随机值，让每一个数据失效的时间不一样，避免大范围的数据失效，这样就不会给数据库压力了;
方法二:对于“redis挂掉了，请求全部走数据库”，可以采取事发前:实现redis高可用(主从架构+Sentinel（哨兵）或者redisCluster(集群))，尽量避免挂掉;事发中:设置本地缓存(echcache)+限流（hystrix）;

事发后:redis持久化，重启后自动从磁盘上加载数据，快速恢复缓存数据。

redis的持久化方式
Redis的持久化有3种方式

快照方式（RDB Redis DataBase）将某一时刻的内存数据，以二进制的方式写入到磁盘当中；
文件追加方式（AOF Append Only File）记录所有的文件并以文本的形式追加到文件中；
混合持久化方式，Redis 4.0之后新增的方式，混合持久化是结合RDB和AOF的优点，在写入的时候先把当前的数据以RDB的形式写入到文件的开头，再将后续的操作以AOF的格式存入文件当中，这样既能保证重启时的速度，又能降低数据丢失的风险。

redis是单线程还是多线程
Redis4.0版本之前，使用的是单线程，一般来说，单线程的处理能力要比多线程差，但是Redis还能达到每秒数万级的处理能力。首先最重要的原因是，Redis的大部分操作都在内存中完成，并且采用了高效的数据结构，比如哈希表和跳表。其次，单线程可以避免多线程之间的竞争，省去了多线程切换带来的时间和性能上的开销，而且还不会导致死锁。最后，Redis采用了I/O多路复用机制处理客户端的socket请求，这样可以使Redis高效的进行网络通信，因为是基于非阻塞的I/O模型，就意味着I/O的读写流程不再阻塞。

Redis4.0版本之后，添加了多线程的支持，但这时的多线程主要体现在大数据的异步删除功能上，例如unlink key、flushdb async、flushall async等。

Redis6.0版本之后，采用了多个I/O线程来处理网络请求，这是因为随着网络硬件的性能提升，Redis的性能瓶颈有时会出现在网络I/O的处理上，所以为了提高网络请求处理的并行度，Redis6.0对于网络请求采用多线程来处理。但是对于读写命令，Redis仍然采用单线程来处理。

Redis 为什么那么快
腾讯架构师是如何解释：Redis高性能通信的原理（精华版）
参考URL: https://www.toutiao.com/article/7020366249465004581/

根据官方的基准测试数据，一台普通硬件配置的Linux机器上运行单个Redis实例，处理简单命令（O(n)或者O（logn）），QPS可以达到8W，如果使用pipeline批处理功能，QPS最高可以达到10W。

Redis的高性能主要依赖于几个方面。

C语言实现，C语言在一定程度上还是比Java语言性能要高一些，因为C语言不需要经过JVM进行翻译。
纯内存I/O，内存I/O比磁盘I/O性能更快
I/O多路复用，基于epoll的I/O多路复用技术，实现高吞吐网络I/O
单线程模型，单线程无法利用到多核CPU，但是在Redis中，性能瓶颈并不是在计算上，而是在I/O能力，所以单线程能够满足高并发的要求。从另一个层面来说，单线程可以避免多线程的频繁上下文切换以及同步锁机制带来的性能开销。

mysql

什么是数据库事务？
在数据库中，事务是指一组逻辑操作，无论成或败，都作为一个整体进行工作，要么全部执行，要么全部不执行。
事务的ACID四个特性

原子性(Atomicity)：事务作为一个整体被执行，包含在其中的对数据库的操作要么全部被执行，要么都不执行。
一致性（Consistency）：事务应确保数据库的状态从一个一致状态转变为另一个一致状态。一致状态的含义是数据库中的数据满足完整性约束。
隔离性(Isolation)：多个事务并发执行，一个事务的执行不应该影响其他事务的执行。
持久性(Durability)：已被提交的事务对数据库的修改应该永远永久保存在数据库中。传统的关系型数据库都支持ACIDa特性，具体来说是通过SQL语句支持事务功能。

事务的隔离级别都有哪些？事务的隔离级别
在事务的并发操作中可能会出现脏读，不可重复读，幻读。

Read uncommitted(读未提交)
Read committed(读提交)
Repeatable read(重复读)
Serializable （序列化）

什么是数据库索引,有哪些分类？索引有什么用？

MySQL按照逻辑分类，索引可分为：

主键索引：一张表只能有一个主键索引，不允许重复、不允许为 NULL；
唯一索引：数据列不允许重复，允许为 NULL 值，一张表可有多个唯一索引，但是一个唯一索引只能包含一列，比如身份证号码、卡号等都可以作为唯一索引；
普通索引：一张表可以创建多个普通索引，一个普通索引可以包含多个字段，允许数据重复，允许 NULL 值插入；
全文索引：让搜索关键词更高效的一种索引。

追问，索引何时应该使用？
1.主键，自动建立唯一索引
2.频繁作为查询的条件的字段
3.查询中与其他表关联的字段存在外键关系
4.查询中排序的字段，排序字段若通过索引去访问将大大提高排序的速度
5.查询中统计或者分组字段

追问，Mysql索引原理是什么？
索引的数据结构主要有B+树和哈希表，对应的索引分别为B+树索引和哈希索引。InnoDB引擎的索引类型有B+树索引和哈希索引，默认的索引类型为B+树索引。

什么是事务的隔离级别？有什么用？
隔离级别在一定程度解决了事务并发问题。
隔离级别越高，数据库事务并发执行性能越差，能处理的操作越少。
Mysql 默认采用的REPEATABLE_READ隔离级别.

四、网络

TCP三次握手原理？
一开始，双方都处于close状态，先是接收端监听某个端口，进入listen状态
第一次握手：发送syn包时，希望向接收端建立连接，并初始化序列号。此时发送端进入syn_sent状态
第二次握手：接收端接受到了syn包，发送ack+syn包，并初始化序列号，并将发送的序列号+1放入确认应答号中。此时接收端进入syn_rcvd状态
第三次握手：发送ack包，给确认应答号+1，表示收到了接收端的报文，进入establelisten状态
服务端收到了客户端的报文后，也进入了establelisten状态、

追问，timewait状态？

为什么“握手”是三次，“挥手”却要四次？
TCP协议如何保证可靠性
MTU是什么？

以太网EthernetII最大的数据帧是1518Bytes这样，刨去以太网帧的帧头（DMAC目的MAC地址48bits=6Bytes+SMAC源MAC地址48bits=6Bytes+Type域2Bytes）14Bytes和帧尾CRC校验部分4Bytes那么剩下承载上层协议的地方也就是Data域最大就只能有1500Bytes这个值我们就把它称之为MTU。

在网络层，因为IP包的首部要占用20字节，所以这的MTU为1500－20＝1480；　
在传输层，对于UDP包的首部要占用8字节，所以这的MTU为1480－8＝1472；

所以，在应用层，你的Data最大长度为1472。当我们的UDP包中的数据多于MTU(1472)时，发送方的IP层需要分片fragmentation进行传输，而在接收方IP层则需要进行数据报重组，由于UDP是不可靠的传输协议，如果分片丢失导致重组失败，将导致UDP数据包被丢弃。

从上面的分析来看，在普通的局域网环境下，UDP的数据最大为1472字节最好(避免分片重组)。

什么是粘包？怎么解决TCP粘包？UDP存在粘包问题吗？
UDP则是面向消息传输的，是有保护消息边界的，接收方一次只接受一条独立的信息，所以不存在粘包问题。

UDP 对应用层交下来的报文，既不合并，也不拆分，而是保留这些报文的边界。而接收方在接收数据报的时候，也不会像面对 TCP 无穷无尽的二进制流那样不清楚啥时候能结束。正因为基于数据报和基于字节流的差异，TCP 发送端发 10 次字节流数据，而这时候接收端可以分 100 次去取数据，每次取数据的长度可以根据处理能力作调整；但 UDP 发送端发了 10 次数据报，那接收端就要在 10 次收完，且发了多少，就取多少，确保每次都是一个完整的数据报。

跟 UDP 不同在于，TCP 发送端在发的时候就不保证发的是一个完整的数据报，仅仅看成一连串无结构的字节流，这串字节流在接收端收到时哪怕知道长度也没用，因为它很可能只是某个完整消息的一部分。

粘包出现的根本原因是不确定消息的边界。接收端在面对"无边无际"的二进制流的时候，根本不知道收了多少 01 才算一个消息。一不小心拿多了就说是粘包。

五、web服务、微服务、中间件

cookie、session有什么区别？
什么是jwt token？它有什么优缺点？
http、https有什么区别？
追问，tls、ssl工作在哪一层？

六、其他、资料

Docker的基本原理？和虚拟机有什么区别？