Go 语言自我提升 (三次握手 - 四次挥手 - TCP状态图 - udp - 网络文件传输)

三次握手：

创新互联服务紧随时代发展步伐，进行技术革新和技术进步，经过10余年的发展和积累，已经汇集了一批资深网站策划师、设计师、专业的网站实施团队以及高素质售后服务人员，并且完全形成了一套成熟的业务流程，能够完全依照客户要求对网站进行成都网站建设、成都网站制作、建设、维护、更新和改版，实现客户网站对外宣传展示的首要目的，并为客户企业品牌互联网化提供全面的解决方案。

1. 主动发起连接请求端（客户端），发送 SYN 标志位，携带数据包、包号

2. 被动接收连接请求端（服务器），接收 SYN，回复 ACK，携带应答序列号。同时，发送SYN标志位，携带数据包、包号

3. 主动发起连接请求端（客户端），接收SYN 标志位，回复 ACK。

被动端（服务器）接收 ACK —— 标志着 三次握手建立完成（ Accept()/Dial() 返回 ）

四次挥手：

1. 主动请求断开连接端（客户端）， 发送 FIN标志，携带数据包

2. 被动接受断开连接端（服务器）， 发送 ACK标志，携带应答序列号。 —— 半关闭完成。

3. 被动接受断开连接端（服务器）， 发送 FIN标志，携带数据包

4. 主动请求断开连接端（客户端）， 发送 最后一个 ACK标志，携带应答序列号。—— 发送完成，客户端不会直接退出，等 2MSL时长。

等 2MSL待目的：确保服务器 收到最后一个ACK

滑动窗口：

通知对端本地存储数据的 缓冲区容量。—— write 函数在对端 缓冲区满时，有可能阻塞。

TCP状态转换：

1. 主动发起连接请求端：

CLOSED —— 发送SYN —— SYN_SENT(了解) —— 接收ACK、SYN，回发 ACK —— ESTABLISHED (数据通信)

2. 主动关闭连接请求端：

ESTABLISHED —— 发送FIN —— FIN_WAIT_1 —— 接收ACK —— FIN_WAIT_2 (半关闭、主动端)

—— 接收FIN、回复ACK —— TIME_WAIT (主动端) —— 等 2MSL 时长 —— CLOSED

3. 被动建立连接请求端：

CLOSED —— LISTEN —— 接收SYN、发送ACK、SYN —— SYN_RCVD —— 接收 ACK —— ESTABLISHED (数据通信)

4. 被动断开连接请求端：

ESTABLISHED —— 接收 FIN、发送 ACK —— CLOSE_WAIT —— 发送 FIN —— LAST_ACK —— 接收ACK —— CLOSED

windows下查看TCP状态转换：

netstat -an | findstr  端口号

Linux下查看TCP状态转换：

netstat -an | grep  端口号

TCP和UDP对比: 

TCP: 面向连接的可靠的数据包传递。 针对不稳定的 网络层，完全弥补。ACK

UDP：无连接不可靠的报文传输。 针对不稳定的 网络层，完全不弥补。还原网络真实状态。

优点                                                             缺点

TCP： 可靠、顺序、稳定                                      系统资源消耗大，程序实现繁复、速度慢

UDP：系统资源消耗小，程序实现简单、速度快                          不可靠、无序、不稳定

使用场景：

TCP：大文件、可靠数据传输。 对数据的 稳定性、准确性、一致性要求较高的场合。

UDP：应用于对数据时效性要求较高的场合。 网络直播、电话会议、视频直播、网络游戏。

UDP-CS-Server实现流程：

1.  创建 udp地址结构 ResolveUDPAddr(“协议”， “IP：port”) —— udpAddr 本质 struct{IP、port}

2.  创建用于 数据通信的 socket ListenUDP(“协议”, udpAddr ) —— udpConn (socket)

3.  从客户端读取数据，获取对端的地址 udpConn.ReadFromUDP() —— 返回：n，clientAddr， err

4.  发送数据包给 客户端 udpConn.WriteToUDP("数据"， clientAddr)

UDP-CS-Client实现流程：

1.  创建用于通信的 socket。 net.Dial("udp", "服务器IP：port") —— udpConn (socket)

2.  以后流程参见 TCP客户端实现源码。

UDPserver默认就支持并发！

------------------------------------

命令行参数： 在main函数启动时，向整个程序传参。 【重点】

语法： go run xxx.go   argv1 argv2  argv3  argv4 。。。

xxx.exe:  第 0 个参数。

argv1 ：第 1 个参数。

argv2 ：第 2 个参数。

argv3 ：第 3 个参数。

argv4 ：第 4 个参数。

使用： list := os.Args  提取所有命令行参数。

获取文件属性函数：

os.stat(文件访问绝对路径) —— fileInfo 接口

fileInfo 包含 两个接口。

Name() 获取文件名。 不带访问路径

Size() 获取文件大小。

网络文件传输 —— 发送端（客户端）

1.  获取命令行参数，得到文件名（带路径）filePath list := os.Args

2.  使用 os.stat() 获取 文件名（不带路径）fileName

3.  创建 用于数据传输的 socket  net.Dial("tcp"， “服务器IP+port”) —— conn

4.  发送文件名(不带路径)  给接收端， conn.write()

5.  读取 接收端回发“ok”，判断无误。封装函数 sendFile(filePath, conn) 发送文件内容

6.  实现 sendFile(filePath,  conn)

1) 只读打开文件 os.Open(filePath)

for {

2) 从文件中读数据  f.Read(buf)

3) 将读到的数据写到socket中  conn.write(buf[:n])

4）判断读取文件的 结尾。 io.EOF. 跳出循环

}

网络文件传输 —— 接收端（服务器）

1. 创建用于监听的 socket net.Listen() —— listener

2. 借助listener 创建用于 通信的 socket listener.Accpet()  —— conn

3. 读取 conn.read() 发送端的 文件名， 保存至本地。

4. 回发 “ok”应答 发送端。

5. 封装函数，接收文件内容 recvFile(文件路径)

1) f = os.Create(带有路径的文件名)

for {

2）从 socket中读取发送端发送的 文件内容 。 conn.read(buf)

3)  将读到的数据 保存至本地文件 f.Write(buf[:n])

4)  判断 读取conn 结束， 代表文件传输完成。 n == 0  break

}

Golang 解决TCP“粘包“问题

TCP 协议是面向连接，可靠的流式协议，当 Server 去 Read 的时候，每次读到的数据都不一定是完整的，该方法会返回读到的字节数，因此，当我们写 Server 的时候，什么时候去回调用户设置的 callback ？也就是怎么样保证每次都能拿到一个完整的包数据，这个就是”粘包“问题的由来。

传统的，有两种方法解决。一是分隔符协议，即每条消息结尾设置固定分隔符，Server 读到分隔符就认为读到了完整的包数据；二是长度协议，即在每个消息头部设置固定长度的字段，表征消息长度，再往后读取该长度的消息即可。

目前长度协议用的较多，因为分隔符协议需要 Server 不停的检测，很耗费性能。长度协议实现中比较重要的点是头部的长度以及字节序， 2 个字节可表示 2^16-1 个字节的内容，如果不够，那就上4字节，字节序相关的只是可以参考： ”字节序“是什么鬼？

先来个没处理粘包的：

common/server.go:

测试一下：

因为每次只读5个字节，可以明显看到消息”乱了“，但就算把这个值增大，你只要是设置了，就会存在这个问题。

delimeter/server.go:

还是拿上个测试脚本跑，结果：

这次看到每个消息长度不一样，但是都是”完整的“。

length/server.go:

client 也得相应调整：

测试结果：

效果跟分隔符协议一样，都可以解决”粘包“问题。

只要是 TCP 协议，任何语言都需要处理 ”粘包“ 问题，我们用 PHP 写一个客户端测试一下：

完美！

只有在直接使用 TCP 协议才存在 "粘包" 问题，其上层应用层协议比如 HTTP ，已经帮我们处理好了，无需关注这些底层，但是我们自己实现一个自定义协议，就必须考虑这些细节了。

2021-03-08

go语言TCP连接池rocket049/connpool使用

安装：

go get -v -u github.com/rocket049/connpool

go get -v -u gitee.com/rocket049/connpool

rocket049/connpool 包是本人用go语言开发的，提供一个通用的TCP连接池，初始化参数包括最高连接数、超时秒数、连接函数，放回连接池的连接被重新取出时，如果已经超时，将会自动重新连接；如果没有超时，连接将被复用。

可调用的函数：

调用示例：

在 Go 中实现一个支持并发的 TCP 服务端

TCP 和 UDP 服务端随处可见，它们基于 TCP/IP 协议栈，通过网络为客户端提供服务。在这篇文章中，我将介绍如何使用 Go 语言开发一个用于返回随机数、支持并发的 TCP 服务端。对于每一个来自 TCP 客户端的连接，它都会启动一个新的 goroutine（轻量级线程）来处理相应的请求。

你可以在 GitHub 上找到本项目的源码：concTcp.go。

这个程序的主要逻辑在 handleConnection 函数中，具体实现如下：

在 main 函数的实现部分，每当 TCP 服务端收到 TCP 客户端的连接请求，它都会启动一个新的 goroutine 来为这个请求提供服务。

首先， main 确保程序至少有一个命令行参数。注意，现有代码并没有检查这个参数是否为有效的 TCP 端口号。不过，如果它是一个无效的 TCP 端口号， net.Listen 就会调用失败，并返回一个错误信息，类似下面这样：

net.Listen 函数用于告诉 Go 接受网络连接，因而承担了服务端的角色。它的返回值类型是 net.Conn ，后者实现了 io.Reader 和 io.Writer 接口。此外， main 函数中还调用了 rand.Seed 函数，用于初始化随机数生成器。最后， for 循环允许程序一直使用 Accept 函数来接受 TCP 客户端的连接请求，并以 goroutine 的方式来运行 handleConnection(c) 函数，处理客户端的后续请求。

net.Listen 函数的第一个参数定义了使用的网络类型，而第二个参数定义了服务端监听的地址和端口号。第一个参数的有效值为 tcp 、 tcp4 、 tcp6 、 udp 、 udp4 、 udp6 、 ip 、 ip4 、 ip6 、 Unix （Unix 套接字）、 Unixgram 和 Unixpacket ，其中： tcp4 、 udp4 和 ip4 只接受 IPv4 地址，而 tcp6 、 udp6 和 ip6 只接受 IPv6 地址。

concTCP.go 需要一个命令行参数，来指定监听的端口号。当它开始服务 TCP 客户端时，你会得到类似下面的输出：

netstat 的输出可以确认 congTCP.go 正在为多个 TCP 客户端提供服务，并且仍在继续监听建立连接的请求：

在上面输出中，最后一行显示了有一个进程正在监听 8001 端口，这意味着你可以继续连接 TCP 的 8001 端口。第一行和第二行显示了有一个已建立的 TCP 网络连接，它占用了 8001 和 62556 端口。相似地，第三行和第四行显示了有另一个已建立的 TCP 连接，它占用了 8001 和 62554 端口。

下面这张图片显示了 concTCP.go 在服务多个 TCP 客户端时的输出：

类似地，下面这张图片显示了两个 TCP 客户端的输出（使用了 nc 工具）：

你可以在 维基百科上找到更多关于 nc （即 netcat ）的信息。

现在，你学会了如何用大约 65 行 Go 代码来开发一个生成随机数、支持并发的 TCP 服务端，这真是太棒了！如果你想要让你的 TCP 服务端执行别的任务，只需要修改 handleConnection 函数即可。

via:

作者：Mihalis Tsoukalos选题：lkxed译者：lkxed校对：wxy

网站标题：go语言tcp LOGO语言
标题路径：http://azwzsj.com/article/dojedee.html