GoLang NetPoll 实现分析

最新推荐文章于 2023-07-02 19:05:36 发布
最新推荐文章于 2023-07-02 19:05:36 发布
阅读量544 收藏
点赞数
分类专栏： golang 文章标签： golang 网络 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cugriver/article/details/124656135
版权

文章目录

基石-系统调用

根据《TCP/IP详解 卷2:实现》第十五章插口层，对bind,listen,accept等系统调用作出解释:

  • bind: 将一个本地网络运输层地址和插口联系起来。服务器进程需要绑定到一个已知的地址上，因为客户进程需要同已知地址建立连接或发送数据。
  • listen: 通知协议进程准备接受插口上的连接请求，同时设定可以排队等待的连接数上限，超过上限将拒绝进入排队队列等待。
  • accept: 等待连接请求。返回一个新的描述符，指向一个连接到客户端的新的插口。

在这里插入图片描述

无论如何封装，底层终究离不开这几个基础的系统调用。当socket准备完成后，接下来将面临另外一个问题，如何处理更多的连接;

如何处理请求连接

线性处理

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<signal.h>


#define err_print_exist(m) \
	do { \
		perror(m); \
		exit(EXIT_FAILURE); \
	} while(0);

void handleconn(int conn) {
	char buf[1024];
	while(1) {
		memset(buf, 0, sizeof(buf));
		int r = read(conn, buf, sizeof(buf));
		if (r == 0) {
			printf("client close\n");
			break;
		}else if (r < 0) {
			err_print_exist("read fail");
		} else {
			sleep(1); //假设服务处理逻辑需要耗时1秒
			write(conn, buf, r);
		}
	}
	close(conn);
}


int main(void) {
	//1. fd listen fd
	int fd = socket(AF_INET, SOCK_STREAM, 0);
	if (fd < 0) {
		err_print_exist("apply listen fd fail");
	}

	//2. 设置服务端socket结构
	struct sockaddr_in s;
	s.sin_family 	  = AF_INET;
	s.sin_port   	  = htons(1949);
	s.sin_addr.s_addr = inet_addr("192.168.56.105");

	//3. bind
	int r = bind(fd, (struct sockaddr *)&s , sizeof(s));
	if (r < 0) {
		err_print_exist("bind fail");
	}

	//4. listen 
	r = listen(fd, 3);
	if (r < 0) {
		err_print_exist("listen fail");
	}

	//5. accept
	struct sockaddr_in peer;
	socklen_t peerlen = sizeof(peer);
	int conn;

	while (1) {
		conn = accept(fd, (struct sockaddr *)&peer, &peerlen);
		if (conn < 0) {
			err_print_exist("accept fail");
		}
        //致命位置
		handleconn(conn);
	}
}
//clang sample.c -o sample

请求连接是一个一个处理的，当第一个请求连接在处理中时，第二个，第三个…都将不会被处理，对于高并发应用是致命的; 但是后续的连接已经在等待队列中了，待accept操作取连接;
在这里插入图片描述

进程处理

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<signal.h>
#include <sys/wait.h>


#define err_print_exist(m) \
	do { \
		perror(m); \
		exit(EXIT_FAILURE); \
	} while(0);

void handleconn(int conn) {
	char buf[1024];
	while(1) {
		memset(buf, 0, sizeof(buf));
		int r = read(conn, buf, sizeof(buf));
		if (r == 0) {
			printf("client close\n");
			break;
		}else if (r < 0) {
			err_print_exist("read fail");
		} else {
			sleep(1); //假设服务处理逻辑需要耗时1秒
			write(conn, buf, r);
		}
	}
	close(conn);
}

void handler(int sig) {
    while (waitpid(-1, NULL, WNOHANG) > 0);
}


int main(void) {
	signal(SIGCHLD, handler);

	//1. fd listen fd
	int fd = socket(AF_INET, SOCK_STREAM, 0);
	if (fd < 0) {
		err_print_exist("apply listen fd fail");
	}

	//2. 设置服务端socket结构
	struct sockaddr_in s;
	s.sin_family 	  = AF_INET;
	s.sin_port   	  = htons(1949);
	s.sin_addr.s_addr = inet_addr("192.168.56.105");

	//3. bind
	int r = bind(fd, (struct sockaddr *)&s , sizeof(s));
	if (r < 0) {
		err_print_exist("bind fail");
	}

	//4. listen 
	r = listen(fd, 3);
	if (r < 0) {
		err_print_exist("listen fail");
	}

	//5. accept
	struct sockaddr_in peer;
	socklen_t peerlen = sizeof(peer);
	int conn;

	pid_t pid;

	while (1) {
		conn = accept(fd, (struct sockaddr *)&peer, &peerlen);
		if (conn < 0) {
			err_print_exist("accept fail");
		}

		pid = fork();
		
		if (pid < 0) {
			err_print_exist("fork process fail");
		} else if (pid == 0) { //子进程
			close(fd);
			handleconn(conn);
			exit(EXIT_SUCCESS);
		} else {  //父进程
			close(conn);
		}

	}
}
//clang process.c -o process

为每个请求连接都分配一个进程处理，确实可以同时处理多个请求连接；同时需要注意更多开发细节，例如进程的创建和退出，避免僵尸进程的产生等
在这里插入图片描述

线程处理

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<signal.h>
#include<pthread.h>


#define err_print_exist(m) \
	do { \
		perror(m); \
		exit(EXIT_FAILURE); \
	} while(0);

void* handleconn(void* fd) {
	int conn = *(int*)fd;

	char buf[1024];
	while(1) {
		memset(buf, 0, sizeof(buf));
		int r = read(conn, buf, sizeof(buf));
		if (r == 0) {
			printf("client close\n");
			break;
		}else if (r < 0) {
			err_print_exist("read fail");
		} else {
			sleep(1); //假设服务处理逻辑需要耗时1秒
			write(conn, buf, r);
		}
	}
	close(conn);

	return 0;
}


int main(void) {
	//1. fd listen fd
	int fd = socket(AF_INET, SOCK_STREAM, 0);
	if (fd < 0) {
		err_print_exist("apply listen fd fail");
	}

	//2. 设置服务端socket结构
	struct sockaddr_in s;
	s.sin_family 	  = AF_INET;
	s.sin_port   	  = htons(1949);
	s.sin_addr.s_addr = inet_addr("192.168.56.105");

	//3. bind
	int r = bind(fd, (struct sockaddr *)&s , sizeof(s));
	if (r < 0) {
		err_print_exist("bind fail");
	}

	//4. listen 
	r = listen(fd, 3);
	if (r < 0) {
		err_print_exist("listen fail");
	}

	//5. accept
	struct sockaddr_in peer;
	socklen_t peerlen = sizeof(peer);
	int conn;

	pthread_t thread_id;

	while (1) {
		conn = accept(fd, (struct sockaddr *)&peer, &peerlen);
		if (conn < 0) {
			err_print_exist("accept fail");
		}

		r = pthread_create(&thread_id, NULL, handleconn, (void*)&conn);
		if (r < 0) {
			err_print_exist("pthread create fail");
		}
	}
}
//clang thread.c -o thread -lpthread

每个请求连接都分配一个线程处理，可以同时处理多个请求连接
在这里插入图片描述

线程池处理

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<signal.h>
#include<pthread.h>


#define err_print_exist(m) \
	do { \
		perror(m); \
		exit(EXIT_FAILURE); \
	} while(0);

//线程池部分
typedef struct threadpool_task_s {
	void* (*func)(void*); 	//回调函数
	void* arg;  		//回调函数参数
}threadpool_task_t; 

typedef struct threadpool_s {
	pthread_mutex_t	lock;  		//互斥锁
	pthread_cond_t 	queue_not_full; 
	pthread_cond_t 	queue_not_empty;

	pthread_t	  *threads;
	threadpool_task_t *task_queue;   //任务队列

	int thr_num;   //线程池线程数

	int queue_front;     //任务队列队头下标
	int queue_rear;	     //任务队列队尾下标
	int queue_size;      //任务队列当前任务数
	int queue_max_size;  //任务队列最大任务数
}threadpool_t;

//线程池消费任务
void *threadpool_thread(void* arg) {
	threadpool_t *pool = (threadpool_t *)arg;
    	threadpool_task_t task;

	while(1) {
		pthread_mutex_lock(&(pool->lock));

		while(pool->queue_size == 0) {
			pthread_cond_wait(&(pool->queue_not_empty), &(pool->lock));
		}

		task.func = pool->task_queue[pool->queue_front].func;
		task.arg = pool->task_queue[pool->queue_front].arg;

		pool->queue_front = (pool->queue_front + 1) % pool->queue_max_size;
		pool->queue_size--;

		pthread_cond_broadcast(&(pool->queue_not_full));

		pthread_mutex_unlock(&(pool->lock));

		(*(task.func))(task.arg); //回调函数
	}

	return NULL;

}


//释放线程池
int threadpool_free(threadpool_t *pool) {
	if (pool == NULL) {
		return 0;
	}	

	if(pool->task_queue) {
 		free(pool->task_queue);
	}

	if (pool->threads) {
		free(pool->threads);	
		pthread_mutex_lock(&(pool->lock));
        	pthread_mutex_destroy(&(pool->lock));
        	pthread_cond_destroy(&(pool->queue_not_empty));
        	pthread_cond_destroy(&(pool->queue_not_full));
	}
	free(pool);
	pool = NULL;

	return 0;
}


//创建线程池
threadpool_t* threadpool_create(int thr_num, int queue_max_size) {
	int i;
	threadpool_t *pool = NULL;
	
	do {
		//1. 分配内存初始化线程池结构
		pool = (threadpool_t *)malloc(sizeof(threadpool_t));
		if (NULL == pool) {
			break;
		}

		pool->thr_num = thr_num;
        	pool->queue_size = 0;
        	pool->queue_max_size = queue_max_size;
        	pool->queue_front = 0;
        	pool->queue_rear = 0;

		pool->threads = (pthread_t *)malloc(sizeof(pthread_t) * thr_num);
        	if (pool->threads == NULL) {
        	    break;
        	}
		memset(pool->threads, 0, sizeof(pthread_t) * thr_num);

		pool->task_queue = (threadpool_task_t *)malloc(sizeof(threadpool_task_t) * queue_max_size);
		if (pool->task_queue == NULL) {
            		break;
        	}

 		if (pthread_mutex_init(&(pool->lock), NULL) != 0 || pthread_cond_init(&(pool->queue_not_empty), NULL) != 0 || pthread_cond_init(&(pool->queue_not_full), NULL) != 0) {
                	break;
            	}

		for (i = 0; i < thr_num; i++) {
            		pthread_create(&(pool->threads[i]), NULL, threadpool_thread, (void *)pool);
        	}

		return pool;
	}while(0);

	threadpool_free(pool);
	
	return NULL;
}

void dispatch(threadpool_t *pool, void *func(void *arg), void *arg) {
	pthread_mutex_lock(&(pool->lock));

	//任务队列满阻塞分配
	while (pool->queue_size == pool->queue_max_size) {
        	pthread_cond_wait(&(pool->queue_not_empty), &(pool->lock));
    	}

	pool->task_queue[pool->queue_rear].func = func;
	pool->task_queue[pool->queue_rear].arg = arg;

	pool->queue_rear = (pool->queue_rear + 1) % pool->queue_max_size;
	pool->queue_size++;

 	pthread_cond_signal(&(pool->queue_not_empty));
    	pthread_mutex_unlock(&(pool->lock));
}



//线程池
void* handleconn(void* fd) {
	int conn = *(int*)fd;

	char buf[1024];
	while(1) {
		memset(buf, 0, sizeof(buf));
		int r = read(conn, buf, sizeof(buf));
		if (r == 0) {
			printf("client close\n");
			break;
		}else if (r < 0) {
			err_print_exist("read fail");
		} else {
			sleep(1); //假设服务处理逻辑需要耗时1秒
			write(conn, buf, r);
		}
	}
	close(conn);

	return 0;
}


int main(void) {
	//1. fd listen fd
	int fd = socket(AF_INET, SOCK_STREAM, 0);
	if (fd < 0) {
		err_print_exist("apply listen fd fail");
	}

	//2. 设置服务端socket结构
	struct sockaddr_in s;
	s.sin_family 	  = AF_INET;
	s.sin_port   	  = htons(1949);
	s.sin_addr.s_addr = inet_addr("192.168.56.105");

	//3. bind
	int r = bind(fd, (struct sockaddr *)&s , sizeof(s));
	if (r < 0) {
		err_print_exist("bind fail");
	}

	//4. listen 
	r = listen(fd, 3);
	if (r < 0) {
		err_print_exist("listen fail");
	}

	//5. accept
	struct sockaddr_in peer;
	socklen_t peerlen = sizeof(peer);
	int conn;

	pthread_t thread_id;

	threadpool_t *pool = threadpool_create(10, 100);
	if (pool == NULL) {
		err_print_exist("thread pool create fail");
	}

	while (1) {
		conn = accept(fd, (struct sockaddr *)&peer, &peerlen);
		if (conn < 0) {
			err_print_exist("accept fail");
		}

		dispatch(pool, handleconn, (void*)&conn);
	}
}

预先创建一批线程，减少线程创建的开销耗时，提高效率，开发复杂度增大
在这里插入图片描述

多路复用

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<errno.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<signal.h>
#include<sys/epoll.h>
#include<fcntl.h>


#define err_print_exist(m) \
	do { \
		perror(m); \
		exit(EXIT_FAILURE); \
	} while(0);

int handleconn(int conn) {
	char buf[1024];
	memset(buf, 0, sizeof(buf));
	int r = read(conn, buf, sizeof(buf));
	if (r == 0) {
		printf("client close\n");
		close(conn);
		return 0;
	}else if (r < 0) {
		err_print_exist("read fail");
		close(conn);
		return -1;
	} else {
		sleep(1); //假设服务处理逻辑需要耗时1秒
		write(conn, buf, r);
		return 0;
	}
}

int setnonblocking(int fd) {
    return fcntl(fd, F_SETFL, fcntl(fd, F_GETFD, 0)|O_NONBLOCK);
}


int main(void) {
	//1. fd listen fd
	int fd = socket(AF_INET, SOCK_STREAM, 0);
	if (fd < 0) {
		err_print_exist("apply listen fd fail");
	}

	//2. 设置服务端socket结构
	struct sockaddr_in s;
	s.sin_family 	  = AF_INET;
	s.sin_port   	  = htons(1949);
	s.sin_addr.s_addr = inet_addr("192.168.56.105");

	//3. bind
	int r = bind(fd, (struct sockaddr *)&s , sizeof(s));
	if (r < 0) {
		err_print_exist("bind fail");
	}

	//4. listen 
	r = listen(fd, 3);
	if (r < 0) {
		err_print_exist("listen fail");
	}

	//5. accept
	struct sockaddr_in peer;
	socklen_t peerlen = sizeof(peer);
	int conn;

	//6. epoll
	int efd = 0;
	
	efd = epoll_create1(0);
	if (efd < 0 ) {
		err_print_exist("epoll create fail");
	}
	struct epoll_event ev, events[0x10];

	ev.events = EPOLLIN;
	ev.data.fd = fd;

	if (epoll_ctl(efd, EPOLL_CTL_ADD, fd, &ev) < 0) {
               err_print_exist("epoll_ctl: listen_sock");
    }

	int nfds, n;

	while (1) {

		nfds = epoll_wait(efd, events, 0x10, -1);
		if (nfds < 0) {
               		err_print_exist("epoll_wait ");
		}

		for (n = 0; n < nfds; ++n) {
			if (events[n].data.fd == fd) {
				conn = accept(fd, (struct sockaddr *)&peer, &peerlen);
				if (conn < 0) {
					err_print_exist("accept fail");
				}
				r = setnonblocking(conn);
				if (r < 0) {
					err_print_exist("conn fd set non blocking fail");
				}
				ev.events = EPOLLIN | EPOLLET;
				ev.data.fd = conn;
				if (epoll_ctl(efd, EPOLL_CTL_ADD, conn, &ev) == -1) {
               				err_print_exist("epoll_ctl add accpet fd fail");
                       		}
			}
			else {
				if (handleconn(events[n].data.fd) < 0 ) {
					epoll_ctl(efd, EPOLL_CTL_DEL, events[n].data.fd, &ev);
				}
			}

		}	
	}
}

IO多路复用是指多个IO复用一个线程; 由复用器epoll完成网络IO的监听(读/写), 然后回调处理逻辑; 还是有些需要注意的点，比如非阻塞网络IO, 回调函数无需循环读取IO，有读写时会触发回调
在这里插入图片描述

Goroutine

package main

import (
	"bufio"
	"fmt"
	"io"
	"net"
)

func handleConn(c net.Conn) {
	defer c.Close()

	var buf = make([]byte, 1024)
	var r = bufio.NewReader(c)

	for {
		n, err := r.Read(buf)
		if err != nil && err == io.EOF {
			return
		}
		if err != nil {
			fmt.Println("read err")
			return
		}
		c.Write(buf[:n])
	}
}

func main() {
	l, err := net.Listen("tcp", "192.168.56.105:1949")
	if err != nil {
		fmt.Println("listen error:", err)
		return
	}

	for {
		c, err := l.Accept()
		if err != nil {
			fmt.Println("accept error:", err)
			break
		}
		go handleConn(c)
	}
}

Go netpoller 通过在底层对 epoll/kqueue/iocp 的封装，从而实现了使用同步编程模式达到异步执行的效果, 简约而不简单; 实现了使用同步编程模式达到异步执行的效果
在这里插入图片描述

引用：
Go netpoller 通过在底层对 epoll/kqueue/iocp 的封装，从而实现了使用同步编程模式达到异步执行的效果。总结来说，所有的网络操作都以网络描述符 netFD 为中心实现。netFD 与底层 PollDesc 结构绑定，当在一个 netFD 上读写遇到 EAGAIN 错误时，就将当前 goroutine 存储到这个 netFD 对应的 PollDesc 中，同时调用 gopark 把当前 goroutine 给 park 住，直到这个 netFD 上再次发生读写事件，才将此 goroutine 给 ready 激活重新运行。显然，在底层通知 goroutine 再次发生读写等事件的方式就是 epoll/kqueue/iocp 等事件驱动机制。

Go netpoller 原生网络模型之源码全面揭秘 文章分析的很深入，细节看这里;

总结

总体来说，请求连接对于服务端程序就是对fd的处理，可以是进程、线程、协程；高并发场景意味着单位时间请求连接多, 所以耗时越短越好，由于创建相同数量的进程、线程和协程“代价”不同，所以“收益”也不同。

参看

cugriver
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
谈谈NAPI机制
落尘纷扰的专栏
03-04 4437
1. 引入问题内核收包主要有两种手段：轮询和中断。通过轮询，内核可以不断持续的检查设备时候有包收上来，例如设置一个定时器，定期检查设备上的某个定时器。这种方法会轻易浪费掉很多系统资源。如果采用中断收包，当设备收到包时，可以产生一个硬件中断通知内核，内核将中断其他活动，然后调用一个中断处理程序以满足设备的需求，内核只是将数据包放到某个队列中并通知内核中的收包模块。这种方式是非常常见的，在低流量负载下...
Golang源码探究 —— 网络轮询器netpoller
Peerless__的博客
10-12 1671
网络通信是服务端程序必不可少也是至关重要的一部分，基于TCP Socket的通信则是网络编程的主流。TCP Socket是最常见的网络编程，在POSIX标准发布后，Socket得到了各大主流操作系统平台很好的支持。 Go是自带运行时的跨平台编程语言，Go的net包中暴露给开发者的Socket也是建立在操作系统原生socket接口之上的。netpoller是Go语言用来屏蔽各个操作系统底层高效I/O多路复用的网络轮询器，它屏蔽了各个操作系统底层不同而且复杂的I/O多路复用的使用，在上层为我们提
详解golang net之netpoll
weixin_30781433的博客
09-20 1271
golang版本1.12.9；操作系统：readhat 7.4 golang的底层使用epoll来实现IO复用。netPoll通过pollDesc结构体将文件描述符与底层进行了绑定。netpoll实现了用户层面的与底层网络IO相关的goroutine的阻塞/非阻塞管理。 对netpoll的介绍按照这篇文章的思路按照tcp建链中的listen/accept/read/write/clo...
Go源码之netpoll.go文件详解
techdashen的博客
06-26 119
总结：netpollblockcommit()函数的主要作用是将因网络I/O操作而被阻塞的goroutine暂时从运行队列中移除，并将其存放到netpollblock数组中，以便后续继续执行阻塞读/写操作，同时将运行队列中的其他goroutine先放到netpollextra数组中，并将所有网络I/O文件描述符的读/写事件取消，释放netpollWait队列的协程，重新加入到调度器的运行队列中，然后重新启用所有网络I/O文件描述符的读/写事件。其中，网络轮询器的数据结构具体是由操作系统提供的。
golang中的网络轮询器netpoll源码解析
猛犸象
11-24 843
golang中的网络轮询器netpoll源码解析
谈谈golang的netpoll原理(二)
恋恋风辰的技术博客
05-20 1270
接上文我们查看了bind和listen流程，直到了listen操作会在内核初始化一个epoll表，并将listen的描述符加入到epoll表中 如何保证epoll表初始化一次 前文我们看到pollDesc的init函数中调用了runtime的pollOpen函数完成的epoll创建和描述符加入，这里再贴一次代码 func (pd *pollDesc) init(fd *FD) error { serverInit.Do(runtime_pollServerInit) ctx, errno :=
golang struct 实现 interface的方法
09-20
总结来说，Golang的结构体可以通过包含一个接口字段来隐式实现接口，但这并不意味着必须实现接口的所有方法。这种设计提供了灵活性，但也需要开发者谨慎处理，以防止在运行时因调用未实现的方法而导致的`panic`。在...
golang实现海康相机抓拍demo
04-30
golang 实现海康相机抓拍，目前只支持球机。需要在代码中设置用户名和密码。 如何调试？用vscode打开，安装golang插件，即可直接调试运行。 编译与运行：运行go build命令，将HKnet.exe拷贝到build\Windows下，运行...
基于Golang协程实现流量统计系统视频.zip
03-01
目录网盘文件永久链接 project.zip 第l章课程介绍.a 第2章并发栏型Tan 第3章Go的协程rar 第4章示例环境搭建ram 第5章Go批里生成日志ar 第6章统计系统框架构成.rar 第7章统计统之口志费.rar 第8章统计系统之批星解析a...
golang实现选择排序
最新发布
07-15
golang实现选择排序
基于golang 实现 图片处理
10-21
基于golang 实现 图片的缩放、裁剪、水印、拼接、蒙板、合并等操作的Util工具。
golang版本的ntpclient
程序员记事本
04-02 596
一直想实现一个go语言版本的ntp客户端程序,今天终于鼓捣出来了，还是在家里学习效率高啊，代码如下： package main import ( "fmt" "github.com/beevik/ntp" "github.com/kardianos/service" "github.com/mako2kano/systime" "os" "time" ) func main()...
Go netpoll大解析
Seekload
04-18 841
开篇之前简单看过一点go原生netpoll，没注意太多细节。最近从头到尾看了一遍，特写篇文章记录下。文章很长，请耐心看完，一定有所收获。内核空间和用户空间在linux中，经常能看到两个词语:User space(用户空间)和Kernel space (内核空间)。简单地说， Kernel space是linux内核运行的空间，User space是用户程序运行的空间。它们...
从 Netpoll 中寻找 BIO/NIO 编程模型的对比 | Netpoll 源码解读
Lance_Yuan24的博客
11-03 439
最近在阅读《Go 组件设计与实现》这本小册，其中让我很感兴趣的一点是为什么在字节开源中间件团队CloudWeGo所开发的网络库 Netpoll 中使用了 NIO 模型，而没有使用 Go 标准库中所使用到的 BIO 编程模型。
谈谈golang的netpoll原理(一)
恋恋风辰的技术博客
05-18 2896
今天谈谈golang源码netpoll部分实现的细节和协程阻塞调度原理 epoll原理 epoll是linux环境下i/o多路复用的模型，结合下图简单说明epoll工作原理 上图说明了epoll生成描epoll表的基本流程，生成socket用来绑定和监听新的连接，将该socket放入epoll内核表，然后调用wait等待就绪事件。 当epoll wait返回就绪事件时，判断是否是新的连接，如果是新的连接则将描述符加入epoll表，监听读写事件。如果不是新的连接，说明已建立的连接上有读或写就绪事件，这样我
深入理解 Golang: 网络编程
不定期更新 Web 开发及机器学习相关博客
07-02 966
在 Go 中，内部采用结合阻塞模型和多路复用的方法。在这里就不再是线程操作 Socket，而是 Goroutine 协程。每个协程关心一个 Socket 连接：1.在底层使用操作系统的多路复用 IO；2.在协程层次使用阻塞模型。3.阻塞协程时，休眠协程。
浅谈 go netpoll
qq_42461373的博客
06-04 540
1.先谈epoll https://zhuanlan.zhihu.com/p/64746509 1.1 epoll定义 是I/O多路复用的一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪，就是这个文件描述符进行读写操作之前），能够通知程序进行相应的读写操作。 Level_triggered(水平触发)：当被监控的文件描述符上有可读写事件发生时，epoll_wait()会通知处理程序去读写。如果这次没有把数据一次性全部读写完(如读写缓冲区太小)，那么下次调用 epoll_wai
netpoll浅析
Justlinux2010的专栏
08-15 4779
netpoll只是一种框架和一些接口，只有依赖这个框架和接口实现的netpoll实例，netpoll才能发挥它的功能。类似于kernel中的vfs，vfs本身并不会去做具体的文件操作，只是为不同的文件系统提供了一个框架。netpoll不依赖于网络协议栈，因此在内核网络及I/O子系统尚未可用时，也可以发送或接收数据包。当然netpoll能够处理的数据包类型也很有限，只有UDP和ARP数据包，并且只能
golang dfa 实现
06-15
以下是一个简单的DFA实现步骤： 1. 定义状态和字符集：首先，你需要定义一组状态和一个输入字符集。这可以通过枚举或结构体来完成。 ```go type State int const ( StateA State = iota StateB // 添加更多状态...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cugriver

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值