@InkStone
@flyqie
@chenyu0x00
@pengjay
@ccnoobs
刚才实测, 同一个客户端, 先向服务端 1 发送 7 万次请求, 再向服务端 2 发送 7 万次请求.

结果是向服务端 1 发送到 6 万多次时就报 SocketException: 通常每个套接字地址(协议/网络地址/端口)只允许使用一次。

再向服务端 2 发请求时, 一次请求都发不出去.

实践证明在 windows 上, 端口是共用的, 若通过端口 9000 请求 dstIp1 并关闭后, 9000 端口进入 time_wait 状态, 此时往其他 dstIp 发送请求时也无法使用这个端口.

服务端代码
```C#
using System.Net;
using System.Net.Sockets;

int port = 9000;
TcpListener server = new TcpListener(IPAddress.Any, port);
server.Start();
Console.WriteLine($"Server listening on :{port}");

try
{
var writer = File.AppendText("c:/temp/a.txt");
List<int> ports = [];
while (true)
{
TcpClient client = server.AcceptTcpClient();
IPEndPoint endPoint = (IPEndPoint)client.Client.RemoteEndPoint!;
ports.Add(endPoint.Port);
if (ports.Count > 10)
{
writer.WriteLine(string.Join("\r\n", ports));
writer.Flush();
ports.Clear();
}
}
}
catch (SocketException e)
{
Console.WriteLine($"SocketException: {e}");
}
finally
{
server.Stop();
}
```

客户端代码
```C#
public class UnitTest1
{
[TestMethod]
public async Task TestMethod1()
{
int k = 0;
for (int j = 0; j < 70; j++)
{
List<Task> list = [];
for (int i = 0; i < 1000; i++)
{
k++;
Task task = OpenAndCloseTcp("10.98.20.129");
list.Add(task);
}

await Task.WhenAll(list);
Console.WriteLine(k);
}
}

[TestMethod]
public async Task TestMethod2()
{
int k = 0;
for (int j = 0; j < 70; j++)
{
List<Task> list = [];
for (int i = 0; i < 1000; i++)
{
k++;
Task task = OpenAndCloseTcp("10.98.20.130");
list.Add(task);
}

await Task.WhenAll(list);
Console.WriteLine(k);
}
}

private async Task OpenAndCloseTcp(string ip)
{
using var client = new TcpClient();
await client.ConnectAsync(ip, 9000);
await using NetworkStream stream = client.GetStream();
byte[] bytes = "\r\n"u8.ToArray();
await stream.WriteAsync(bytes);
}
}
```

@chenyu0x00 我就说为啥我这突破不了 2000 了, 我还以为哪里配置有问题. 我这里是代理了 Modbus 主服务器, 走的是短链接 tcp 协议, 不是 http. Modbus 主服务器是施耐德的 PLC, 限制只能短链接. 这种情况下, 还有什么别的办法突破 2000 这个限制吗?

@chenyu0x00 但是 nginx 反代呢, 他跟后端服务器之间, nginx 的 IP 是固定的, 后端服务器的 IP 和端口也是固定的, 这个时候只有 nginx 的端口是动态的了. 可不可以认为这种情况下, nginx 的 TPC 不可能>2000?

@codehz nginx 不是服务端呀, nginx 是做反向代理, 是客户端. benchmark 程序可以使用端口复用, nginx 应该是不会端口复用的吧?
也就是说, 就是 keep-alive 确保了可以突破 2000?

@InkStone 这跟四元组有什么关系? nginx 压测, 后端起一个服务器, nginx 代理请求到这个服务器, 测试端全部是短链接请求, dstPort,dstIp, srcIp 都是固定的, 只有 srcPort 是变化的.

我司用的国产古方金丝楠木发布

看看是不是有人在接口里写了一句 thread.sleep

@huanxi0701 小皮是什么

为什么你们还在用网关, 网关这种东西, 自 k8s 诞生的那一天起就被淘汰了.

我正在开发一款无线脑波输入法, 只要将一个硬币大小的设备放在口袋里, 就能精准读取你的脑电波, 分析你的想法, 精准打字.

@ColdBird 场景很简单, 后台每生成一条日志就发到前端, 前端按时间倒序将日志一条条显示出来, 最多显示最近的 45 条.
react 里循环 div 需要给个 key. 已知后端不是我这个组的, 别人只发日志, 不会给你带个 id 过来.
我当然也可以随便给个 key, 或者就用日志内容当 key, 但如果有自增, 不是性能更好么?

手机号出问题了接不了码???
手机号怎么可能出问题了, 你是缅甸北部诈骗人员, 手机号被大陆封了?

我不信, 视频发来看看

@main1234 我试了下, 结果不对啊

@main1234 你这个算法有问题啊,
if sum < target1 && sum-track[len(track)-1] < target1 && sum-track[len(track)-1] < target1-target2
是不是应该改成
if sum > target1 ...

@xhatt510 你这么牛逼, 不也还是跟他平级. 事实就是别想太多, 早点糊弄完下班.

针对 Width 的二分查找, 在找到符合范围的数据后, 继续往上 100 条一跳查找是否满足条件, 不满足则往上 10 条一跳查找, 还不满足就往上一条条查找, 找到起始点. 同样往下找到结束点.
针对 Gsm 的二分查找, 因为每个 Width 对应的 Gsm 不会有太多, 二分查找到符合条件的数据后, 就不做 100 条一跳了, 直接 10 条一跳转 1 条一跳.

@wxf666 我目前采用的方案: 直接拉到内存里, 按 id 生成字典. 然后对 2 个区分度相对高的必查字段排序后生成了 1 个 List<Index>.

```
public struct Index(int Width, GsmId[] GsmIds);
public struct GsmId(int Gsm, int Id);
```

每次查询时, 先二分法查找 Width, 再对结果集遍历, 在 GsmIds 中二分法查找 Gsm, 得出满足 Width 和 Gsm 的 id 结果集, 再从字典中取回数据本体生成新的结果集.

这时候的结果集就已经只有几十条了, 其余字段查找, 直接在这个结果集中遍历

@cat1879 查一遍是没压力, 这是要瞬间根据不同条件查几千遍.