本教程详细阐述了如何在go语言中利用其强大的并发特性，同时在不同端口上运行多个tcp服务器，包括http服务和自定义tcp协议服务。通过使用goroutine，开发者可以轻松地实现多服务监听与处理，确保各个服务独立运行且互不干扰，从而构建高效、可扩展的网络应用。
引言
在现代网络应用开发中，一个应用程序常常需要同时提供多种服务，例如HTTP API接口、WebSocket服务，或者自定义的TCP协议服务。Go语言凭借其内置的并发模型，为实现此类需求提供了优雅且高效的解决方案。本教程将指导您如何在Go中同时启动并管理监听不同端口的多个TCP服务。
Go语言的并发优势
Go语言通过Goroutine和Channel提供了强大的并发能力。Goroutine是一种轻量级的执行线程，由Go运行时管理，启动和切换的开销非常小。这使得Go程序能够轻松地并发执行数千甚至数百万个任务，非常适合处理高并发的网络连接。利用Goroutine，我们可以将每个服务器的监听逻辑封装起来，并在独立的Goroutine中运行，从而实现多端口的并发监听。
实现原理：Goroutine并发监听
核心思想是将每个服务器（无论是HTTP、自定义TCP或其他协议）的监听和连接处理逻辑封装在一个独立的函数中。然后，在程序的入口点（通常是main函数），使用go关键字将这些函数作为Goroutine启动。这样，每个服务器都将在其独立的Goroutine中运行，互不干扰地监听各自的端口并处理传入的连接。为了防止主Goroutine过早退出导致所有子Goroutine终止，我们需要一种机制来保持主Goroutine的活跃。
代码示例
以下是一个完整的Go程序示例，演示了如何同时运行一个HTTP服务器和一个自定义TCP服务器。
立即学习“go语言免费学习笔记（深入）”；
package main
import (
"fmt"
"io"
"log"
"net"
"net/http"
"os"
"os/signal"
"syscall"
"time"
)
// serveHTTP 启动一个HTTP服务器
func serveHTTP(port string) {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
log.Printf("HTTP request received from %s on port %s: %s %s", r.RemoteAddr, port, r.Method, r.URL.Path)
fmt.Fprintf(w, "Hello from HTTP server on port %s!", port)
})
log.Printf("HTTP server listening on :%s", port)
// http.ListenAndServe 会阻塞，因此需要在一个goroutine中运行
if err := http.ListenAndServe(":"+port, nil); err != nil && err != http.ErrServerClosed {
log.Fatalf("HTTP server error on port %s: %v", port, err)
}
log.Printf("HTTP server on port %s stopped.", port)
}
// serveCustomTCP 启动一个自定义TCP服务器
func serveCustomTCP(port string) {
listener, err := net.Listen("tcp", ":"+port)
if err != nil {
log.Fatalf("Custom TCP server error on port %s: %v", port, err)
}
defer listener.Close() // 确保在函数退出时关闭监听器
log.Printf("Custom TCP server listening on :%s", port)
for {
conn, err := listener.Accept()
if err != nil {
// 如果监听器已关闭，Accept会返回错误
if opErr, ok := err.(*net.OpError); ok && opErr.Op == "accept" && opErr.Err.Error() == "use of closed network connection" {
log.Printf("Custom TCP server on port %s listener closed, stopping accept loop.", port)
return
}
log.Printf("Error accepting connection on port %s: %v", port, err)
continue
}
// 为每个新连接启动一个goroutine进行处理
go handleCustomConnection(conn, port)
}
}
// handleCustomConnection 处理自定义TCP连接
func handleCustomConnection(conn net.Conn, port string) {
defer conn.Close() // 确保连接关闭
log.Printf("Accepted custom connection from %s on port %s", conn.RemoteAddr(), port)
buf := make([]byte, 1024)
for {
// 设置读取超时，防止客户端不发送数据导致阻塞
conn.SetReadDeadline(time.Now().Add(5 * time.Minute))
n, err := conn.Read(buf)
if err != nil {
if err == io.EOF {
log.Printf("Client %s on port %s disconnected.", conn.RemoteAddr(), port)
} else if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
log.Printf("Read timeout for client %s on port %s, closing connection.", conn.RemoteAddr(), port)
} else {
log.Printf("Error reading from custom connection %s on port %s: %v", conn.RemoteAddr(), port, err)
}
return
}
receivedData := string(buf[:n])
log.Printf("Received %d bytes from %s on port %s: %s", n, conn.RemoteAddr(), port, receivedData)
response := fmt.Sprintf("Echo from custom server on port %s: %s", port, receivedData)
_, err = conn.Write([]byte(response))
if err != nil {
log.Printf("Error writing to custom connection %s on port %s: %v", conn.RemoteAddr(), port, err)
return
}
}
}
func main() {
// 创建一个通道用于接收操作系统信号
stopChan := make(chan os.Signal, 1)
signal.Notify(stopChan, syscall.SIGINT, syscall.SIGTERM) // 监听中断和终止信号
// 启动HTTP服务器（使用8080端口，避免权限问题）
go serveHTTP("8080")
// 启动自定义TCP服务器
go serveCustomTCP("8088")
// 阻塞主Goroutine，直到接收到停止信号
<-stopChan
log.Println("Received shutdown signal, gracefully stopping servers...")
// 在实际应用中，这里需要实现服务器的优雅关机逻辑
// 例如，对于HTTP服务器可以使用 http.Server.Shutdown()
// 对于自定义TCP服务器，需要关闭 listener 并等待所有连接处理完毕
// 简单起见，这里仅演示信号处理，实际关机逻辑会更复杂
time.Sleep(2 * time.Second) // 留一些时间给goroutine处理
log.Println("Servers stopped.")
}代码解析
-
serveHTTP(port string) 函数
-
serveCustomTCP(port string) 函数
- 此函数用于启动一个自定义的TCP服务器。
- net.Listen("tcp", ":"+port) 创建一个TCP监听器。如果端口被占用或发生其他错误，它会返回错误。
- defer listener.Close() 确保在函数退出时关闭监听器，释放端口资源。
- 在一个无限循环 for {} 中，listener.Accept() 等待并接受新的客户端连接。Accept 也是一个阻塞调用。
- 每当一个新连接被接受时，go handleCustomConnection(conn, port) 就会为这个连接启动一个新的Goroutine，以便并发处理多个客户端。
-
handleCustomConnection(conn net.Conn, port string) 函数
- 这个函数负责处理单个自定义TCP连接。
- defer conn.Close() 确保连接在处理完毕后关闭。
- 它在一个循环中读取客户端发送的数据，并简单地将数据回写给客户端（实现一个简单的echo服务）。
- 加入了 conn.SetReadDeadline 来防止恶意或不活跃的客户端长时间占用连接。
- 对 conn.Read 返回的错误进行了详细处理，包括 io.EOF（客户端断开连接）和超时错误。
-
main() 函数
- stopChan := make(chan os.Signal, 1) 和 signal.Notify(...) 实现了对操作系统信号（如Ctrl+C）的监听。这是一种实现优雅关机的常见方式。
- go serveHTTP("8080") 和 go serveCustomTCP("8088") 分别启动了HTTP服务器和自定义TCP服务器的Goroutine。它们将并发运行，互不影响。
注意事项
- 错误处理： http.ListenAndServe 和 net.Listen 都会返回错误。务必进行适当的错误检查和日志记录，以便及时发现和解决问题。例如，端口冲突会导致 Listen 失败。
- 端口冲突： 不同的服务器必须监听不同的端口。如果尝试在同一端口上启动多个监听器，将会导致端口绑定失败。
-
优雅关机： 在生产环境中，实现服务器的优雅关机至关重要。当程序收到终止信号时，应该：
- 停止接受新的连接。
- 给正在处理的连接留出一定时间完成其操作。
- 关闭所有活动的连接和监听器。
- 对于HTTP服务器，http.Server.Shutdown() 方法可以实现优雅关机。对于自定义TCP服务器，需要手动关闭 net.Listener，并可能需要追踪和等待所有 handleCustomConnection Goroutine完成。
- 资源管理： 确保每个客户端连接在处理完毕后都调用 conn.Close() 来释放系统资源。这在自定义TCP服务器中尤为重要。
- 主Goroutine的生命周期： select {} 是一种简单的阻塞主Goroutine的方式，但它无法响应外部事件来停止服务。本教程中的信号处理机制是一个更好的实践，但更复杂的应用可能需要结合 context 包和 sync.WaitGroup 来更精细地协调Goroutine的生命周期和关机过程。
总结
Go语言通过其强大的Goroutine并发模型和简洁的网络库，使得同时运行多个不同协议的TCP服务器变得异常简单和高效。开发者可以轻松地构建模块化、高并发的网络服务，满足各种复杂应用场景的需求。理解并恰当运用Goroutine进行并发监听，是构建高性能Go网络应用的关键。
