三次握手是否会成为服务端的并发瓶颈？

IT行业相对于一般传统行业，发展更新速度更快，一旦停止了学习，很快就会被行业所淘汰。所以我们需要踏踏实实的不断学习，精进自己的技术，尤其是初学者。今天golang学习网给大家整理了《三次握手是否会成为服务端的并发瓶颈？》，聊聊Java、go、python、C++、计算机网络，我们一起来看看吧！

问题内容

服务端采用多线程模型：

• master thread 负责 accept，创建和客户端的 socket 连接，并把 clientsocket 投递到线程池中
• 线程池中的 work thread 负责读写 clientsocket，先读后写，然后关闭 clientsocket

问题在这个

master thread

1ms

RPS

1000 RPS

但是像

Nginx

指的是 socket 的

accept

Nginx

虽然 Nginx 是多进程模型，但是先不管这个

我的逻辑，用下面的 python 代码可以大概描述：

import socket
import sys
import time
import threading
from loguru import logger
from concurrent.futures import ThreadPoolExecutor
from concurrent.futures._base import Future

default_encoding: str = 'utf-8'

pool = ThreadPoolExecutor(
    max_workers=20,
    thread_name_prefix='simple-work-thread-pool'
)


def init_serversocket() -> socket.socket:
    serversocket = socket.socket(
        family=socket.AF_INET,
        type=socket.SOCK_STREAM
    )

    # 获取本地主机名
    host = socket.gethostname()

    logger.debug(f'host {host}')

    port = 9999

    # 绑定端口号
    serversocket.bind(('0.0.0.0', port))

    # 设置最大连接数，超过后排队
    serversocket.listen(5)

    return serversocket


def send_response(clientsocket: socket.socket, addr: tuple, response_body: bytes) -> int:
    send_len: int = clientsocket.send(response_body)
    clientsocket.close()
    return send_len


def start_request(clientsocket: socket.socket, addr: tuple) -> int:
    logger.debug(f'get message from {addr}')
    request_body: bytes = clientsocket.recv(2048)
    request_text: str = request_body.decode(encoding=default_encoding)

    response_text: str = f'server get message: {request_text}'

    response_body: bytes = response_text.encode(default_encoding)
    time.sleep(1)
    return send_response(clientsocket=clientsocket, addr=addr, response_body=response_body)


def start_request_callback(future: Future) -> None:
    send_len: int = future.result()
    logger.debug(
        f'{threading.current_thread().name}, send payload len is {send_len}')


serversocket = init_serversocket()


while True:
    clientsocket, addr = serversocket.accept()

    clientsocket: socket.socket
    addr: tuple

    future: Future = pool.submit(start_request, clientsocket, addr)
    future.add_done_callback(start_request_callback)

正确答案

服务端在listen监听时，其实就已经可以建立连接了，所以这上面有个误区，accept并不是在进行三次握手，accept只是在已建立连接队列获取套接字来处理，所以accept操作不存在瓶颈

而Nginx能处理百万级别连接，主要原因是其使用多进程+IO多路复用模型，IO多路复用与传统的一个线程处理一个连接不同，它可以在单个线程里通过操作系统提供的select/poll/epoll等系统调用来同时管理多个连接，这才是高并发的关键所在

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。