![mark](https://img.zouchanglin.cn///20200226/plcYVa97lRmi.png)

这篇文章主要是谈谈计算机网络常见的面试个考察点，记录一下，里面有很多问题之前面试也遇到过，特此记录一下！



## 0、讲一下TCP三次握手

0、TCP三次握手是一个TCP连接的建立过程，为了确认双方的收发能力正常，并初始化seq，为后续传输做准备

1、首先Client处于Closed状态，Server处于Listen状态，Client向Server发了SYN=1，seq=x，Server收到后确认了Server的接收能力正常，Client的发送能力正常；

2、Server回复SYN=1，ACK=1，ack=x+1，seq=y，Client收到后做出判断：Client和Server的收发能力都正常，

3、接着Client向Server发ACK=1，seq=x+1，ack=y+1，这就是第三次握手，可以携带数据了，Server收到后便可以确认Client接收能力正常，Server发送能力正常，并把链接从半连接队列移动到全连接队列

## 1、seq是固定的吗

seq是随时间变化的，每个连接都有不同的seq，seq是一个32byte的计数器，每4ms加一，因此seq是动态生成的，为后续传输做准备

## 2、三次握手可以携带数据吗

只有第三次可以携带数据，如果第一次就能携带数据的话服务器会花很多时间对数据进行存储，占用IO资源，非常危险，对于第三次握手来说Client已经知道双方的收发能力正常，所以携带数据也是没问题的

## 3、什么是半连接队列

第一次握手后，Server发出ACK报文，等待Client向自己发送ACK报文，此时就会把请求放在半连接队列，半连接队列满了就会丢弃报文

## 4、谈谈SYN攻击

Client向Server发SYN=1，seq=x，收到Server发来的ACK不回复ACK，或者直接丢弃Server的ACK报文，导致半连接队列满了，丢弃了其他真实需求的请求报文，导致服务器无法正常提供服务

## 5、第三次握手丢失，会怎样

服务端会重传，如果收到就会停止，尝试时间间隔为1s、2s、4s、8s、16s、32s、64s，Linux最多尝试64s，之后若还是无应答就会移出半连接队列

## 6、Linux如何判断受到了SYN攻击

```bash
netstat -n -p TCP|grep SYN_RECV
```

## 7、Linux查看网络状态

```bash
netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'    
```

它会显示例如下面的信息：

TIME_WAIT 814
CLOSE_WAIT 1
FIN_WAIT1 1
ESTABLISHED 634
SYN_RECV 2
LAST_ACK 1

**ESTABLISHED 表示正在通信，TIME_WAIT 表示主动关闭，CLOSE_WAIT 表示被动关闭。** 

## 8、讲一下TCP四次挥手

TCP四次挥手用户双方断开连接，TCP四次挥手由任意一方发起，这里假设A主机和B主机：

1、A主动发起释放连接请求，FIN=1，seq=u

2、B收到A的连接释放报文后，立即回复A主机一个ACK报文（ACK=1，ack=u+1，seq=v），表示自己收到了A主机的连接释放报文

3、B主机此时会通知ApplicationA主机要释放连接了，Application执行资源释放代码，完毕后回复A主机连接释放报文，ACK=1，FIN=1，ack=u+1，seq=w

4、A主机回复B主机连接释放报文，ACK=1，ack=w+1，seq=u+1，并且等待2MSL时间后关闭，B主机在收到A主机的ACK报文后也会关闭

## 9、为什么会有四次挥手

因为B主机收到A主机连接释放报文后不会立即关闭Socket，只能先回复一个ACK报文，告诉A主机你的连接释放请求报文我已经收到了，等到B主机全部发完报文后，B主机才会向A主机发送FIN报文

## 10、什么是2MSL的等待时间

MSL是TCP报文段的最大生存时间，2MSL是报文段在AB主机之间的往返时间，为了最后的ACK报文能到达B主机，B主机才能正常关闭连接。

如果B主机未收到A主机发的最后的ACK报文，B主机会重发FIN报文，一来一去正好是两个MSL；还有2MSL的等待时间也是为了避免新旧连接混淆，因为经过2MSL，上一次连接中所有的重复包都会消失

## 11、服务器出现大量CLOSE_WAIT的原因

最有可能的就是资源释放代码有BUG，没有正确发出ACK=1、FIN=1的报文，导致大量连接不能正常关闭，也就是出现大量CLOSE_WAIT的原因

## 12、服务器出现大量TIME_WAIT的原因

一些爬虫服务器（如果网管在安装的时候没有做内核参数优化的话）上经常会遇到这个问题 ，TIME_WAIT是主动关闭连接的一方保持的状态，对于爬虫服务器来说他本身就是“客户端”，在完成一个爬取任务之后，他就 会发起主动关闭连接，从而进入TIME_WAIT的状态，然后在保持这个状态2MSL（max segment lifetime）时间之后，彻底关闭回收资源。 

解决思路很简单，就是让服务器能够快速回收和重用那些TIME_WAIT的资源，vim /etc/sysctl.conf

```ini
#对于一个新建连接，内核要发送多少个 SYN 连接请求才决定放弃,不应该大于255，默认值是5，对应于180秒左右时间  
net.ipv4.tcp_syn_retries=2 
#net.ipv4.tcp_synack_retries=2 
#表示当keepalive起用的时候，TCP发送keepalive消息的频度。缺省是2小时，改为300秒 
net.ipv4.tcp_keepalive_time=1200 
net.ipv4.tcp_orphan_retries=3 
#表示如果套接字由本端要求关闭，这个参数决定了它保持在FIN-WAIT-2状态的时间 
net.ipv4.tcp_fin_timeout=30   
#表示SYN队列的长度，默认为1024，加大队列长度为8192，可以容纳更多等待连接的网络连接数。 
net.ipv4.tcp_max_syn_backlog = 4096 
#表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭 
net.ipv4.tcp_syncookies = 1 
   
#表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭 
net.ipv4.tcp_tw_reuse = 1 
#表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭 
net.ipv4.tcp_tw_recycle = 1 
   
##减少超时前的探测次数  
net.ipv4.tcp_keepalive_probes=5  
##优化网络设备接收队列  
net.core.netdev_max_backlog=3000  
```

修改完之后执行/sbin/sysctl -p让参数生效。 

## 12、TCP和UDP的区别

UDP的主要特点是：
（1）无连接；
（2）尽最大努力交付；不保证可靠交付
（3）面向报文，不对报文拆分或者合并；
（4）无拥塞控制；
（5）支持一对一、一对多、多对一和多对多的交互通信；
（6）首部开销小（只有四个字段：源端口、目的端口、长度、检验和，即8个字节）。

TCP的主要特点是：
（1）面向连接；
（2）每一条TCP连接只能是点对点的（一对一）；
（3）提供可靠交付的服务；
（4）提供全双工通信；
（5）面向字节流。

## 13、GET请求和POST请求的区别

**HTTP报文层面**：GET将请求信息放在URL、POST放在报文体中。GET请求URL长度受浏览器限制， HTTP协议本身对URL长度并没有做任何规定。

**数据层层面**：GET符合幂等性和安全性， 反复读取不应该对访问的数据有副作用 ；POST不符合幂等性和安全性

**其他层面**：GET可以被缓存POST不幂等也就意味着不能随意多次执行，因此也就不能缓存。

GET和POST还有一个重大区别，简单的说：GET产生一个TCP数据包；POST产生两个TCP数据包。
对于GET方式的请求，浏览器会把http header和data一并发送出去，服务器响应200（返回数据）； 而对于POST，浏览器先发送header，服务器响应100 continue，浏览器再发送data，服务器响应200 ok（返回数据）。

## 14、Session的两种实现方式

1、使用Cookie来实现，也就是以SESSIONID为Cookie的Key，以SESSIONID的值为Cookie的Value，每次请求的时候都会通过Cookie机制携带上这个SESSIONID

2、如果客户端禁止使用Cookie，那么就使用URL回写来实现，就在参数 url 中加入 Session ID 信息，然后返回修改后的 url ， 通过这种机制，url中保存了sessionId，然后点击URL时又回传到服务器，来维持身份。 

## 15、Cookie和Session的区别

Cookie数据存放在客户的浏览器上，Session数据放在服务器上

Session相对Cookie更安全

如果考虑减轻服务器负担，应该使用Cookie

## 16、HTTPS真的很安全吗

浏览器默认填充http://，请求需要进行跳转，又被劫持的风险，如果一开始输入的地址的https://... 那么这样还是可以保证安全性的，可以使用HSTS（HTTP Strict Transport Security）优化，目前还未开始推行

## 17、UDP如何实现可靠传输

UDP要想可靠，就要接收方收到UDP之后回复个确认包，发送方有个机制，收不到确认包就要重新发送，每个包有递增的序号，接收方发现中间丢了包就要发重传请求，当网络太差时候频繁丢包，防止越丢包越重传的恶性循环，要有个发送窗口的限制，发送窗口的大小根据网络传输情况调整，调整算法要有一定自适应性。

恭喜你， 你在应用层重新实现了TCP！ 

##  18、ARP地址解析协议，工作原理

[《NAT技术与ARP协议-ARP协议》](https://zouchanglin.cn/2019/10/29/1894999249.html) ARP不是一个单纯的数据链路层的协议，而是一个介于数据链路层和网络层之间的协议。ARP协议的作用：ARP协议建立了主机IP地址和MAC地址的映射关系。其实就是喊话的方式，大家都听见了，但是只有符合IP的主机才会回发自己的MAC地址。

## 19、 ICMP协议

ICMP是InternetControl Message Protocol，因特网控制报文协议。它是TCP/IP协议族的一个子协议，用于在IP主机、路由器之间传递控制消息。控制消息是指网络通不通、主机是否可达、路由器是否可用等网络本身的消息。这些控制消息虽然并不传输用户数据，但是对于用户数据的传递起着重要的作用。ICMP报文有两种：差错报告报文和询问报文。 详情见[《辅助IP的ICMP》](https://zouchanglin.cn/2019/11/16/4183462900.html)

## 20、TTL是什么？作用是什么？

TTL是指生存时间，简单来说，它表示了数据包在网络中的时间，经过一个路由器后TTL就减一，这样TTL最终会减为0，当TTL为0时，则将数据包丢弃，这样也就是因为两个路由器之间可能形成环，如果没有TTL的限制，则数据包将会在这个环上一直死转，由于有了TTL，最终TTL为0后，则将数据包丢弃。 

## 21、TCP流量控制、拥塞控制

关于TCP的流量控制、拥塞控制见[《TCP的高性能机制》](https://zouchanglin.cn/2020/02/25/4240078285.html)，点击链接

## 22、谈谈OSI七层模型与TCP/IP五层模型

![mark](https://img.zouchanglin.cn///20200226/tTuX8Qa22m19.png)

计算机网络常见面试题

![mark](https://img.zouchanglin.cn///20200301/w3XwYriSoTQ9.png)

因为笔者的电脑是Windows，所以要进行Linux系统编程不得不准备一台虚拟机，当然子系统Ubuntu也是可以的，因为昨天解决了一个虚拟机固定IP的问题，[《CentOS7虚拟机设置固定IP》](https://zouchanglin.cn/2019/12/12/40756677.html)所以一旦连接稳定，那么就可以开始开发了，哈哈，今天主要是通过Clion这个工具（和IDEA是亲兄弟）来进行高效的Linux系统编程环境搭建！



## 一、准备Linux环境

只要有一台装了Linux的虚拟机就可以，我使用的是CentOS7 Server版，所以，平时使用起来也是直接拿Xshell一连接就可以使用了

## 二、在Linux下准备开发工具

Cmake 3.x 以上 + gdb 7.8.x 以上 + gcc + gcc-g++

首先卸载预装Cmake 2

```bash
yum remove cmake
```

安装必要环境

```bash
yum install -y gcc g++ gcc-c++ make automake texinfo wget
```

安装Cmake

```bash
wget https://cmake.org/files/v3.14/cmake-3.14.0.tar.gz
tar -xf cmake-3.14.0.tar.gz
cd cmake-3.14.0
./configure
make
make install

# 安装好后的Cmake位于 /usr/local/share/cmake-3.13/，可执行程序位于/usr/local/bin/cmake
# 为了让CLion能够自动识别，构建软连接
ln -s /usr/local/bin/cmake /usr/bin/cmake
```

如果wget很慢，推荐使用我的

```bash
wget https://img.zouchanglin.cn/cmake-3.14.0.tar.gz
```

安装gdb

```bash
# 首先安装依赖，termcap
wget https://ftp.gnu.org/gnu/termcap/termcap-1.3.1.tar.gz
tar -xf termcap-1.3.1.tar.gz
cd termcap-1.3.1
./configure
make
make install
```

如果安装的依赖包下载很慢，推荐用我的

```bash
wget https://img.zouchanglin.cn/termcap-1.3.1.tar.gz
```

如果依赖包安装完成，开始下一步

```bash
# 卸载预装gdb
yum remove -y gdb

# 安装gbd
wget http://mirrors.ustc.edu.cn/gnu/gdb/gdb-7.9.tar.xz
tar -xf gdb-7.9.tar.xz
cd gdb-7.9
./configure
make
make install

# gdb将被安装到/usr/local/share/gdb目录，可执行程序位于/usr/local/bin/gdb
# 为了让CLion能够自动识别，构建软连接。
ln -s /usr/local/bin/gdb /usr/bin/gdb
```

如果gdb下载很慢，推荐用我的

```bash
wget https://img.zouchanglin.cn/gdb-7.9.tar.xz
```

## 三、CLion配置remote主机

![mark](https://img.zouchanglin.cn///20200301/N7T2oRGNHs9z.png)

## 四、愉快的写代码吧

![mark](https://img.zouchanglin.cn///20200301/nmkM5BIs2XN2.png)

自动同步代码，超人性化提示，唯一的缺点就是对于不懂CMakeList的同学就Over了，下面复习一下CMakeList

## 五、CMakeList构建项目

cmake 是一个跨平台、开源的构建系统。它是一个集软件构建、测试、打包于一身的软件。它使用与平台和编译器独立的配置文件来对软件编译过程进行控制。 在Windows下也可以使用Cmake进行大型项目的构建，比如我之前编译过OpenCV的源码，就是通过VisualStudio的编译器配合Cmake来完成的！

### 1. 指定 cmake 的最小版本

```cmake
cmake_minimum_required(VERSION 3.4.1)
```

这行命令是可选的，我们可以不写这句话，但在有些情况下，如果 CMakeLists.txt 文件中使用了一些高版本 cmake 特有的一些命令的时候，就需要加上这样一行，提醒用户升级到该版本之后再执行 cmake。

### 2. 设置项目名称

```cmake
project(demo)
```

这个命令不是强制性的，但最好都加上。它会引入两个变量 demo_BINARY_DIR 和 demo_SOURCE_DIR，同时，cmake 自动定义了两个等价的变量 PROJECT_BINARY_DIR 和 PROJECT_SOURCE_DIR。

### 3. 设置编译类型

```cmake
add_executable(demo demo.cpp) # 生成可执行文件
add_library(common STATIC util.cpp) # 生成静态库
add_library(common SHARED util.cpp) # 生成动态库或共享库
```

add_library 默认生成是静态库，通过以上命令生成文件名字，

- 在 Linux 下是：
  demo
  libcommon.a
  libcommon.so
- 在 Windows 下是：
  demo.exe
  common.lib
  common.dll

### 4. 指定编译包含的源文件

4.1 明确指定包含哪些源文件

```cmake
add_library(demo demo.cpp test.cpp util.cpp)
```

4.2 搜索所有的 cpp 文件

aux_source_directory(dir VAR) 发现一个目录下所有的源代码文件并将列表存储在一个变量中。

```cmake
aux_source_directory(. SRC_LIST) # 搜索当前目录下的所有.cpp文件
add_library(demo ${SRC_LIST})
```

自定义搜索规则

```cmake
file(GLOB SRC_LIST "*.cpp" "protocol/*.cpp")
add_library(demo ${SRC_LIST})
# 或者
file(GLOB SRC_LIST "*.cpp")
file(GLOB SRC_PROTOCOL_LIST "protocol/*.cpp")
add_library(demo ${SRC_LIST} ${SRC_PROTOCOL_LIST})
# 或者
aux_source_directory(. SRC_LIST)
aux_source_directory(protocol SRC_PROTOCOL_LIST)
add_library(demo ${SRC_LIST} ${SRC_PROTOCOL_LIST})
```

### 5. 查找指定的库文件

 find_library(VAR name path)查找到指定的预编译库，并将它的路径存储在变量中。
默认的搜索路径为 cmake 包含的系统库，因此如果是 NDK 的公共库只需要指定库的 name 即可 

```cmake
find_library( # Sets the name of the path variable.
              log-lib
 
              # Specifies the name of the NDK library that
              # you want CMake to locate.
              log )
```

### 6. 设置包含的目录

```cmake
include_directories(
    ${CMAKE_CURRENT_SOURCE_DIR}
    ${CMAKE_CURRENT_BINARY_DIR}
    ${CMAKE_CURRENT_SOURCE_DIR}/include
)
```

Linux 下还可以通过如下方式设置包含的目录

```cmake
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I${CMAKE_CURRENT_SOURCE_DIR}")
```

### 7. 设置链接库搜索目录

```bash
link_directories(
    ${CMAKE_CURRENT_SOURCE_DIR}/libs
)
```

Linux 下还可以通过如下方式设置包含的目录 

```cmake
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -L${CMAKE_CURRENT_SOURCE_DIR}/libs")
```

### 8. 设置 target 需要链接的库

```bash
target_link_libraries( # 目标库
                       demo
 
                       # 目标库需要链接的库
                       # log-lib 是上面 find_library 指定的变量名
                       ${log-lib} )
```

在 Windows 下，系统会根据链接库目录，搜索xxx.lib 文件，Linux 下会搜索 xxx.so 或者 xxx.a 文件，如果都存在会优先链接动态库（so 后缀） 

8.1 指定链接动态库或静态库

```cmake
target_link_libraries(demo libface.a) # 链接libface.a
target_link_libraries(demo libface.so) # 链接libface.so
```

8.2 指定全路径

```cmake
target_link_libraries(demo ${CMAKE_CURRENT_SOURCE_DIR}/libs/libface.a)
target_link_libraries(demo ${CMAKE_CURRENT_SOURCE_DIR}/libs/libface.so)
```

 8.3 指定链接多个库

```cmake
target_link_libraries(demo
    ${CMAKE_CURRENT_SOURCE_DIR}/libs/libface.a
    boost_system.a
    boost_thread
    pthread)
```

### 9. 设置变量

9.1 set 直接设置变量的值

```cmake
set(SRC_LIST main.cpp test.cpp)
add_executable(demo ${SRC_LIST})
```

9.2 set 追加设置变量的值

```cmake
set(SRC_LIST main.cpp)
set(SRC_LIST ${SRC_LIST} test.cpp)
add_executable(demo ${SRC_LIST})
```

9.3 list 追加或者删除变量的值

```cmake
set(SRC_LIST main.cpp)
list(APPEND SRC_LIST test.cpp)
list(REMOVE_ITEM SRC_LIST main.cpp)
add_executable(demo ${SRC_LIST})
```

## 六、CMake项目示例

### 1、简单项目

新建文件 main.c，内容如下，新建文件 CMakeLists.txt（命名必须是 CMakeLists.txt，注意大小写）

![mark](https://img.zouchanglin.cn///20200301/gh0XkkvbFuCU.png)

一般我们采用 cmake 的 out-of-source 方式来构建（即生成的中间产物和源代码分离），这样做可以让生成的文件和源文件不会弄混，且目录结构看起来也会清晰明了。所以推荐使用这种方式，至于这个文件夹的命名并无限制，我们习惯命名为 build。

我们进入build文件夹，执行`cmake..`， `..` 表示上一级目录，cmake 会在上一级目录下找到 CMakeLists.txt 文件并编译，并生成如下图所示的一些中间文件 

![mark](https://img.zouchanglin.cn///20200301/GqkqB7dXUnvw.png)

直接执行 make命令，生成可执行程序，如下图： 

![mark](https://img.zouchanglin.cn///20200301/it3537Jsml8s.png)

### 2、复杂项目

![mark](https://img.zouchanglin.cn///20200301/mpOWOWwHf53M.png)

CMakeList.txt

```cmake
cmake_minimum_required (VERSION 2.8)
project(demo)
aux_source_directory(. DIR_SRCS)
# 添加math子目录
add_subdirectory(math)
# 指定生成目标
add_executable(demo ${DIR_SRCS})
# 添加链接库
target_link_libraries(demo MathFunctions)
```

main.c

```c
#include <stdio.h>
#include "math/MathFunctions.h"

int main() {
    printf("Hello World!\n");
    printf("Add(1,2) ret = %d\n", add(1,2));
    return 0;
}
```

math里的CMakeList.txt

```cmake
aux_source_directory(. DIR_LIB_SRCS)
# 生成链接库
add_library(MathFunctions ${DIR_LIB_SRCS})
```

math里的MathFunctions.h 和MathFunctions.c

```c
#ifndef define _MATHFUNCTIONS_H__
#define _MATHFUNCTIONS_H__

int add(int num, int num2);

#endif //!define _MATHFUNCTIONS_H__
```

```c
#include <stdio.h>
#include "MathFunctions.h"

int add(int num, int num2){
	return num + num2;
}
```

同样的也只需要进入build目录，进行cmake ..

![mark](https://img.zouchanglin.cn///20200301/c9kNmr0HwG9h.png)

高效的Linux系统编程环境

![mark](https://img.zouchanglin.cn///20200301/NOwCYlkoT90r.png)

虚拟机设置为固定IP，不管主机在什么网络环境下，是断网环境，还是连接任何网段访问外网的环境下，虚拟机的IP都固定不变，而且使用终端连接，始终不变，正常连接；  虚拟机的固定IP可以按照自己想设置的IP地址网段随意设置，比如我就想设置固定IP为192.168.2.2；

经过查询资料，终于得出一个完美解决方案：**采用方式为NAT模式+固定IP的模式** 。

配置环境说明：主机为Win10专业版，虚拟机为VMware Workstation 15 Pro，虚拟机中的Linux系统为CentOS 7.3_64位。



## 1、虚拟机设置NAT模式

无论有几个网络适配器都设置成NAT模式！

![mark](https://img.zouchanglin.cn///20200301/MNygsF3sEGiW.png)

## 2、配置虚拟机NAT模式参数

修改子网IP设置，实现自由设置固定IP，若你想设置固定IP为192.168.2.2-255，比如192.168.2.2，则子网IP为192.168.2.0；建议不要用：192.168.1.2-255，亲测1网段无法成功

![mark](https://img.zouchanglin.cn///20200301/4UMTjMldFCBx.png)

## 3、配置物理主机VMnet8参数

其中的IP地址随意设置，但是要保证不能跟你要设置虚拟机的固定IP一样。

![mark](https://img.zouchanglin.cn///20200301/9z84rc3aaPeM.png)

## 4、配置Centos网络配置文件

![mark](https://img.zouchanglin.cn///20200301/2ratXcv5P4fF.png)

![mark](https://img.zouchanglin.cn///20200301/mz9DzcjiC6nr.png)

## 5、重启CentOS

reboot，ping一下baidu.com试试，SSH连接一下试试！

CentOS7虚拟机设置固定IP

# 1、CPU多核心缓存架构分析

并发编程：肯定是为了更合理充分的利用多核CPU架构的性能

CPU 主频率远远高于主存，所以引入CPU缓存，CPU加载数据无法绕过缓存，而且对于多核CPU，一级缓存不是共享的，二级和三级缓存是线程共享的！CPU计算的数据并不是直接从主存中去拿，而且通过层层在缓存中寻找。



下图是一个单CPU多核心的架构图：

![mark](https://img.zouchanglin.cn///20200201/24FFIEvLSVIm.png)

# 2、CPU缓存一致性协议

先看这样一段代码：

![](https://img.zouchanglin.cn///20200201/iDRYlT3KP4bK.png)

加载过程就是ThreadA通过read指令读取到flag，在通过load指令加载到缓存，也就是JMM中的本地内存，CPU再通过寄存器去使用flag，ThreadB也是同样的流程，通过assign指令为本地内存中的flag赋值，再写入主存：

![](https://img.zouchanglin.cn///20200201/iPetMyQrMYAi.png)

由于while(true)并没有释放时间片，所以在这里可以让它去进行上下文切换，则就会有时间清除缓存

![mark](https://img.zouchanglin.cn///20200201/gi6mMfLRsxgH.png)

两次的执行结果肯定很简单

![mark](https://img.zouchanglin.cn///20200201/T5hyPEeWBOYV.png)

什么情况下的上下文切换不会清除缓存呢？可以设置一个非常小的休眠时间

![mark](https://img.zouchanglin.cn///20200201/8bSnHw0qSx8D.png)

这个时候，设置500纳秒的Sleep和500000纳秒的等待会导致结果完全不一样！！

这与CPU多核心架构有关系，CPU修改之后的值并不会立即刷新到主存，这便导致了缓存不一致的问题，这是属于CPU架构的问题，不仅仅存在于JVM层面，只要是这种的CPU架构都会出现这种问题，所以首先得靠加锁来解决这种问题，在早期有一种东西叫做总线锁：

![mark](https://img.zouchanglin.cn///20200201/Dg18RIUeEYKI.png)

一旦发生数据修改的回写操作，直接把总线加锁，这样别的线程在使用数据的时候就不得不重新从主存得到新的数据，而且存在严重的性能问题，如果存在大量IO操作时，还使用这种总线锁，那么肯定IO性能肯定会下降！

于是出现了缓存一致性协议：

主要用到的缓存一致性协议时MESI协议（M修改、E独占、S共享、I无效四种状态，这四种状态记录的是缓存行的转态）。

这里还有一个机制叫做总线嗅探机制，嗅探通过总线的数据，如果只有一个核心用到，那么就会给这个缓存行一个状态叫做E状态（独占状态），当另一个线程也用到了这个变量的时候，CPU就会通过广播机制通知其他的核心把这个缓存行的状态修改为S状态（共享状态），接下来其中一个线程对这个变量进行了修改，那么对于这个线程来说，这个变量的缓存行变成了M状态（修改状态），回写的时候会通过总线，总线嗅探机制嗅探到这个变量的缓存行已经是M状态，它就会通过其他的核心，说缓存无效，则其他核心上的缓存行就会变成I状态（无效状态），变成无效状态后如果还需要使用这个变量，那么肯定只能重新从主存中去加载这个变量到缓存，而且必须等待修改核心修改（回写主存）完成！

![mark](https://img.zouchanglin.cn///20200201/Id5pv2ES62r4.png)

这里锁的缓存行最大值为 64 byte ，总线锁主要是用到了lock原语

# 3、内存模型JMM实现原理

JMM描述的是一种抽象的概念，一组规则，通过这组规则控制程序中各个变量在共享数据区域和私有数据区域的访问方式，JMM是围绕原子性、有序性、可见性展开的

![mark](https://img.zouchanglin.cn///20200201/SoIbOydo9ypK.png)

这个JMM模型只是一个抽象的概念，图上画出的也只是逻辑空间，通过对应到硬件内存架构是这样的：

![mark](https://img.zouchanglin.cn///20200201/oXWAj2CVMNxg.png)



# 4、Volatile关键字原理剖析

在上面的例子中，我们明显可以通过volatile关键字来解决这个问题，那么volatile又是如何实现的呢？

通过汇编指令来看看就知道了，运行时加虚拟机运行参数：

```bash
-XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -Xcomp
```

但是Mac环境可能会由于缺少部分包：hsdis-amd64.dylib，在这里下载就好了 https://github.com/evolvedmicrobe/benchmarks/blob/master/hsdis-amd64.dylib，下载完毕后放在：/Library/Java/JavaVirtualMachines/jdk1.8.0_231.jdk/Contents/Home/jre 就好了

先看看如何保证可见性的：

底层实现了 lock addl $0x0,(%rsp) ，触发了缓存一致性协议 

![mark](https://img.zouchanglin.cn///20200201/IWgK9WdYGyPp.png)

什么是重排序呢？是指编译器生成了指令序列，处理乱序执行！

接下来看看指令重排序的一个例子：

![mark](https://img.zouchanglin.cn///20200201/nPft5BeoBtvy.png)

打印出来（0，0）（0，1）（1，0）（1，1）都有

这就好比单例模式，请看下面这个例子：

![mark](https://img.zouchanglin.cn///20200201/cocuuCxlyLWi.png)

![mark](https://img.zouchanglin.cn///20200201/8fiF6sAm3ipw.png)

myInstance = new SingletonFactory()，这句话主要是三个指令构成的，如果不能保证指令有序性的话，那么拿到的对象就是未被初始化的对象，是无效的！

对于x86架构的CPU，加上volatile写后面的storeLoad内存屏障，我们也可以手动加上内存屏障：

![mark](https://img.zouchanglin.cn///20200201/UlVphp4q2knW.png)

这个加上内存屏障的方法定义是 public native void storeFence(); 因此是原生实现，可以看看OpenJDK的虚拟机实现，可以看到对于64位机器使用的是rsp寄存器，对于非64位用的是esp寄存器

![mark](https://img.zouchanglin.cn///20200201/vAA6EPpKUhth.png)

# 5、可见性、有序性、原子性详解

并发编程的三大特性：

可见性、有序性、原子性

volatile保证可见性与有序性，但是不能保证原子性，要保证原子性需要借助 synchronized、Lock锁机制，同理也能保证有序性与可见性，因为 synchronized和Lock能够保证任一时刻只有个线程访问该代码块。关于volatile不保证原子性这个其实很好证明：

![mark](https://img.zouchanglin.cn///20200201/HA5SKqo66Jcm.png)

因为线程进行了很多次无效计算，所以结果并不是100000，他们都是从主存中拿的值，而且值都是对的，但是计算过程却不是原子的，准确的说应该是资源并没有被锁定，导致自己修改的时候别人也在修改，所以正确理解volatile的作用是很重要的！ 

最后看看CAS操作对应的汇编指令：

![mark](https://img.zouchanglin.cn///20200201/L2dPr9fjKqMH.png)

volatile原理剖析

在并发编程中，我们通过锁，来避免由于竞争而造成的数据不一致问题。通常，我们以`synchronized 、Lock`来使用它。  但是Java中的锁，只能保证在同一个JVM进程内中执行。如果在分布式集群环境下呢？  分布式锁的实现有很多，比如基于数据库、memcached、Redis、系统文件、zookeeper等。它们的核心的理念跟上面的过程大致相同。 本篇文章，主要讲如何用Redis的形式实现分布式锁。



# 1、秒杀示例

首先，下面的例子是一个特价商品得秒杀案例，直接看代码

![mark](https://img.zouchanglin.cn///20200202/s4HB1MLjH93M.png)


服务层

![mark](https://img.zouchanglin.cn///20200202/nAnvwkbU2vWx.png)



![mark](https://img.zouchanglin.cn///20200202/0Ntyj0iQtqaN.png)


单个电脑上直接拿鼠标点链接肯定不会有问题，因为是串行的操作，接下用使用Apache ab工具模拟并发的情况：

`http://httpd.apache.org/docs/2.0/programs/ab.html` 这个是它的官网，使用说明里面也有，下面直接使用它进行模拟测压：

![mark](https://img.zouchanglin.cn///20200202/KBdkg8IEO5dr.png)


经过测试之后发现：卖超了，意料之中的事情

![mark](https://img.zouchanglin.cn///20200202/T5DaRI4dOza2.png)


为什么会出现这种情况呢？ 没有做同步呗，很正常，首先要解决的是数据同步问题

使用synchronized对方法加锁：

![mark](https://img.zouchanglin.cn///20200202/n4Xa2iApU5Ci.png)


加了synchronized之后肯定是数据同步了：

![mark](https://img.zouchanglin.cn///20200202/aTWdPX4N3ubL.png)


但是速度却太慢了，无法实现细粒度控制，而且系统根本无法实现水平拓展，问题很多，下面用分布式锁来解决这些问题。

# 2、Redis的几个命令

http://www.redis.cn/commands/setnx.html 可以先看看这个文档：

第一个命令：SETNX

> Design pattern: Locking with !SETNX
> 设计模式：使用!SETNX加锁
> Please note that:
> 请注意：
> 不鼓励以下模式来实现the Redlock algorithm ，该算法实现起来有一些复杂，但是提供了更好的保证并且具有容错性。
> 无论如何，我们保留旧的模式，因为肯定存在一些已实现的方法链接到该页面作为引用。而且，这是一个有趣的例子说明Redis命令能够被用来作为编程原语的。
> 无论如何，即使假设一个单例的加锁原语，但是从 2.6.12 开始，可以创建一个更加简单的加锁原语，相当于使用SET命令来获取锁，并且用一个简单的 Lua 脚本来释放锁。该模式被记录在SET命令的页面中。
> 也就是说，SETNX能够被使用并且以前也在被使用去作为一个加锁原语。例如，获取键为foo的锁，客户端可以尝试一下操作：
> SETNX lock.foo <current Unix time + lock timeout + 1>
> 如果客户端获得锁，SETNX返回1，那么将lock.foo键的Unix时间设置为不在被认为有效的时间。客户端随后会使用DEL lock.foo去释放该锁。
> 如果SETNX返回0，那么该键已经被其他的客户端锁定。如果这是一个非阻塞的锁，才能立刻返回给调用者，或者尝试重新获取该锁，直到成功或者过期超时。

第二个命令：GETSET

> 自动将key对应到value并且返回原来key对应的value。如果key存在但是对应的value不是字符串，就返回错误。
>
> 设计模式
>
> [GETSET](http://www.redis.cn/commands/getset.html)可以和[INCR](http://www.redis.cn/commands/incr.html)一起使用实现支持重置的计数功能。举个例子：每当有事件发生的时候，一段程序都会调用[INCR](http://www.redis.cn/commands/incr.html)给key mycounter加1，但是有时我们需要获取计数器的值，并且自动将其重置为0。这可以通过GETSET mycounter “0”来实现：

其实就是先GET、再SET，所以返回SET之前的值



# 3、使用Redis实现分布式锁

首先搞清楚锁的是什么，即搞清楚什么是进行同步和互斥的数据，对于上面的秒杀系统示例程序来说，当然是商品，而且是同样的商品需要同步与互斥，假设现在是华为Mate30 Pro的秒杀活动，大家肯定买的都是这一款产品，所以其实需要关心的就是成交订单量和库存的关系，如果不进行同步与互斥，那么肯定会出现买超的情况，限量秒杀1000台，可能实际成交订单变成了1200或更多，所以需要进行数据的同步与互斥



我直接使用Docker跑了一个Redis实例

![mark](https://img.zouchanglin.cn///20200202/qQ8xwSNxNHII.png)


测试通过可以使用！

pom文件引入redis-starter

![mark](https://img.zouchanglin.cn///20200202/rwtsygu5pXRS.png)


写入最基础的连接配置

![mark](https://img.zouchanglin.cn///20200202/UQOEd1vmNsNl.png)


RedisLock实现:

![mark](https://img.zouchanglin.cn///20200202/zmNwClkmOViQ.png)





在秒杀系统中使用：

![mark](https://img.zouchanglin.cn///20200202/s7c81EHhnKWi.png)


在设计的时候把商品的Id设置为Key，当前时间+超时时间为Value

通过代码注释可以看清楚实现流程：

![mark](https://img.zouchanglin.cn///20200202/D3x9AjAvqSJA.png)


如果锁未超时也是返回False，这说明别的线程已经持有锁！

# 4、Redis分布式锁的好处

保证了数据的同步与互斥，通过模拟10个线程模拟500次请求的结果，对了我还统计了一下未能成功获得锁的请求次数，本次实验是469次请求未能成功获得锁，所以订单成交了31个，仓库剩余99969份！

![mark](https://img.zouchanglin.cn///20200202/NWUCJdrcpLOx.png)


另外分布式锁可以很好的支持分布式部署，本例中因为为了方便直接在一个服务中写死了，所以就不演示集群似的测试了。



效率上也是很大的进步：

使用Redis分布式锁：

![]( https://img.zouchanglin.cn/sync08-966e272e.gif)


使用synchronized：

![]( https://img.zouchanglin.cn/sync09-461b14339.gif)