Interview Mock

一面

A

（1）TCP三次握手和四次挥手，以及为什么要挥手4次呢？

首先来理解一下TCP的报文格式：

Wrk3ct.jpg

序列号seq：占4个字节，用来标记数据段的顺序，TCP把连接中发送的所有数据字节都编上一个序号，第一个字节的编号由本地随机产生；给字节编上序号后，就给每一个报文段指派一个序号；序列号seq就是这个报文段中的第一个字节的数据编号。

​ 确认号ack：占4个字节，期待收到对方下一个报文段的第一个数据字节的序号；序列号表示报文段携带数据的第一个字节的编号；而确认号指的是期望接收到下一个字节的编号；因此当前报文段最后一个字节的编号+1即为确认号。

​ 确认ACK：占1位，仅当ACK=1时，确认号字段才有效。ACK=0时，确认号无效

​ 同步SYN：连接建立时用于同步序号。当SYN=1，ACK=0时表示：这是一个连接请求报文段。若同意连接，则在响应报文段中使得SYN=1，ACK=1。因此，SYN=1表示这是一个连接请求，或连接接受报文。SYN这个标志位只有在TCP建产连接时才会被置1，握手完成后SYN标志位被置0。

​ 终止FIN：用来释放一个连接。FIN=1表示：此报文段的发送方的数据已经发送完毕，并要求释放运输连接

​ PS：ACK、SYN和FIN这些大写的单词表示标志位，其值要么是1，要么是0；ack、seq小写的单词表示序号。

字段 含义
URG 紧急指针是否有效。如果为1，表示某一位需要被优先处理
ACK 确认号是否有效，一般置为1
PSH 提示接收端应用程序立即从TCP缓冲区把数据读走
RST 对方要求立即重新建立连接，复位
SYN 请求建立连接，并在其序列号的字段进行序列号的初始值设定。建立连接，设置为1
FIN 希望断开连接

TCP三次握手过程

WrkFpR.png

第一次握手：建立连接时，客户端发送syn包（syn=j）到服务器，并进入SYN_SENT状态，等待服务器确认；SYN：同步序列编号（Synchronize Sequence Numbers）。

第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；

第三次握手：客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK(ack=k+1），此包发送完毕，客户端和服务器进入ESTABLISHED（TCP连接成功）状态，完成三次握手。

四次挥手过程理解

WrELpd.png

1）客户端进程发出连接释放报文，并且停止发送数据。释放数据报文首部，FIN=1，其序列号为seq=u（等于前面已经传送过来的数据的最后一个字节的序号加1），此时，客户端进入FIN-WAIT-1（终止等待1）状态。 TCP规定，FIN报文段即使不携带数据，也要消耗一个序号。

2）服务器收到连接释放报文，发出确认报文，ACK=1，ack=u+1，并且带上自己的序列号seq=v，此时，服务端就进入了CLOSE-WAIT（关闭等待）状态。TCP服务器通知高层的应用进程，客户端向服务器的方向就释放了，这时候处于半关闭状态，即客户端已经没有数据要发送了，但是服务器若发送数据，客户端依然要接受。这个状态还要持续一段时间，也就是整个CLOSE-WAIT状态持续的时间。

3）客户端收到服务器的确认请求后，此时，客户端就进入FIN-WAIT-2（终止等待2）状态，等待服务器发送连接释放报文（在这之前还需要接受服务器发送的最后的数据）。

4）服务器将最后的数据发送完毕后，就向客户端发送连接释放报文，FIN=1，ack=u+1，由于在半关闭状态，服务器很可能又发送了一些数据，假定此时的序列号为seq=w，此时，服务器就进入了LAST-ACK（最后确认）状态，等待客户端的确认。

5）客户端收到服务器的连接释放报文后，必须发出确认，ACK=1，ack=w+1，而自己的序列号是seq=u+1，此时，客户端就进入了TIME-WAIT（时间等待）状态。注意此时TCP连接还没有释放，必须经过2∗∗MSL（最长报文段寿命）的时间后，当客户端撤销相应的TCB后，才进入CLOSED状态。

6）服务器只要收到了客户端发出的确认，立即进入CLOSED状态。同样，撤销TCB后，就结束了这次的TCP连接。可以看到，服务器结束TCP连接的时间要比客户端早一些。

可能的问题

【问题1】为什么连接的时候是三次握手，关闭的时候却是四次握手？

答：因为当Server端收到Client端的SYN连接请求报文后，可以直接发送SYN+ACK报文。其中ACK报文是用来应答的，SYN报文是用来同步的。但是关闭连接时，当Server端收到FIN报文时，很可能并不会立即关闭SOCKET，所以只能先回复一个ACK报文，告诉Client端，“你发的FIN报文我收到了”。只有等到我Server端所有的报文都发送完了，我才能发送FIN报文，因此不能一起发送。故需要四步握手。

【问题2】为什么TIME_WAIT状态需要经过2MSL(最大报文段生存时间)才能返回到CLOSE状态？

答：虽然按道理，四个报文都发送完毕，我们可以直接进入CLOSE状态了，但是我们必须假想到网络是不可靠的，有可能最后一个ACK丢失。所以TIME_WAIT状态就是用来重发可能丢失的ACK报文。在Client发送出最后的ACK回复，但该ACK可能丢失。Server如果没有收到ACK，将不断重复发送FIN片段。所以Client不能立即关闭，它必须确认Server接收到了该ACK。Client会在发送出ACK之后进入到TIME_WAIT状态。Client会设置一个计时器，等待2MSL的时间。如果在该时间内再次收到FIN，那么Client会重发ACK并再次等待2MSL。所谓的2MSL是两倍的MSL(Maximum Segment Lifetime)。MSL指一个片段在网络中最大的存活时间，2MSL就是一个发送和一个回复所需的最大时间。如果直到2MSL，Client都没有再次收到FIN，那么Client推断ACK已经被成功接收，则结束TCP连接。

【问题3】为什么不能用两次握手进行连接？

答：3次握手完成两个重要的功能，既要双方做好发送数据的准备工作(双方都知道彼此已准备好)，也要允许双方就初始序列号进行协商，这个序列号在握手过程中被发送和确认。

​ 现在把三次握手改成仅需要两次握手，死锁是可能发生的。作为例子，考虑计算机S和C之间的通信，假定C给S发送一个连接请求分组，S收到了这个分组，并发 送了确认应答分组。按照两次握手的协定，S认为连接已经成功地建立了，可以开始发送数据分组。可是，C在S的应答分组在传输中被丢失的情况下，将不知道S 是否已准备好，不知道S建立什么样的序列号，C甚至怀疑S是否收到自己的连接请求分组。在这种情况下，C认为连接还未建立成功，将忽略S发来的任何数据分 组，只等待连接确认应答分组。而S在发出的分组超时后，重复发送同样的分组。这样就形成了死锁。

【问题4】如果已经建立了连接，但是客户端突然出现故障了怎么办？

TCP还设有一个保活计时器，显然，客户端如果出现故障，服务器不能一直等下去，白白浪费资源。服务器每收到一次客户端的请求后都会重新复位这个计时器，时间通常是设置为2小时，若两小时还没有收到客户端的任何数据，服务器就会发送一个探测报文段，以后每隔75秒钟发送一次。若一连发送10个探测报文仍然没反应，服务器就认为客户端出了故障，接着就关闭连接。

参考：TCP三次握手和四次挥手过程

（2）CLOSE-WAIT和TIME_WAIT的相关内容，分别是做什么用的？分别在哪一个端存在？

​ i.根据上述分析内容， CLOSE_WAIT就是 服务器收到连接释放报文后，进入到CLOSE_WAIT的状态，这时候TCP服务器通知高层的应用进程，客户端向服务器的方向就释放了，这时候处于半关闭状态，即客户端已经没有数据要发送了，但是服务器若发送数据，客户端依然要接受。这个状态还要持续一段时间，也就是整个CLOSE-WAIT状态持续的时间。

​ ii.客户端收到服务器的连接释放报文后，必须发出确认，ACK=1，ack=w+1，而自己的序列号是seq=u+1，此时，客户端就进入了TIME-WAIT（时间等待）状态。注意此时TCP连接还没有释放，必须经过2∗∗MSL（最长报文段寿命）的时间后，当客户端撤销相应的TCB后，才进入CLOSED状态。

（3）线程和进程的区别是什么？

（1）进程

进程是程序的一次执行过程，是一个动态概念，是程序在执行过程中分配和管理资源的基本单位，每一个进程都有一个自己的地址空间，至少有 5 种基本状态，它们是：初始态，执行态，等待状态，就绪状态，终止状态。

（2）线程

线程是CPU调度和分派的基本单位，它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

（3）联系

线程是进程的一部分，一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。

（4）区别：理解它们的差别，我从资源使用的角度出发。（所谓的资源就是计算机里的中央处理器，内存，文件，网络等等）

根本区别：进程是操作系统资源分配的基本单位，而线程是任务调度和执行的基本单位

在开销方面：每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。

所处环境：在操作系统中能同时运行多个进程（程序）；而在同一个进程（程序）中有多个线程同时执行（通过CPU调度，在每个时间片中只有一个线程执行）

内存分配方面：系统在运行的时候会为每个进程分配不同的内存空间；而对线程而言，除了CPU外，系统不会为线程分配内存（线程所使用的资源来自其所属进程的资源），线程组之间只能共享资源。

包含关系：没有线程的进程可以看做是单线程的，如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（线程）共同完成的；线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程。

（4）了解算法吗，排序算法常用的说一说？稳定的算法都是什么？什么叫做稳定？

排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。下面讲的排序都是属于内排序。内排序有可以分为以下几类：

(1)、插入排序：直接插入排序、二分法插入排序、希尔排序。 (2)、选择排序：简单选择排序、堆排序。 (3)、交换排序：冒泡排序、快速排序。 (4)、归并排序 (5)、线性时间排序：计数排序、基数排序、桶排序

WrGaLD.jpg

说下快排思想：

快速排序使用分治策略来把一个序列（list）分为两个子序列（sub-lists）。步骤为：

① 从数列中挑出一个元素，称为”基准”（pivot）。 ② 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。 ③ 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

参考

排序算法总结1

排序算法总结2

（5）对于调度算法了解吗，都有什么，描述一下？

​ # 进程调度算法

  • 先进先出算法(FIFO)：按照进程进入就绪队列的先后次序来选择。即每当进入进程调度，总是把就绪队列的队首进程投入运行。

  • 时间片轮转算法(RR)：分时系统的一种调度算法。轮转的基本思想是，将CPU的处理时间划分成一个个的时间片，就绪队列中的进程轮流运行一个时间片。当时间片结束时，就强迫进程让出CPU，该进程进入就绪队列，等待下一次调度，同时，进程调度又去选择就绪队列中的一个进程，分配给它一个时间片，以投入运行。

  • 最高优先级算法(HPF)：进程调度每次将处理机分配给具有最高优先级的就绪进程。最高优先级算法可与不同的CPU方式结合形成可抢占式最高优先级算法和不可抢占式最高优先级算法。

  • 多级队列反馈法：几种调度算法的结合形式多级队列方式。

调度算法图解

（6）了解工厂模式吗，说几个，单例模式是什么？单例模式的析构函数和构造函数是什么样子的？

单例模式

答：单例模式是一种常用的软件设计模式，在应用这个模式时，单例对象的类必须保证只有一个实例存在，整个系统只能使用一个对象实例。

优点：不会频繁地创建和销毁对象，浪费系统资源。

使用场景：IO 、数据库连接、Redis 连接等。

单例模式实现代码：

1
2
3
4
5
6

class Singleton {
    private static Singleton instance = new Singleton();
    public static Singleton getInstance() {
        return instance;
    }
}

单例模式调用代码：

1
2
3
4
5
6
7

public class Lesson {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2); 
    }
}

程序的输出结果：true

可以看出以上单例模式是在类加载的时候就创建了，这样会影响程序的启动速度，那如何实现单例模式的延迟加载？在使用时再创建？

单例延迟加载代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 单例模式-延迟加载版
class SinletonLazy {
    private static SingletonLazy instance;
    public static SingletonLazy getInstance() {
        if (instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }
}

以上为非线程安全的，单例模式如何支持多线程？

使用 synchronized 来保证，单例模式的线程安全代码：

1
2
3
4
5
6
7
8
9

class SingletonLazy {
    private static SingletonLazy instance;
    public static synchronized SingletonLazy getInstance() {
        if (instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }
}

工厂模式， 简单工厂模式， 抽象工厂

简单工厂模式

答：简单工厂模式又叫静态工厂方法模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。比如，一台咖啡机就可以理解为一个工厂模式，你只需要按下想喝的咖啡品类的按钮（摩卡或拿铁），它就会给你生产一杯相应的咖啡，你不需要管它内部的具体实现，只要告诉它你的需求即可。

抽象工厂模式

答：抽象工厂模式是在简单工厂的基础上将未来可能需要修改的代码抽象出来，通过继承的方式让子类去做决定。

比如，以上面的咖啡工厂为例，某天我的口味突然变了，不想喝咖啡了想喝啤酒，这个时候如果直接修改简单工厂里面的代码，这种做法不但不够优雅，也不符合软件设计的“开闭原则”，因为每次新增品类都要修改原来的代码。这个时候就可以使用抽象工厂类了，抽象工厂里只声明方法，具体的实现交给子类（子工厂）去实现，这个时候再有新增品类的需求，只需要新创建代码即可。

（7）对于什么方向感兴趣呢？回答AI，图像识别（因为个人项目了解过）；对于图像识别的算法和数据学习训练有什么了解？ （8）写过什么相关框架

B

(1) sql优化？（只答了索引）

SQL优化的具体操作：

1、在表中建立索引，优先考虑where、group by使用到的字段。

2、尽量避免使用select *，返回无用的字段会降低查询效率。如下：

SELECT * FROM t

优化方式：使用具体的字段代替*，只返回使用到的字段。

3、尽量避免使用in 和not in，会导致数据库引擎放弃索引进行全表扫描。如下：

SELECT * FROM t WHERE id IN (2,3)

SELECT * FROM t1 WHERE username IN (SELECT username FROM t2)

优化方式：如果是连续数值，可以用between代替。如下：

SELECT * FROM t WHERE id BETWEEN 2 AND 3

如果是子查询，可以用exists代替。如下：

SELECT * FROM t1 WHERE EXISTS (SELECT * FROM t2 WHERE t1.username = t2.username)

4、尽量避免使用or，会导致数据库引擎放弃索引进行全表扫描。如下：

SELECT * FROM t WHERE id = 1 OR id = 3

优化方式：可以用union代替or。如下：

SELECT * FROM t WHERE id = 1 UNION SELECT * FROM t WHERE id = 3

（PS：如果or两边的字段是同一个，如例子中这样。貌似两种方式效率差不多，即使union扫描的是索引，or扫描的是全表）

5、尽量避免在字段开头模糊查询，会导致数据库引擎放弃索引进行全表扫描。如下：

SELECT * FROM t WHERE username LIKE ‘%li%’

优化方式：尽量在字段后面使用模糊查询。如下：

SELECT * FROM t WHERE username LIKE ’li%'

6、尽量避免进行null值的判断，会导致数据库引擎放弃索引进行全表扫描。如下：

SELECT * FROM t WHERE score IS NULL

优化方式：可以给字段添加默认值0，对0值进行判断。如下：

SELECT * FROM t WHERE score = 0

7、尽量避免在where条件中等号的左侧进行表达式、函数操作，会导致数据库引擎放弃索引进行全表扫描。如下：

SELECT * FROM t2 WHERE score/10 = 9

SELECT * FROM t2 WHERE SUBSTR(username,1,2) = ’li'

优化方式：可以将表达式、函数操作移动到等号右侧。如下：

SELECT * FROM t2 WHERE score = 10*9

SELECT * FROM t2 WHERE username LIKE ’li%'

8、当数据量大时，避免使用where 1=1的条件。通常为了方便拼装查询条件，我们会默认使用该条件，数据库引擎会放弃索引进行全表扫描。如下：

SELECT * FROM t WHERE 1=1

优化方式：用代码拼装sql时进行判断，没where加where，有where加and

(2) 数据库的索引？

​ 1) 为什么要使用索引？

​ 快速查找数据

​ 2) 什么样的信息能够成为索引？

​ 主键， 唯一的键，其他的普通键；

​ 3) 索引的数据结构

  • 生成索引， 建立二叉查找树进行二分查找(平衡二叉树， 红黑树)；
  • 生成索引， 建立B-tree结构进行查找；
  • 生成索引，建立B+ tree结构进行查找；
  • 生成索引，建立Hash结构进行查找；

B树

定义：

  • 根节点至少包括两个孩子
  • 树中每个节点最多含有m个孩子(m>=2)
  • 除根节点和叶节点外,其他每个节点至少有ceil(m/2)个孩子
  • 所有叶子节点都位于同一层

B+-Tree

  • 非叶子节点的子树指针与关键字个数相同
  • 非叶子节点的子树指针p[i]，指向关键字值[k[i],k[i+1])子树
  • 非叶子节点仅用来索引，数据都保存在叶子节点中
  • 所有叶子节点均有一个链指针指向下一个叶子节点

B+Tree更适合用来做存储索引

  • B+树的磁盘读写代价更低
  • B+树的查询效率更加稳定
  • B+树更有利于对数据库的扫描

(3) b树和b+树的区别？

a) B树是每个关键字都保存数据，有n棵子树的B+树非叶子结点中含有n个关键字， B树是n-1个， B+树这些关键字不保存数据，所有的数据都保存在叶子结点(B树是每个关键字都保存数据);

b) B+树中，有一个指针指向关键字最小的叶子结点，所有的叶子结点链成一个单链表；

可以发现，B+树它和B树比较，B+树对磁盘的读写代价更低；因此B+树在文件系统，数据库系统中更有优势；

实际上，查询索引操作最耗资源的不在内存中，而是磁盘IO。索引是存在磁盘上的，当数据量比较大的时候，索引的大小可能达到几个G。那么，我们利用索引进行查询的时候，不可能把索引直接加载到内存中，只能一次读取一个磁盘页，一个磁盘页对应着一个节点，一次读取操作需要一次磁盘io。

在二叉树查询时，最坏的情况下查找的次数是树的高度，即io次数为树的高度。B-树就是比二叉树“矮胖”的树。

所以，B+树对比B-树有如下好处：

​ io次数少：B+树中间节点只存索引，不存在实际的数据，所以可以存储更多的数据。索引树更加的矮胖，io次数更少。

​ 性能稳定：B+树数据只存在于叶子节点，查询性能稳定

​ 范围查询简单：b+树不需要中序遍历，遍历链表即可。

(4) explain分析sql语句有哪些列？

类型 描述 id 在一个大的查询语句中，每个select关键字都对应一个唯一的id select_type select关键字对应的查询类型 table 表 type 针对单表的访问方法 possible_keys 预测用到的索引 key 实际使用的索引 key_len 实际使用索引的长度 ref 表之间的引用 rows 估算出来的结果记录条数 Extra 额外的信息

幻读是什么？怎么解决？（next-key locks）

幻读

  • 破坏了锁的语义。当实行 select … from… where … for update 的时候，语义是要锁住符合条件的行，但是幻读破坏了这个规则。
  • 数据不一致。两次同样的范围查询却查出来的结果不一样。

解决幻读：

使用间隙锁。在两两数据行之间有间隙，如果我们能把数据行之间的间隙也锁住，则不会有产生幻读的数据插入。

间隙锁和行锁合称为next-key lock ，实现语句为 select * from t for update。这样表t中数据行被锁住，而且行与行之间的间隙也会被锁住。

next-key lock 会导致锁的范围变大，影响并发，而且有可能会带来死锁。

tcp和udp的区别？

TCP(传输控制协议)和UDP（用户数据报协议）区别

  • TCP是一种面向连接的、可靠的、基于字节流的传输层通信协议，是专门为了在不可靠的网络中提供一个可靠的端对端字节流而设计的，面向字节流。
  • UDP（用户数据报协议）是iso参考模型中一种无连接的传输层协议，提供简单不可靠的非连接传输层服务，面向报文

区别：

1） TCP是面向连接的，可靠性高；UDP是基于非连接的，可靠性低 2） 由于TCP是连接的通信，需要有三次握手、重新确认等连接过程，会有延时，实时性差，同时过程复杂，也使其易于攻击；UDP没有建立连接的过程，因而实时性较强，也稍安全 3） 在传输相同大小的数据时，TCP首部开销20字节；UDP首部开销8字节，TCP报头比UDP复杂，故实际包含的用户数据较少。TCP在IP协议的基础上添加了序号机制、确认机制、超时重传机制等，保证了传输的可靠性，不会出现丢包或乱序，而UDP有丢包，故TCP开销大，UDP开销较小 4） 每条TCP连接只能时点到点的；UDP支持一对一、一对多、多对一、多对多的交互通信

应用场景选择

  • 对实时性要求高和高速传输的场合下使用UDP;在可靠性要求低，追求效率的情况下使用UDP;
  • 需要传输大量数据且对可靠性要求高的情况下使用TCP

说说https?（ssl/tls加密过程）

HTTP是未经安全加密的协议，它的传输过程容易被攻击者监听、数据容易被窃取、发送方和接收方容易被伪造;而HTTPS是安全的协议，它通过密钥交换算法-签名算法-对称加密算法-摘要算法能够解决上面这些问题。

// HTTPS的工作原理

  • 首先服务端给客户端传输证书,这个证书就是公钥,只是包含了很多的信息,比如说证书的办法机构,证书的过期时间
  • 客户端进行证书的解析,比如说验证办法机构,过期时间,如果发现没有任何问题,就生成一个随机值(私钥),然后用证书对这个私钥进行加密,并发送给服务端
  • 服务端使用私钥将这个信息进行解密,得到客户端的私钥,然后客户端和服务端就可以通过这个私钥进行通信了
  • 服务端将消息进行对称加密(简单来说就是讲消息和私钥进行混合,除非知道私钥否则服务进行解密),私钥正好只有客户端和服务端知道,所以信息就比较安全了
  • 服务端将进行对称加密后的消息进行传送
  • 客户端使用私钥进行信息的解密

对称加密和非对称加密的优劣？（没答出来，只说了使用场景）

对称加密：对称，也就是双方都是平等的。使用同一个秘钥进行加密和解密。优点就是：简单，易使用。缺点：就是不安全，因为只要获取到一方秘钥，就可以解密双方的信息。

非对称加密：非对称，也就是双方不是平等的。服务方与客户方都各有一把公钥和私钥。两者发送信息的时候用公钥加密，对方用私钥解密。但这样做的就是管理困难，信息发送者用公开密钥去加密，而信息接收者则用私用密钥去解密。公钥机制灵活，但加密和解密速度却比对称密钥加密慢得多。

（1） 对称加密加密与解密使用的是同样的密钥，所以速度快，但由于需要将密钥在网络传输，所以安全性不高。 （2） 非对称加密使用了一对密钥，公钥与私钥，所以安全性高，但加密与解密速度慢。 （3） 解决的办法是将对称加密的密钥使用非对称加密的公钥进行加密，然后发送出去，接收方使用私钥进行解密得到对称加密的密钥，然后双方可以使用对称加密来进行沟通。（其实就是在连接的过程中使用非对称加密，连接后进行通讯用的是对称加密）

三次握手？四次挥手？

进程与线程的区别？

goroutine与线程的区别？（说了gmp模型）

（一）从使用上来讲

a.goroutine 比线程更轻量级，可以创建十万、百万不用担心资源问题。

b.goroutine 和 chan 搭配使用，实现多线程、高并发 实现起来要方便很多。

c.虽然go的并发用起来很方便，但多线程还是要小心不要产生 数据竞态,以及共享锁还是互斥锁的选择问题、并发操作的数据同步问题（多核心，不同的cpu缓存操作，同步到内存使其他协程感知）。

(二) 从实现上来讲

a.从资源上讲，线程的栈内存大小一般是固定的一般为2MB，虽然这个数值可以设置，但是 太大了浪费，太小了容易不够用。而 goroutine 栈内存是可变的，初始一般为 2KB，随着需求可以扩大达到1GB。 所以goroutine 十分的轻量级，且能满足不同的需求。

b.从调度上讲，线程的调度由 OS 的内核完成；线程的切换需要CPU寄存器和内存的数据交换，从而切换不同的线程上下文。 其触发方式为 CPU时钟。而goroutine 的调度 则比较轻量级，由go自身的调度器完成；其只关心当前go程序内协程的调度；触发方式为 go内部的事件，time.sleep,通道阻塞，互斥量操作等。

c.协程同线程的关系，有些类似于 线程同进程的关系。多个协程绑定到同一个线程上，按照一定的调度算法执行。

面试官建议：多了解数据库优化，golang

二面

为什么数据库需要索引？

​ 为了加快查找

B+树和hash？

并发量变大时怎么开发网关系统？