原始碼：

#include <sys/epoll.h> 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <fcntl.h>
#include <netinet/in.h>
//返回值的巨集定義，在開發linux環境時，用0表示成功
#define RES_SUC 0
#define RES_FAIL -1

#define FD_NULL 0
#define null 0
#define MAX_EPOLL_FD 1024
#define LISTEN_SOCK_QUEUE 1024

#define WORK_STATE_STOP 0
#define WORK_STATE_RUN 1
//伺服器的監聽埠
#define LISTNE_PORT 3557

#define INVALID_SOCKET -1

#define MAX_EPOLL_EVENTS 1024
//epoll在無事件發生時的最大返回間隔時間
#define EPOLL_WAIT_INTERVAL 100 

#define  MAX_BUF_SIZE_READ 1024

static int g_fd_epoll = FD_NULL;
static int g_fd_listen_sock = FD_NULL;
static int g_run_server = WORK_STATE_RUN;
int main()
{
	printf("[main] will start test server!\n");
	//初始化測試伺服器
	if(init() == RES_FAIL)
	{
		printf("[main] init fail!\n");
		return RES_FAIL;
	}
	// 開始長迴圈工作
	if(main_loop() == RES_FAIL)
	{
		printf("[main] main_loop fail!\n");
		return RES_FAIL;
	}
	printf("[main] test server will exit!\n");
	return RES_SUC;
}
/**
*初始化服務端程式，成功返回RES_SUC
*/
int init()
{
	//建立epoll的控制代碼
	g_fd_epoll = epoll_create(MAX_EPOLL_FD);
	if(g_fd_epoll <= 0)
	{
		printf("[init] epoll_create fail!\n");
		return RES_FAIL;
	}
	//初始化監聽socket
	if(init_listen_socket() == RES_FAIL)
	{
		printf("[init] epoll_create fail!\n");
		return RES_FAIL;
	}
	
	return RES_SUC;
}
/*
*初始化監聽socket，成功則返回建立的監聽socket，否則返回RES_FAIL
*/
int init_listen_socket()
{
	printf("[init_listen_socket] will init listen socket!\n");
	//建立監聽socket的控制代碼
	g_fd_listen_sock = socket(AF_INET, SOCK_STREAM, 0);
	if(INVALID_SOCKET == g_fd_listen_sock)
	{
		printf("[init_listen_socket] create listen socket fail!\n");
		return RES_FAIL;
	}
	//設定監聽socket的狀態為非阻塞
	int opt = 1;
	opt = fcntl(g_fd_listen_sock, F_GETFL, 0);
	if(opt == -1 || fcntl(g_fd_listen_sock, F_SETFL, opt | O_NONBLOCK) == -1)
	{
		printf("[init_listen_socket] set socket state: O_NONBLOCK fail!\n");
		close(g_fd_listen_sock);
		return RES_FAIL;
	}
	
	//繫結socket到本地埠
	struct sockaddr_in serv_addr;
	serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);  // 使用本地通配地址
    serv_addr.sin_port = htons(LISTNE_PORT); 
	if(bind(g_fd_listen_sock, (struct sockaddr *)&serv_addr, sizeof( serv_addr)) != RES_SUC)
	{
		printf("[init_listen_socket] bind socket to port %d fail!\n", LISTNE_PORT);
		close(g_fd_listen_sock);
		return RES_FAIL;
	}
	//開啟socket的監聽狀態
	if(listen(g_fd_listen_sock, LISTEN_SOCK_QUEUE) == -1)
	{
		printf("[init_listen_socket] listen socket fail!\n");
		close(g_fd_listen_sock);
		return RES_FAIL;
	}
	
	//註冊監聽socket到epoll
	if(reg_socket(g_fd_listen_sock) == RES_FAIL)
	{
		printf("[init_listen_socket] reg_socket fail!\n");
		return RES_FAIL;
	}
	printf("[init_listen_socket] init listen socket suc!\n");
	return g_fd_listen_sock;
}
//註冊一個socket到epoll
int reg_socket(int new_sock)
{
	if(new_sock <= 0)
		return RES_FAIL;
	struct epoll_event new_events;
	new_events.data.fd = new_sock;
	new_events.events = EPOLLIN;//我們只關注有資料到來
	if(epoll_ctl(g_fd_epoll, EPOLL_CTL_ADD,new_sock, &new_events) < 0){
		printf("[reg_socket] register socket into epoll faill!\n");
		return RES_FAIL;
	}
	else		
		return RES_SUC;				
}
//主迴圈體
int main_loop()
{
	//建立一個epoll事件的緩衝區，以便存放就緒的檔案描述符
	struct epoll_event* epoll_events = null;
	epoll_events = (struct epoll_event*)malloc(sizeof(struct epoll_event) * MAX_EPOLL_EVENTS);
	if(epoll_events == null)
	{
		printf("[main_loop] allocating memory for epoll events faill!\n");
		return RES_FAIL;
	}
	int fd_ready_num = 0;
	printf("[main_loop] server start success at port:%d!\n", LISTNE_PORT);
	while(g_run_server == WORK_STATE_RUN)
	{
		//使用epoll來監控所有註冊進來的socket，該步驟將以阻塞的方式用epoll_wait等待就緒的描述符，當一直沒有描述符就緒時，最多將等待EPOLL_WAIT_INTERVAL毫秒之後，也會返回；
		fd_ready_num = epoll_wait(g_fd_epoll, epoll_events, MAX_EPOLL_EVENTS, EPOLL_WAIT_INTERVAL);
		//epoll_wait返回時說明有就緒的socket或者等待的超時時間到了
		int i = 0;
		for(i = 0; i < fd_ready_num; i++)
		{
			if(epoll_events[i].data.fd == g_fd_listen_sock)
			{//說明當前的描述符是一個監聽socket
				if(handle_listen_socket() == RES_FAIL)
				{
					printf("[main_loop] handle listen socket faill!\n");
				}
				continue;
			}
			//以下步驟將處理業務socket
			if(handle_business_socket(epoll_events[i].data.fd) == RES_FAIL)
			{
				printf("[main_loop] handle business socket:%s faill!\n", epoll_events[i].data.fd);
			}
		}
	}
}

//處理就緒的監聽socket,接收新的連線進來，併為之產生一個業務socket
int handle_listen_socket()
{
	int new_sock = INVALID_SOCKET;
	new_sock = accept(g_fd_listen_sock, NULL, 0);
	if(new_sock == INVALID_SOCKET)
	{
		printf("[handle_listen_socket] accept new socket faill!\n");
		return RES_FAIL;
	}
		
	//設定監聽socket的狀態為非阻塞
	int opt = 1;
	opt = fcntl(new_sock, F_GETFL, 0);
	if(opt == -1 || fcntl(new_sock, F_SETFL, opt | O_NONBLOCK) == -1)
	{
		printf("[handle_listen_socket] set socket state: O_NONBLOCK fail!\n");
		close(new_sock);
		return RES_FAIL;
	}
	
	//註冊監聽socket到epoll
	if(reg_socket(new_sock) == RES_FAIL)
	{
		printf("[handle_listen_socket] reg_socket:%d fail!\n", new_sock);
		return RES_FAIL;
	}
	printf("[handle_listen_socket] accept new socket:%d suc!\n", new_sock);
	return RES_SUC;
}

//處理就緒的業務socket
int handle_business_socket(int ready_socket)
{
	if(ready_socket == INVALID_SOCKET)
	{
		printf("[handle_business_socket] socket:%d is invalid!\n", ready_socket);
		return RES_FAIL;
	}
	char* read_buf = (char* )malloc(sizeof(char) * MAX_BUF_SIZE_READ);
	memset(read_buf, '\0', MAX_BUF_SIZE_READ);
	int read_len = read(ready_socket, read_buf, MAX_BUF_SIZE_READ);
	if(read_len > 0)
	{
		printf("[handle_business_socket] recv msg from socket:%d, content:%s\n", ready_socket, read_buf);
		if(write(ready_socket, read_buf, read_len) != read_len)
		{
			printf("[handle_business_socket] write msg into socket:%d fail! content:[%s]!\n", ready_socket, read_buf);
		}
	}
	free(read_buf);
}
 

[[email protected] echoserver]# gcc echo_server.c -o echo_server
[[email protected] echoserver]# ./echo_server 
[main] will start test server!
[init_listen_socket] will init listen socket!
[init_listen_socket] init listen socket suc!
[main_loop] server start success at port:3557!