Go语言直接使用Windows的IOCP API写一个echo服务器

已于 2024-05-29 13:38:26 修改
阅读量371 收藏 6
点赞数 4
分类专栏： # GO 网络 文章标签： golang 服务器 windows iocp echo服务器
于 2024-05-24 17:31:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/witton/article/details/139178400
版权
GO 同时被 2 个专栏收录
15 篇文章 0 订阅
订阅专栏
网络
6 篇文章 0 订阅
订阅专栏

Go的标准库中Windows下的网络是使用了IOCP的，参见go源码go/src/runtime/netpoll_windows.go，标准库为了与Epoll、kqueue等不同平台的IO模式使用统一的API，进行了封装。

如果想直接使用Windows的IOCP API编程，比如想按照：Windows下的高效网络模型IOCP完整示例中的流程写，就需要自行封装IOCP相关的API，虽然标准库中封装了很多系统调用，但是不是很全，而且API的函数签名也有一些问题，比如：

// Deprecated: CreateIoCompletionPort has the wrong function signature. Use x/sys/windows.CreateIoCompletionPort.
func CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uint32, threadcnt uint32) (Handle, error) {
	return createIoCompletionPort(filehandle, cphandle, uintptr(key), threadcnt)
}

// Deprecated: GetQueuedCompletionStatus has the wrong function signature. Use x/sys/windows.GetQueuedCompletionStatus.
func GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uint32, overlapped **Overlapped, timeout uint32) error {
	var ukey uintptr
	var pukey *uintptr
	if key != nil {
		ukey = uintptr(*key)
		pukey = &ukey
	}
	err := getQueuedCompletionStatus(cphandle, qty, pukey, overlapped, timeout)
	if key != nil {
		*key = uint32(ukey)
		if uintptr(*key) != ukey && err == nil {
			err = errorspkg.New("GetQueuedCompletionStatus returned key overflow")
		}
	}
	return err
}

// Deprecated: PostQueuedCompletionStatus has the wrong function signature. Use x/sys/windows.PostQueuedCompletionStatus.
func PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uint32, overlapped *Overlapped) error {
	return postQueuedCompletionStatus(cphandle, qty, uintptr(key), overlapped)
}

看了一下，其实内部调用的函数签名是没问题的，可以使用Go的魔法指令go:linkname来解决：

//go:linkname CreateIoCompletionPort syscall.createIoCompletionPort
func CreateIoCompletionPort(fileHandle syscall.Handle, cpHandle syscall.Handle, key uintptr, threadCnt uint32) (handle syscall.Handle, err error)

//go:linkname GetQueuedCompletionStatus syscall.getQueuedCompletionStatus
func GetQueuedCompletionStatus(cpHandle syscall.Handle, qty *uint32, key *uintptr, overlapped **syscall.Overlapped, timeout uint32) (err error)

//go:linkname PostQueuedCompletionStatus syscall.postQueuedCompletionStatus
func PostQueuedCompletionStatus(cphandle syscall.Handle, qty uint32, key uintptr, overlapped *syscall.Overlapped) (err error)

另外还需要使用到一些API，比如WSACreateEvent、WSAWaitForMultipleEvents、WSAResetEvent、WSAGetOverlappedResult，就需要自行从Ws2_32.dll中装载了：

var (
	modws2_32 = syscall.NewLazyDLL("Ws2_32.dll")

	procWSACreateEvent           = modws2_32.NewProc("WSACreateEvent")
	procWSAWaitForMultipleEvents = modws2_32.NewProc("WSAWaitForMultipleEvents")
	procWSAResetEvent            = modws2_32.NewProc("WSAResetEvent")
	procWSAGetOverlappedResult   = modws2_32.NewProc("WSAGetOverlappedResult")
)

func WSACreateEvent() (Handle syscall.Handle, err error) {
	r1, _, e1 := syscall.SyscallN(procWSACreateEvent.Addr())
	if r1 == 0 {
		err = errnoErr(e1)
	}
	return syscall.Handle(r1), nil
}

func WSAWaitForMultipleEvents(cEvents uint32, lpEvent *syscall.Handle, fWaitAll bool, dwTimeout uint32, fAlertable bool) (uint32, error) {
	var WaitAll, Alertable uint32
	if fWaitAll {
		WaitAll = 1
	}
	if fAlertable {
		Alertable = 1
	}
	r1, _, e1 := syscall.SyscallN(procWSAWaitForMultipleEvents.Addr(), uintptr(cEvents), uintptr(unsafe.Pointer(lpEvent)), uintptr(WaitAll), uintptr(dwTimeout), uintptr(Alertable))
	if r1 == syscall.WAIT_FAILED {
		return 0, errnoErr(e1)
	}
	return uint32(r1), nil
}

func WSAResetEvent(handle syscall.Handle) (err error) {
	r1, _, e1 := syscall.SyscallN(procWSAResetEvent.Addr(), uintptr(handle))
	if r1 == 0 {
		err = errnoErr(e1)
	}
	return
}

func WSAGetOverlappedResult(socket syscall.Handle, overlapped *syscall.Overlapped, transferBytes *uint32, bWait bool, flag *uint32) (err error) {
	var wait uint32
	if bWait {
		wait = 1
	}
	r1, _, e1 := syscall.SyscallN(procWSAGetOverlappedResult.Addr(), uintptr(socket), uintptr(unsafe.Pointer(overlapped)),
		uintptr(unsafe.Pointer(transferBytes)), uintptr(wait), uintptr(unsafe.Pointer(flag)))
	if r1 == 0 {
		err = errnoErr(e1)
	}
	return
}

笔者尝试了下，完全可以，

在这里插入图片描述

直接附上源码：

package main

import (
	"errors"
	"fmt"
	"os"
	"runtime"
	"syscall"
	"unsafe"
	_ "unsafe"
)

//go:linkname CreateIoCompletionPort syscall.createIoCompletionPort
func CreateIoCompletionPort(fileHandle syscall.Handle, cpHandle syscall.Handle, key uintptr, threadCnt uint32) (handle syscall.Handle, err error)

//go:linkname GetQueuedCompletionStatus syscall.getQueuedCompletionStatus
func GetQueuedCompletionStatus(cpHandle syscall.Handle, qty *uint32, key *uintptr, overlapped **syscall.Overlapped, timeout uint32) (err error)

//go:linkname PostQueuedCompletionStatus syscall.postQueuedCompletionStatus
func PostQueuedCompletionStatus(cphandle syscall.Handle, qty uint32, key uintptr, overlapped *syscall.Overlapped) (err error)

//go:linkname errnoErr syscall.errnoErr
func errnoErr(e syscall.Errno) error

var (
	modws2_32 = syscall.NewLazyDLL("Ws2_32.dll")

	procWSACreateEvent           = modws2_32.NewProc("WSACreateEvent")
	procWSACloseEvent            = modws2_32.NewProc("WSACloseEvent")
	procWSAWaitForMultipleEvents = modws2_32.NewProc("WSAWaitForMultipleEvents")
	procWSAResetEvent            = modws2_32.NewProc("WSAResetEvent")
	procWSAGetOverlappedResult   = modws2_32.NewProc("WSAGetOverlappedResult")
)

func WSACreateEvent() (handle syscall.Handle, err error) {
	r1, _, e1 := syscall.SyscallN(procWSACreateEvent.Addr())
	if r1 == 0 {
		err = errnoErr(e1)
	}
	return syscall.Handle(r1), err
}

func WSACloseEvent(handle syscall.Handle) (err error) {
	r1, _, e1 := syscall.SyscallN(procWSACloseEvent.Addr(), uintptr(handle))
	if r1 == 0 {
		err = errnoErr(e1)
	}
	return err
}

func WSAResetEvent(handle syscall.Handle) (err error) {
	r1, _, e1 := syscall.SyscallN(procWSAResetEvent.Addr(), uintptr(handle))
	if r1 == 0 {
		err = errnoErr(e1)
	}
	return
}

func WSAWaitForMultipleEvents(cEvents uint32, lpEvent *syscall.Handle, fWaitAll bool, dwTimeout uint32, fAlertable bool) (uint32, error) {
	var WaitAll, Alertable uint32
	if fWaitAll {
		WaitAll = 1
	}
	if fAlertable {
		Alertable = 1
	}
	r1, _, e1 := syscall.SyscallN(procWSAWaitForMultipleEvents.Addr(), uintptr(cEvents), uintptr(unsafe.Pointer(lpEvent)), uintptr(WaitAll), uintptr(dwTimeout), uintptr(Alertable))
	if r1 == syscall.WAIT_FAILED {
		return 0, errnoErr(e1)
	}
	return uint32(r1), nil
}

func WSAGetOverlappedResult(socket syscall.Handle, overlapped *syscall.Overlapped, transferBytes *uint32, bWait bool, flag *uint32) (err error) {
	var wait uint32
	if bWait {
		wait = 1
	}
	r1, _, e1 := syscall.SyscallN(procWSAGetOverlappedResult.Addr(), uintptr(socket), uintptr(unsafe.Pointer(overlapped)),
		uintptr(unsafe.Pointer(transferBytes)), uintptr(wait), uintptr(unsafe.Pointer(flag)))
	if r1 == 0 {
		err = errnoErr(e1)
	}
	return
}

func SetNonBlock(fd syscall.Handle) error {
	flag := uint32(1)
	size := uint32(unsafe.Sizeof(flag))
	ret := uint32(0)
	ol := syscall.Overlapped{}
	err := syscall.WSAIoctl(fd, 0x8004667e, (*byte)(unsafe.Pointer(&flag)), size, nil, 0, &ret, &ol, 0)
	if err != nil {
		return err
	}
	return nil
}

type IOData struct {
	Overlapped syscall.Overlapped
	WsaBuf     syscall.WSABuf
	NBytes     uint32
	isRead     bool
	cliSock    syscall.Handle
}

func closeIO(data *IOData) {
	if data.Overlapped.HEvent != syscall.Handle(0) {
		WSACloseEvent(data.Overlapped.HEvent)
		data.Overlapped.HEvent = syscall.Handle(0)
	}
	syscall.Closesocket(data.cliSock)
}

func main() {
	listenFd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_STREAM, syscall.IPPROTO_TCP)
	if err != nil {
		return
	}
	defer func() {
		syscall.Closesocket(listenFd)
		syscall.WSACleanup()
	}()
	v4 := &syscall.SockaddrInet4{
		Port: 6000,
		Addr: [4]byte{},
	}
	err = syscall.Bind(listenFd, v4)
	if err != nil {
		return
	}
	err = syscall.Listen(listenFd, 0)
	if err != nil {
		return
	}

	hIOCP, err := CreateIoCompletionPort(syscall.InvalidHandle, 0, 0, 0)
	if err != nil {
		return
	}
	count := runtime.NumCPU()
	for i := 0; i < count; i++ {
		go workThread(hIOCP)
	}

	defer func() {
		for i := 0; i < count; i++ {
			PostQueuedCompletionStatus(hIOCP, 0, 0, nil)
		}
	}()

	for {
		acceptFd, er := syscall.Socket(syscall.AF_INET, syscall.SOCK_STREAM, syscall.IPPROTO_TCP)
		if er != nil {
			break
		}
		b := make([]byte, 1024)
		recvD := uint32(0)
		data := &IOData{
			Overlapped: syscall.Overlapped{},
			WsaBuf: syscall.WSABuf{
				Len: 1024,
				Buf: &b[0],
			},
			NBytes:  1024,
			isRead:  true,
			cliSock: acceptFd,
		}
		data.Overlapped.HEvent, er = WSACreateEvent()
		if er != nil {
			fmt.Printf("WSACreateEvent failed:%s", er)
			closeIO(data)
			break
		}

		size := uint32(unsafe.Sizeof(&syscall.SockaddrInet4{}) + 16)
		er = syscall.AcceptEx(listenFd, acceptFd, data.WsaBuf.Buf, data.WsaBuf.Len-size*2, size, size, &recvD, &data.Overlapped)
		if er != nil && !errors.Is(er, syscall.ERROR_IO_PENDING) {
			er = os.NewSyscallError("AcceptEx", er)
			fmt.Printf("AcceptEx Error:%s", er)
			closeIO(data)
			break
		}

		_, er = WSAWaitForMultipleEvents(1, &data.Overlapped.HEvent, true, 100, false)
		if er != nil {
			fmt.Printf("WSAWaitForMultipleEvents Error:%s", er)
			closeIO(data)
			break
		}
		WSAResetEvent(data.Overlapped.HEvent)
		flag := uint32(0)
		er = WSAGetOverlappedResult(acceptFd, &data.Overlapped, &data.NBytes, true, &flag)
		if er != nil {
			fmt.Printf("WSAGetOverlappedResult Error:%s", er)
			closeIO(data)
			break
		}
		if data.NBytes == 0 {
			closeIO(data)
			continue
		}
		fmt.Printf("client %d connected\n", acceptFd)
		_, err = CreateIoCompletionPort(acceptFd, hIOCP, 0, 0)
		if err != nil {
			fmt.Printf("CreateIoCompletionPort Error:%s", er)
			closeIO(data)
			break
		}
		postWrite(data)
	}
}

func postWrite(data *IOData) (err error) {
	data.isRead = false
	// 这里输出一下data指针，让运行时不把data给GC掉，否则就会出问题
	fmt.Printf("%p cli:%d send %s\n", data, data.cliSock, unsafe.String(data.WsaBuf.Buf, data.NBytes))
	err = syscall.WSASend(data.cliSock, &data.WsaBuf, 1, &data.NBytes, 0, &data.Overlapped, nil)
	if err != nil && !errors.Is(err, syscall.ERROR_IO_PENDING) {
		fmt.Printf("cli:%d send failed: %s\n", data.cliSock, err)
		closeIO(data)
		return err
	}
	return
}

func postRead(data *IOData) (err error) {
	data.NBytes = data.WsaBuf.Len
	data.isRead = true
	flag := uint32(0)
	err = syscall.WSARecv(data.cliSock, &data.WsaBuf, 1, &data.NBytes, &flag, &data.Overlapped, nil)
	if err != nil && !errors.Is(err, syscall.ERROR_IO_PENDING) {
		fmt.Printf("cli:%d receive failed: %s\n", data.cliSock, err)
		closeIO(data)
		return err
	}
	return
}

func workThread(hIOCP syscall.Handle) {
	var pOverlapped *syscall.Overlapped
	var ioSize uint32
	var key uintptr
	for {
		err := GetQueuedCompletionStatus(hIOCP, &ioSize, &key, &pOverlapped, syscall.INFINITE)
		if err != nil {
			fmt.Printf("GetQueuedCompletionStatus failed: %s\n", err)
			return
		}
		ioData := (*IOData)(unsafe.Pointer(pOverlapped))
		if ioSize == 0 {
			closeIO(ioData)
			break
		}
		ioData.NBytes = ioSize
		if ioData.isRead {
			postWrite(ioData)
		} else {
			postRead(ioData)
		}
	}
}

源码只是一个示例，可能有不完善的地方，感兴趣的读者可以自行完善。

witton
关注
专栏目录
Go netpoll I/O 多路复用构建原生网络模型之源码深度解析
翼下之风的专栏
11-09 748
导言 Go 基于 I/O multiplexing 和 goroutine 构建了一个简洁而高性能的原生网络模型(基于 Go 的I/O 多路复用 netpoll)，提供了 goroutine-per-connection 这样简单的网络编程模式。在这种模式下，开发者使用的是同步的模式去编写异步的逻辑，极大地降低了开发者编写网络应用时的心智负担，且借助于 Go runtime scheduler 对...
C++ IOCP windows服务器
01-20
首先，启动主线程，接收来自客户端的请求。... 　IOCP服务器实现 #pragma once #include #include #include <Windows> #include #include #include CThreadPool.h #include WorkA.h #include Wor
是谁神化了IOCP——完成端口通讯服务器（IOCP Socket Server）设计（1）
码客 卢益贵 ygluu
08-27 8078
完成端口通讯服务器（IOCP Socket Server）设计（一）是谁神化了IOCPCopyright © 2009 代码客（卢益贵）版权所有QQ:48092788   源码博客：http://blog.csdn.net/guestcodeWindows系统下的socket模型有多种，其中完成例程的效率也是相当高的，其它的也不差（相关模型知识这里不多做介绍，读者可以自己搜
发布一套IOCP框架
思月行云
08-25 2590
原文链接：http://blog.csdn.net/chenyu2202863/archive/2010/08/17/5818920.aspx更新：2010/08/211. 提供MemoryPool支持（详情请查看猛击这里）2. 模仿asio中io_service服务，把dispatcher接口公开出来，可以post任意回调3. 增强网络服务端demo同时，把该套框架放到了Google code上，需要的朋友可以自行下载。svn：http://iocpframework.googlecode.com/svn
完成端口(IOCP)详解[1/2](转载)
xupeng1644的博客
06-16 804
版权声明：本文为CSDN博主「PiggyXP」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/piggyxp/article/details/6922277 一 前言 本系列里完成端口的代码在两年前就已经写好了，但是由于许久没有写东西了，不知该如何提笔，所以这篇文档总是在酝酿之中……酝酿了两年之后，终于决定开始动笔了，但愿还不算晚…… 这篇文档我非常详细并且图文并茂的介绍了关于网络编程模型中完成端口的方方面面的信息，从
gnet: 一个轻量级且高性能的 Go 网络框架
嘿嘿
11-17 6230
GitHub 主页 https://github.com/panjf2000/gnet 欢迎大家围观 ~~，目前还在持续更新，感兴趣的话可以 star 一下暗中观察哦。 ???? 简介 gnet是一个基于事件驱动的高性能和轻量级网络框架。它直接使用epoll和kqueue系统调用而非标准 Golang 网络包：net来构建网络应用，它的工作原理类似两个开源的网络库：netty和l...
【go基础】16.I/O模型与网络轮询器netpoller
lixiaonan0318的博客
03-24 695
一、I/O模型在linux世界中，所有I/O设备被抽象为文件Everything is File，都通过文件操作：open 打开；seek 改变读写位置；read write 读写；close 关闭文件描述符（File descriptor，FD）：用于访问文件或者其他 I/O 资源的抽象句柄，例如：管道或者网络套接字。不同的 I/O 模型会使用不同的方式操作文件描述符。5种I/O模型：同步的阻塞I/O模型非阻塞I/O模型I/O多路复用模型信号驱动I/O模型异步I/O模型。
net-iocp.rar_.net IOCP_IOCP_IOCP windows_Windows iocp使用_iocp编程
09-24
IOCP（Input/Output Completion Port）在Windows系统中提供了一种线程池机制，它允许应用程序通过一个单一的线程处理来自多个I/O操作的完成通知，从而实现高并发、低延迟的网络服务。 标题中的“net-iocp.rar”暗示...
C++语言实现的线程池，结合windowsIOCP完成端口，实现socket高并发服务端程序.zip
10-19
在本项目"C++语言实现的线程池，结合windowsIOCP完成端口，实现socket高并发服务端程序.zip"中，我们关注的核心是利用C++编程语言构建一个高性能的、支持高并发的TCP服务器。线程池和Windows的IO Completion Ports...
windows iocp编程实例
10-25
1. **创建IOCP**：首先，我们需要使用`CreateIoCompletionPort`函数创建一个IOCP。这个函数返回一个句柄，后续的所有操作都将围绕这个句柄进行。 2. **关联设备**：创建完IOCP后，需要将要进行I/O操作的设备（如...
epoll 使用golang实现
05-05
golang 语言实现 epoll 在 Linux, MacOS and windows 平台上
windows iocp网络通讯库封装
11-24
这个"windows iocp网络通讯库封装"显然是一个使用IOCP实现的C++库，它可能包含了客户端和服务器端的网络通信功能。下面将详细解释IOCP以及与之相关的技术。 1. **IOCP（Input/Output Completion Port）**： IOCP是...
golang netpoller揭秘
最新发布
iUcool的博客
04-28 695
netpoller依托于go调度器，提供了一种看上去同步的异步网络编程模式，显著地降低了开发难度更重要的是，go主动挂起goroutine等待网络IO的完成，而不是被动让系统线程去挂起，这就将执行网络IO的goroutine掌控在Go运行时中。
编写IOCP时的几个注意事项（转自mirosoft）
大宝(sodme)的专栏
04-04 3573
TIP 1: Use Winsock2 IOCP-capable functions, such as WSASend and WSARecv, over Win32 file I/O functions, such as WriteFile and ReadFile. 提示1：尽量使用WSASend和WSARecv进行数据收发Socket handles from Microsoft-based
Windows服务器高并发处理IOCP（完成端口）详细说明
热门推荐
波波诸葛伟
09-12 1万+
转载地址:https://blog.csdn.net/liuhengxiao/article/details/44040933 本系列里完成端口的代码在两年前就已经写好了，但是由于许久没有写东西了，不知该如何提笔，所以这篇文档总是在酝酿之中……酝酿了两年之后，终于决定开始动笔了，但愿还不算晚…..         这篇文档我非常详细并且图文并茂的介绍了关于网络编程模型中完成端口的方方面面的信息...
IOCP模型与网络编程
ada的自留地
06-25 1556
转自：http://blog.csdn.net/neicole/article/details/7549497/        Windows平台上伸缩性最好的一种I/O模型莫过IOCP了，不过设计和实现起来比较复杂一些。针对成千上万个套接字的并发处理，IOCP采用了线程池+队列+重叠结构的内核机制完成任务。需要说明的是IOCP其实不仅可以接受套接字对象句柄，还可以接受文件对象句柄等。
kcp-go源码解析
weixin_34067049的博客
06-12 288
2019独角兽企业重金招聘Python工程师标准>>> ...
【Go语言踩坑系列（七）】Goroutine（上）
NoSay
04-06 437
声明 本系列文章并不会停留在Go语言的语法层面，更关注语言特性、学习和使用中出现的问题以及引起的一些思考。 进程，线程到协程的发展 计算机发展至今有几个至关重要的时期： 1. 单任务时代 这个时代主要标志为批处理。我们都知道早期的计算机就是穿孔打卡来运行的，需要人工去做输入输出的处理工作，计算机只进行了计算，而且每次都只能执行一个流程，然后循环往复，这个大流程下计算机很大程度上是没有执行的，所以...
Golang实现简单tcp服务器04 -- 服务器的粘包处理
weixin_33850015的博客
06-02 208
2019独角兽企业重金招聘Python工程师标准>>> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值