符合中小企业对网站设计、功能常规化式的企业展示型网站建设
本套餐主要针对企业品牌型网站、中高端设计、前端互动体验...
商城网站建设因基本功能的需求不同费用上面也有很大的差别...
手机微信网站开发、微信官网、微信商城网站...
https://waterflow.link/articles/
成都创新互联主营甘肃网站建设的网络公司,主营网站建设方案,app软件开发,甘肃h5微信小程序搭建,甘肃网站营销推广欢迎甘肃等地区企业咨询
我看先看下流程:
我们先看下服务端:
package main
import (
"fmt"
"net"
)
func main() {
server := ":8330"
tcpAddr, err := net.ResolveTCPAddr("tcp", server)
if err != nil {
fmt.Println("resolve err:", err)
return
}
// 监听某个端口的tcp网络
listen, err := net.ListenTCP("tcp", tcpAddr)
if err != nil {
fmt.Println("listen err:", err)
return
}
defer listen.Close()
for {
// 等待下次请求过来并建立连接
conn, err := listen.Accept()
if err != nil {
fmt.Println("accept err:", err)
continue
}
// 在这个连接上做一些事情
go handler(conn)
}
}
func handler(conn net.Conn) {
}
我们运行下上面的代码:
go run server.go
然后在另一个shell中执行下面的命令:
watch -d 'netstat -nat |grep "8330"'
Every 2.0s: netstat -nat |grep "8330" userdeMacBook-Pro.local: Thu Sep 29 16:38:42 2022
tcp46 0 0 *.8330 *.* LISTEN
可以看到此时8330端口已经开启监听
客户端:
package main
import (
"fmt"
"net"
)
func main() {
serverAddr := ":8330"
tcpAddr, err := net.ResolveTCPAddr("tcp", serverAddr)
if err != nil {
fmt.Println("resolve err:", err)
return
}
// 发起一个tcp的网络拨号
_, err = net.DialTCP("tcp", nil, tcpAddr)
if err != nil {
fmt.Println("dial err:", err)
return
}
closed := make(chan bool)
// 客户端阻塞不直接关闭
for {
select {
case <-closed:
fmt.Println("服务端关闭")
return
}
}
}
其中核心的方法就是net.DialTCP,第一个参数会返回一个建立成功的连接,第二个参数会返回没建立成功的错误信息。
然后我们命令行执行下:
go run client.go
接着看下watch -d 'netstat -nat |grep "8330"'
的返回,这个命令是实时的,所以不需要重复执行
Every 2.0s: netstat -nat |grep "8330" userdeMacBook-Pro.local: Thu Sep 29 16:45:57 2022
tcp4 0 0 127.0.0.1.8330 127.0.0.1. ESTABLISHED
tcp4 0 0 127.0.0.1. 127.0.0.1.8330 ESTABLISHED
tcp46 0 0 *.8330 *.* LISTEN
可以看到客户端服务端,服务端和客户端都成功建立了连接(连接是否建立成功不是看是否有条线真连上了,连接状态是维护在各个端的)
同时我们也可以在wireshark中看到三次握手建立连接的流程:
我们现在稍微修改下服务端的代码:
package main
import (
"fmt"
"io"
"net"
"time"
)
func main() {
server := ":8330"
tcpAddr, err := net.ResolveTCPAddr("tcp", server)
if err != nil {
fmt.Println("resolve err:", err)
return
}
listen, err := net.ListenTCP("tcp", tcpAddr)
if err != nil {
fmt.Println("listen err:", err)
return
}
defer listen.Close()
for {
conn, err := listen.Accept()
if err != nil {
fmt.Println("accept err:", err)
continue
}
go handler(conn)
}
}
func handler(conn net.Conn) {
go func() {
for {
// 指定从buffer中读取数据的最大容量
var buf = make([]byte, 1024)
// 从buffer中读取数据并保存到buf中,n代表实际返回的数据大小
n, err := conn.Read(buf)
if err != nil {
// 客户端关闭会触发EOF
if err == io.EOF {
conn.Close()
return
}
fmt.Println("read err:", err)
return
}
fmt.Println("read data ", n, ":", string(buf))
}
}()
curTime := time.Now().String()
// 数据写到缓冲区
_, err := conn.Write([]byte(curTime))
if err != nil {
fmt.Println("write err:", err)
return
}
fmt.Println("send data:", curTime)
}
首先要明白,操作系统内核会为每个连接的客户端和服务端分配发送缓冲区和接收缓冲区。
非阻塞I/O,当应用程序调用非阻塞 I/O 完成某个操作时,内核立即返回,不会把 CPU 时间切换给其他进程,应用程序在返回后,可以得到足够的 CPU 时间继续完成其他事情。
读操作:如果套接字对应的接收缓冲区没有数据可读,在非阻塞情况下 read 调用会立即返回,一般返回 EWOULDBLOCK 或 EAGAIN 出错信息。
写操作:在非阻塞 I/O 的情况下,如果套接字的发送缓冲区已达到了极限,不能容纳更多的字节,那么操作系统内核会尽最大可能从应用程序拷贝数据到发送缓冲区中,并立即从 write 等函数调用中返回。可想而知,在拷贝动作发生的瞬间,有可能一个字符也没拷贝,有可能所有请求字符都被拷贝完成,那么这个时候就需要返回一个数值,告诉应用程序到底有多少数据被成功拷贝到了发送缓冲区中,应用程序需要再次调用 write 函数,以输出未完成拷贝的字节。
非阻塞 I/O 操作:拷贝→返回→再拷贝→再返回。
阻塞 I/O 操作:拷贝→直到所有数据拷贝至发送缓冲区完成→返回。
golang中底层使用的还是非阻塞的I/O,但是在代码层面做了一些处理,让用户感觉是以阻塞方式调用的。
...
for {
n, err := ignoringEINTRIO(syscall.Read, fd.Sysfd, p)
if err != nil {
n = 0
// 非阻塞方式调用,如果遇到syscall.EAGAIN报错,代表没拿到数据,继续循环
if err == syscall.EAGAIN && fd.pd.pollable() {
if err = fd.pd.waitRead(fd.isFile); err == nil {
continue
}
}
}
err = fd.eofError(n, err)
return n, err
}
...
在socket中,当客户端调用close()方法时,其实就是发送一个FIN标志位,意思就是我要主动关闭TCP连接了。Close方法会让对端的所有读写操作结束阻塞,并返回。
在golang中调用Close方法,会让对端的Read读取到EOF的错误,此时就代表我想关闭连接。对端接收到关闭的请求后也可以调用Close方法关闭连接。
客户端:
package main
import (
"fmt"
"io"
"net"
)
func main() {
serverAddr := ":8330"
tcpAddr, err := net.ResolveTCPAddr("tcp", serverAddr)
if err != nil {
fmt.Println("resolve err:", err)
return
}
conn, err := net.DialTCP("tcp", nil, tcpAddr)
if err != nil {
fmt.Println("dial err:", err)
return
}
closed := make(chan bool)
go func() {
for {
var buf = make([]byte, 1024)
n, err := conn.Read(buf)
if err != nil {
// 读取到EOF,服务端关闭连接
if err == io.EOF {
conn.Close()
closed <- true
return
}
fmt.Println("read err:", err)
return
}
fmt.Println("read data ", n, ":", string(buf))
}
}()
for {
select {
case <-closed:
fmt.Println("服务端关闭")
return
}
}
}
服务端:
package main
import (
"fmt"
"io"
"net"
"time"
)
func main() {
server := ":8330"
tcpAddr, err := net.ResolveTCPAddr("tcp", server)
if err != nil {
fmt.Println("resolve err:", err)
return
}
listen, err := net.ListenTCP("tcp", tcpAddr)
if err != nil {
fmt.Println("listen err:", err)
return
}
defer listen.Close()
for {
conn, err := listen.Accept()
if err != nil {
fmt.Println("accept err:", err)
continue
}
go handler(conn)
}
}
func handler(conn net.Conn) {
go func() {
for {
var buf = make([]byte, 1024)
n, err := conn.Read(buf)
if err != nil {
// 读取到EOF,客户端关闭连接
if err == io.EOF {
conn.Close()
return
}
fmt.Println("read err:", err)
return
}
fmt.Println("read data ", n, ":", string(buf))
}
}()
curTime := time.Now().String()
_, err := conn.Write([]byte(curTime))
if err != nil {
fmt.Println("write err:", err)
return
}
fmt.Println("send data:", curTime)
}
参考:
《极客时间:网络编程实战》