网络和操作系统高频问题

野性酷女 2022-09-09 04:45 106阅读 0赞

> 持续整理更新中  
> https://bbs.gameres.com/thread\_842984\_1\_1.html

### 一、TCP为什么是三次握手？ ###

*  1、TCP是面向连接：双方需证明彼此有收发能力。第一次握手，客户端发送SYN连接请求，服务端收到后仅能判断`客户端有发送能力`；第二次握手，服务端发送ACK，证明`服务端有接受和发送能力`；第三次握手，客户端发送ACK包，证明`客户端有接受能力`。
 *  2、防止失效链接传送给服务端：当客户端发送SYN包后，此包在网络节点发生滞留，在客户端重新发包建立连接并释放后到达服务端，服务端以为客户端的再次请求，向客户端发送ACK(`二次握手包`)，假如非三次握手，此时服务端就建立连接并等待client的数据，但现在的client并没有此行为，不会理睬服务端的ACK。
 *  3、TCP是可靠的：TCP需要seq序列号来做可靠重传或接收，为避免连接复用无法分辨出seq是延时还是旧链接的seq，因此需要双方三次握手约定双方的ISN(初始seq序列号)。第一次握手，客户端发送自己ISN\_C；第二次握手，服务端收到了客户端ISN\_C，并发送服务端的ISN\_S和确认ISN\_C；完成二次握手后，服务端确认收到了客户端的，而客户端无法确认收到服务端的(客户端没发ack，服务端无法确认客户端是否确认收到了)。所以只有客户端->服务端是可靠的。

第2条，实际上客户端收到非期望的ACK包会发送RST报文中止连接  
第3条，当连接断开重连后，TCP依靠ISN识别旧链接重发的包，确认机制是累加的，seq X的确认，表明seq X-1都被确认收到了

### 二、为什么建立连接是三次握手，关闭连接却是四次握手？ ###

因为建立连接的二次握手时，服务端把SYN和ACK一起回复。但是关闭连接时，当Server端收到FIN报文时，Server端的报文可能并没有发完，此时又要回应客户端FIN报文，所以先回复一个ACK报文表明收到， 然后等到Server端报文都发送完了，才发送FIN报文。因此不能一起发送。故需要四步握手。

### 三、一次访问网页的过程 ###

DNS域名解析。  
TCP三次握手，建立接连。  
发送HTTP请求报文。  
服务器处理请求返回响应报文。  
浏览器解析渲染页面。  
四次挥手，断开连接。

### 四、HTTP1.1 、HTTPS、HTTP2 ###

HTTP：keep-alive作用：在响应头设置keep-alive可以在一个TCP连接中发送多个http请求

HTTPS：客户端先向服务器端索要公钥，然后用公钥加密信息，服务器收到密文后，用自己的私钥解密。服务器公钥放在数字证书中。

HTTP2：

*  多路复用：相同域名多个请求共享一个TCP连接，降低延迟
 *  请求优先级：给每个request设置优先级
 *  二进制传输；取代纯文本传输
 *  数据流：数据包不是按顺序发送，对数据包做标记。每个请求或回应的所有数据包成为一个数据流
 *  服务端推送：可以主动向客户端发送消息。
 *  头部压缩：减少包的大小跟数量

### 五、活锁和死锁 ###

活锁：相互谦让导致看似同步进行，实则原地踏步  
死锁：一个进程拿着资源A请求资源B；另一个进程拿着资源B请求资源A，导致双方都在等待对方释放资源

### 六、死锁的产生和预防 ###

产生死锁的必要条件：  
互斥条件：进程要求对所分配的资源进行排它性控制，即在一段时间内某资源仅为一进程所占用。  
请求和保持条件：当进程因请求资源而阻塞时，对已获得的资源保持不放。  
不剥夺条件：进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。  
环路等待条件：在发生死锁时，必然存在一个进程–资源的环形链。

预防死锁：  
资源一次性分配：一次性分配所有资源，这样就不会再有请求了：（破坏请求条件）  
只要有一个资源得不到分配，也不给这个进程分配其他的资源：（破坏请保持条件）  
可剥夺资源：即当某进程获得了部分资源，但得不到其它资源，则释放已占有的资源（破坏不可剥夺条件）  
资源有序分配法：系统给每类资源赋予一个编号，每一个进程按编号递增的顺序请求资源，释放则相反（破坏环路等待条件）

### BIO、NIO、AIO ###

https://zhuanlan.zhihu.com/p/152247738  
BIO例子【多个线程处理业务】

func main(){ 
    	listen, err := net.Listen("tcp", "0.0.0.0:4000")
    	if err != nil { 
    		log.Fatal(err)
    	}
    	defer listen.Close()
    	for { 
    		socket, err := listen.Accept()  // 2. 接收请求返回套接字(阻塞)
    		if err != nil { 
    			log.Fatal(err)
    		}
    		go process(socket)  // 3.处理请求
    	}

NIO例子(由java例子改造，仅供理解不可运行)【一个线程处理多个业务】

type SocketChannel struct{ 
    	socket net.Conn
    	schannel chan
    }
    func(s *SocketChannel)Bind(proto, addr string) (sc *SocketChannel, err error) { 
    	listen, err := net.Listen(proto, addr)
    	if err !=nil{ 
    		return nil, err
    	}
    	s.socket = listen
    	schannel = make([]net.Conn, 0, 10)
    	go func(){ 
    		for{ 
    		socket, err := listen.Accept()  // 2. 接收连接放进管道
    			if err == nil && socket !=nil{ 
    				s.schannel <- socket
    			}
    		}
    	}()
    	return
    }
    func (s *SocketChannel)Accept() net.Conn { 
    	select{ 
    	case c := <-s.schannel:
    		return c
    	default:
    		return nil
    	}
    }
    func (s *SocketChannel)Close() { 
    	s.socket.Close()
    }
    
    var socketArray = []net.Conn
    func main(){ 
    	sc, err := net.Bind("tcp", "0.0.0.0:4000")
    	if err != nil { 
    		log.Fatal(err)
    	}
    	defer sc.Close()
    	for { 
    		socket := sc.Accept()  // 接收套接字(非阻塞)
    		if socket !=nil{ 
    			socketArray = append(socketArray, socket)
    		}
    		// 遍历连接进行数据读取
    		for i:=0;i<len(socketArray);i++{  // 主动轮询socket,可改链表存便于修改
    			var buffer bytes.NewBuffer()
    			io.Write(socketArray, buffer)
    			if len(buffer) > 0 { 
    				fmt.Println("接收到消息", string(buffer))
    			}else if len(buffer) == -1 { 
    				socketArray.Remove(i);  // 此处象征性移除，语法有错仅供理解
    				fmt.Println("断开连接")
    			}
    		}
    	}

### Epoll的底层实现 ###

epoll\_create()：调用linux系统的内核函数epoll\_create()创建epoll实例  
epoll\_wait()：调用linux系统的epoll\_wait等待文件描述符epfd(epoll实例)的事件。当socket收到数据后，操作系统的`中断`程序调用回调函数会给epoll实例的事件就绪列表rdlist里添加该socket引用(这块是操作系统实现的)，当程序执行到epoll\_wait时，如果rdlist已经引用了socket，那么epoll\_wait直接返回；若rdlist为空，阻塞进程。  
epoll\_ctl()：处理事件绑定

> 中断是系统用来响应硬件设备请求的一种机制，操作系统收到硬件的中断请求，会打断正在执行的进程，然后调用内核中的中断处理程序来响应请求。例如c/s通信中，s网卡收到客户端数据，将触发操作系统中断程序，将事件放进就绪事件列表rdlist

### 进程阻塞为什么不占用CPU资源 ###

进程执行的过程的确是在内核CPU中执行的，会消耗CPU。但是当进程阻塞变成等待态的时候，会被加入该socket的等待队列中，并不会出现在内核中了，而是在socket的等待队列中“等待”。当进程被操作系统唤醒后，又会被加入到工作队列中。

### 为什么Kafka吞吐量如此高 ###

kafka使用sendfile系统调用：可以避免数据在内核态和用户态的拷贝来优化数据传输效率，也称0次拷贝