一个端口到底可以建立多少TCP连接？
 
这是一个很基础的问题，但是网上对于这个问题的解释千奇百怪。
 
有人说，一个端口只能建立一个TCP连接，所以说无论服务还是客户端都最多只能建立65535个TCP连接。还有人说，服务端因为accept之后新建立的socket是重用listen的端口的，所以服务端最多可以建立65535×n个连接，而客户端connect建立的端口不可重用所以客户端只能65535。
 
这里有两个误解：
 
误解一：一个端口只能建立一个TCP连接。事实上Linux内核对TCP连接的识别是通过四元组来区分，即（源ip，源port，目标ip，目标port）。这个四元组只要任意一个不同，就是完全不同的连接！所以说，只要建立的连接是不同的，一个端口是可以建立多个TCP连接的！
 
误解二：客户端connect建立的端口不可重用。在一篇讨论这个问题的知乎专栏中作者说“当Linux作为客户端建立连接的时候，最大连接数量是受内核参数net.ipv4.ip_local_port_range限制 而ip_local_port_range是可配置的，最大理论范围是0-65535”。他的这个结论建立在下面的代码：
 
 
我们可以看到作者的方法是：在客户端建立num个socket和同一服务器ip：port建立连接，如果是这样那么从四元组出发目的ip和目的port都固定了，那一个客户端端口当然只能建立一个和同一ip：port的连接，那这样算当然只能建立65535（端口数）个连接了！但是场景应当换到和不同的服务端ip：port建立连接啊！也就是说，对于一个端口，只要它要建立的连接不同是可以建立多个连接的。所以对于客户端也没有所谓”端口不可重用所以客户端只能65535“的无稽之谈！其能建立的最大TCP连接数量也应当是65535×n。n取决于单进程/系统/用户最大能打开的文件描述数和内存情况，其实文件描述符数量也不要紧，可以改内核参数对应的限制，所以真正限制一台主机（无论服务客户）的TCP最大连接数的只有内存！

TCP段结构中端口地址是16比特，可以有在0~65535范围内的端口号。对于这65536个端口号，有以下使用规定。 
 （1）端口号小于256的定义为常用端口，服务器一般都是通过常用端口号来识别的。任何TCP/IP实现所提供的服务都用1~1023之间的端口号。这些端口号由Internet端口号分配机构来管理； 
 （2）客户端通常对它所用的端口号并不关心，只需保证该端口号在本机上是唯一的就可以了。客户端口号因存在时间很短暂又称作临时端口号。 
 （3）大多数TCP/IP实现给临时端口分配1024~5000之间的端口号。大于5000的端口号是为其他服务器预留的（Internet上并不常用的服务） 
 常用的TCP协议所使用的端口如下所示 
 FTP （文件传输服务） 21 
 TELNET（远程登陆）23 
 HTTP：（超文本传送协议） 80 
 GOPHER（菜单驱动信息检索） 70 
 SMTP（简单邮件传送协议）25 
 POP3（接收邮件）与SMTP对应 110
 
TCP重传策略 
 TCP协议用于控制数据段是否需要重传的依据是设立重发定时器。在发送一个数据段的同时启动一个重发定时器，如果在定时器超时前收到确认，就关闭该定时器，如果定时器超时前没有收到确认，则重传该数据段。 
 TCP拥塞控制 
 因特网中，对拥塞的控制大部分是由TCP来完成，对拥塞控制的最有效的方法是降低数据传输速率。要进行拥塞控制首先要检测到拥塞的发生，由于传输线路质量的提高，由传输错误 造成的数据丢失的情况越来越少，因此，因特网上的传输超时大部分是因拥塞造成的。这样，就可以明确地认为，如果出现传输超时就意味着出现了拥塞。 
 造成拥塞出现，是由网络容量与接受方容量两个方面的问题引起的，需要分别处理。为此，发送方除前面讲到的接受方承认的发送窗口外，增加一个拥塞窗口，每个窗口都反应出发送方能够传输的字节数，发送方取两个窗口中的最小值作为发送的字节数。 
 在刚建立连接时，将拥塞窗口的大小初始化为该连接所需的最大数据段的长度值，并发送一个最大长度的数据段。如果在定时器超时前，得到 确认，将拥塞窗口的大小增加一个数据段的字节数，并发送两个数据段，如果每个数据段在定时器超时前都得到确认，就再在原基础上增加一倍，即为4个数据段的大小，如此发反复，每次都在前一次的基础上加倍。当定时器超时或达到发送窗口设定的值时，停止拥塞窗口尺寸的增加，这种反复称为慢速启动，所有的TCP协议都支持这种方法。

个人博客：www.saoguang.top
 
一、背景
 
记得上学期暑假的时候我基于MFC写了一个简单的聊天程序。那个聊天程序，两部分组成，监听客户端请求线程和客户端请求处理线程。
 
1.服务器接收到登陆请求，验证登陆信息后，如果通过验证建立新线程与其交互，并通知用户连接到新的端口，并创建好新端口的SOCKET连接。
 
2.然后将用户类和新端口传给新建立的客户端请求处理线程。
 
当时，可能是没理解好的原因，误以为，一个端口同一时间只能建立起一个TCP连接。所以写这个聊天程序时才会每一个用户分配一个新的端口。
 
之前，自己了解HTTP后，接触到web应用开发的时候，就疑惑了，web server接收浏览器的请求，都是从80端口接受请求。当时没仔细去想，就以为web server和我那个聊天程序一样，会去建立新的线程与其进行请求处理。
 
二、问题
 
最近，写爬虫的时候用到了Smsniff去抓包。发现，一个http请求中。往往是只与服务器的80端口进行通信。这就与我记忆中的SOCKET冲突了。于是今天写了个小代码测试了一下，一个端口，真的能建立多个连接。
 
三、代码逻辑流程
 
1.server
 
①服务端主线程：负责监听5174端口，如果有请求，accept到系统分配的SOCKET(为unsigned int， recv接受函数就需要这个SOCKET)于是建立一个新线程，将这个SOCKET通过lpParament传递给新线程。
 
②服务器信息接受线程：负责从lpParment从拿到SOCKET并，recv客户端发来的信息。
 
2.client
 
连接到服务器的5174端口，并发送消息。
 
四、执行结果
 
一个端口的确能同时建立多条TCP请求。
 
 
五、理解
 
综合部分网上看到的资料。我的理解是，一个连接的唯一标识是[server ip, server port, client ip, client port]也就是说。操作系统，接收到一个端口发来的数据时，会在该端口，产生的连接中，查找到符合这个唯一标识的并传递信息到对应缓冲区。
 
1.一个端口同一时间只能bind给一个SOCKET。就是同一时间一个端口只可能有一个监听线程(监听listen之前要bind)。
 
2.为什么一个端口能建立多个TCP连接，同一个端口也就是说 server ip和server port 是不变的。那么只要[client ip 和 client port]不相同就可以了。能保证接唯一标识[server ip, server port, client ip, client port]的唯一性。
 
 
 
六、疑问解答
 
1.如果监听的线程释放掉监听用的SOCKET了，会影响之前通过这个监听SOCKET建立的TCP连接么？
 
答案：并不会，SOCKET之间是独立的，不会有影响（我已经自己写了程序验证了，读者可以自己写代码验证）。
 
2.一个端口能建立多个UDP连接么？
 
答案：UPD本身就是无连接的。所以不存在什么多个UDP连接。只是，服务端接收UDP数据需要bind一个端口。一个SOCKET只能绑定到一个端口。
 
七、服务端和客户端代码
 
注意：如果用的是VS，记得把 SDL checks(安全开发生命周期检测关闭)
 
服务端：
 
#include <stdio.h>
#include <stdlib.h>
#include <WinSock2.h>
#pragma comment(lib,"Ws2_32.lib")
#include <memory.h>

#define BUF_SIZE 4096
#define QUEUE_SIZE 5

DWORD WINAPI ThreadProcServerConmunicate(
	_In_ LPVOID lpParameter
) {
	SOCKET * psc = (SOCKET *)lpParameter;

	int receByt = 0;
	while (1)
	{
		char buf[BUF_SIZE];
		receByt = recv(*psc, buf, BUF_SIZE, 0);
		buf[receByt] = '\0';
		if (receByt>0)
		{
			printf("%u : 接收的消息是：%s\n", *psc, buf);
		}
		else
		{
			printf("接收消息结束！");
			break;
		}

	}
	int ic = closesocket(*psc);
	free(psc);
	return 0;
}


int main() {
	
	WSADATA wsd;
	WSAStartup(MAKEWORD(2, 0), &wsd);

	SOCKET s = NULL;
	s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	struct sockaddr_in ch;
	memset(&ch, 0, sizeof(ch));
	ch.sin_family = AF_INET;
	ch.sin_addr.s_addr = INADDR_ANY;
	ch.sin_port = htons(5174);
	int b = bind(s, (struct sockaddr *) &ch, sizeof(ch));
	
	int l = listen(s, QUEUE_SIZE);
	printf("正在监听本机的5174端口\n");

	while (1) {
		SOCKET * psc = (SOCKET *)malloc(sizeof(SOCKET));
		*psc = accept(s, 0, 0);
		printf("一个客户端已经连接到本机的5174端口,SOCKET是 : %u \n", *psc);

		CreateThread(NULL,
			0,
			&ThreadProcServerConmunicate,
			psc,
			0,
			NULL
		);
	}
	
	int is = closesocket(s);
	WSACleanup();
	return 0;
}
 
客户端：
 
#include <stdio.h>
#include <stdlib.h>
#include <WinSock2.h>
#pragma comment(lib,"Ws2_32.lib")
#include <memory.h>

#define BUF_SIZE 4096

void main()
{
	WSADATA wsd;
	WSAStartup(MAKEWORD(2, 0), &wsd);

	SOCKET s = NULL;
	s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	struct sockaddr_in ch;
	memset(&ch, 0, sizeof(ch));
	ch.sin_family = AF_INET;
	ch.sin_addr.s_addr = inet_addr("127.0.0.1");
	ch.sin_port = htons(5174);

	int c = connect(s, (struct sockaddr *) &ch, sizeof(ch));
	printf("已经连接到服务器的5174端口,现在可以向服务器发送消息了！\n");

	char info[1024], buf[BUF_SIZE];

	while (1)
	{
		gets(info);
		if (info[0] == '\0')
			break;
		strcpy(buf, info);
		int nsend = send(s, buf, strlen(buf), 0);
		Sleep(500);
	}
	int ic = closesocket(s);
	WSACleanup();
	return 0;
}
 
 

唯一能够确定一个socket连接有4点
 
服务器的IP
服务器的Port
客户端的IP
客户端的Port
 
tomcat最多能建立多少个连接？tomcat作为服务端程序，一直在监听80端口，之前一直以为tomcat每接收到一个新的连接，都会创建一个新的socket，然后这个socket又会占用一个端口。但是事实上并不是这样的，肯定是会创建新的socket的，但是这个新创建的socket并不会占用新的端口。
 那么问题来了，客户端发送的数据，服务器是怎么区分是哪个客户端？
 关键就在于上面的4个点，标识一个socket的是上面的4个点，而不是单纯的一个本地ip和一个本地端口，所以tomcat每accpet到一个连接，都会创建一个新的socket连接，这个socket连接种包含了下面4个信息，假设现在tomcat的ip为12.1.11.11
 
服务器ip:12.1.11.11
服务器端口:80
客户端ip:213.32.1.2
客户端端口:80
 
由这4个信息标识一个唯一的socket，tomcat accept到的每一个连接的服务器ip和端口都是一样的，但是客户端的ip和端口是不一样的，根据唯一标识socket的4点，系统能正确的区分。
 
服务端的socket有什么特殊的？
 
其实就我们创建一个新的socket来说，他是没有什么特殊的，他就是一个未连接的socket，特殊的点在于socket.listen()方法
 
#include<sys/socket.h>
int listen(int sockfd, int backlog);
 
listen函数仅由TCP服务器调用，当socket函数创建一个套接口时，它被假设为一个主动套装口，也就是说，它是一个将调用connet发起连接的客户套接口。listen函数把一个未连接的套接口转换成一个被动套接口，指示内核应接受指向该套接口的连接请求。根据TCP状态转换图，调用listen导致套接口从CLOSED状态转换到LISTEN状态。
 注意，在java中是没有listen()函数的，因为java帮我们进行了封装，使用了ServerSocket来专门代表监听的Socket。
 运行下面这个简单的程序
 
public static void main(String[] args) throws IOException, InterruptedException {
    ServerSocket serverSocket = new ServerSocket(21111);
    Thread.sleep(100000000);
}
 
在windows中我们就能通过netstat -ano来查看端口占用，可以发现21111正处于监听状态
 
 我们查看Java中的ServerSocket类的构造函数
 
 能够看到，其实这与我们的c语言中的listen()函数差不多，其也有一个backlog参数。
 为了更好的理解backlog参数，我们必须认识到内核为任何一个给定的监听套接口维护两个队列：
 1、未完成连接队列（incomplete connection queue），每个这样的SYN分节对应其中一项：已由某个客户发出并到达服务器，而服务器正在等待完成相应的TCP三路握手过程。这些套接口处于SYN_RCVD状态。
 2、已完成连接队列（completed connection queue），每个已完成TCP三路握手过程的客户对应其中一项。这些套接口处于ESTABLISHED状态。
 当来自客户的SYN到达时，TCP在未完成连接队列中创建一个新项，然后响应以三路握手的第二个分节：服务器的SYN响应，其中稍带对客户SYN的ACK（即SYN+ACK）。这一项一直保留在未完成连接队列中，直到三路握手的第三个分节（客户对服务器SYN的ACK）到达或者该项超时为止（曾经源自Berkeley的实现为这些未完成连接的项设置的超时值为75秒）。如果三路握手正常完成，该项就从未完成连接队列移到已完成连接队列的队尾。当进程调用accept时，已完成连接队列中的队头项将返回给进程，或者如果该队列为空，那么进程将被投入睡眠，直到TCP在该队列中放入一项才唤醒它。
 
如果监听的线程释放掉监听用的SOCKET了，会影响之前通过这个监听SOCKET建立的TCP连接么？
 
这个问题的答案是不会的，利用ServerSocket建立的连接，即使是ServerSocket关闭了，这个连接依然还是存在，因为他们之间本身就没有任何关系了
 
测试代码，Server
 
public static void main(String[] args) throws IOException, InterruptedException {
    ServerSocket serverSocket = new ServerSocket();
    serverSocket.bind(new InetSocketAddress(8080));
    Socket accept = serverSocket.accept();
    new Thread(() -> {
        try {
            OutputStream outputStream = accept.getOutputStream();
            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream);
            while (true) {
                outputStreamWriter.write(UUID.randomUUID().toString() + System.lineSeparator());
                outputStreamWriter.flush();
                Thread.sleep(1000);
                System.out.println("写了一个");
            }
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }).start();
    serverSocket.close();
    System.out.println("连接关闭");
    Thread.sleep(100000);
}
 
Client
 
public static void main(String[] args) throws IOException, InterruptedException {
    Socket socket = new Socket();
    socket.connect(new InetSocketAddress("localhost", 8080));
    InputStream in = socket.getInputStream();
    BufferedReader reader = new BufferedReader(new InputStreamReader(in));
    String msg;
    while ((msg = reader.readLine()) != null) {
        System.out.println("读了一个");
        System.out.println(msg);
    }
    System.out.println("dsadsa");
    Thread.sleep(100000);
}
 
运行这两个代码我们就能发现，即使是ServerSocket关闭，依然能继续通信
 我们又利用netstat -ano命令来查看端口占用