LINUX网络编程（fork、select、epoll三种模式）

最新推荐文章于 2020-08-18 11:25:00 发布
最新推荐文章于 2020-08-18 11:25:00 发布
阅读量562 收藏 1
点赞数
分类专栏： C/C++ 文章标签： linux 编程 网络 struct signal socket

使用了fork、select、epoll三种socket服务器工作模式，客户端向服务端发送任何数据，服务端再原样返回给客户端，本文的目的只为加深偶的记忆。
fork:每accept到一个socket之后，开启一个子进程来负责收发处理工作。
select:监控文件描述符事件
epoll:监控文件描述符事件，比select性能优异，可最大支持2W个连接，有死连接时处理能力高
文末附注了SOCKET的一些常见错误标识

-------------------------- fork.cpp --------------------------
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h> 
#include <errno.h> 
#include <string>
#include <stdexcept>
#include <iostream>
#include <sys/ioctl.h>

#define SERVER_PORT 8888 
#define BUFFER_LENGTH 1024

using namespace std;

class SocketException : public std::logic_error
{
public:
SocketException(const std::string& what) throw ()
: std::logic_error(what) {};
};

int SocketRead(int& fd, std::string& strValue)
{
// 每次只读取一个字节
int nRead = 1;

auto_ptr<char> apBuf(new char[nRead]);
int r = read(fd, apBuf.get(), nRead) ;
if (0 < r)
{
   strValue.assign(apBuf.get(), r);
}

return r;
}

int SocketWrite(int& fd, const char* pBuf, int nBufLen)
{
int nWrite = 0;
int nError = -1;

/*
SIGPIPE：sent to a process when it attempts to write to a pipe without a process connected to the other end. The symbolic constant for SIGPIPE is defined in the header file signal.h. Symbolic signal names are used because signal numbers can vary across platforms.
*/
// SIG_IGN:忽略信号
sighandler_t sh = signal(SIGPIPE, SIG_IGN);

while (nWrite < nBufLen)
{
   nError = send(fd, pBuf + nWrite, nBufLen - nWrite, 0); 
   if (0 > nError)
   {
    perror(strerror(errno));

    // 见文末
    if (nError == EINTR) continue;

    if (nError == EPIPE) 
    {
     close(fd); 
    }
    // 恢复信号
    signal(SIGPIPE, sh);
    throw SocketException(string("SocketWrite error, ") + strerror(errno));
   }
   else if (0 == nError)
   {
    signal(SIGPIPE, sh);
    throw SocketException(string("SocketWrite error, ") + strerror(errno));
   }
   else
   {
    nWrite += nError;
   }
}

signal(SIGPIPE, sh);
return nError;
}

void SetOption(int s, int level, int optname, const void *optval, socklen_t optlen)
{
if (setsockopt(s, level, optname, optval, optlen) < 0)
{
   perror(strerror(errno));
}
}

int main(int argc, char*argv[])
{
int fdServer = -1;
int   fdClient = -1;
int   nStatus = -1;
pid_t pid = 0;

int nSockAddrLen = sizeof(struct sockaddr_in);
struct sockaddr_in addrServer;
struct sockaddr_in addrSocket;
bzero(&addrServer, sizeof(struct sockaddr_in)); 
bzero(&addrSocket, sizeof(struct sockaddr_in));

if(-1 == (fdServer = socket(AF_INET, SOCK_STREAM, 0)))
{
   perror(strerror(errno));
   exit(-1);
}

int nReuseAddr = 1;
SetOption(fdServer, SOL_SOCKET, SO_REUSEADDR, &nReuseAddr, sizeof(int));

addrServer.sin_family = AF_INET;
addrServer.sin_port = htons(SERVER_PORT);
addrServer.sin_addr.s_addr = INADDR_ANY;

if (-1 == bind(fdServer, (struct sockaddr *)&addrServer, sizeof(struct sockaddr))) 
{ 
   perror(strerror(errno));
   exit(-1);
}

if (-1 == listen(fdServer, 128))
{
   perror(strerror(errno));
   exit(-1);
}

while (true)
{
   if ((fdClient = accept(fdServer, (struct sockaddr *)&addrSocket, (socklen_t*)&nSockAddrLen)) < 0)
   {
    perror(strerror(errno));
    exit(-1);
   }

   printf("client address:%s/t port:%d/r/n", inet_ntoa(addrSocket.sin_addr), ntohs(addrSocket.sin_port));
   if ((pid = fork()) < 0)
   {
    perror(strerror(errno));
    exit(-1);
   }
   else if (0 == pid) /* clild */
   {
    while (true)
    {
     try
     {
      std::string strValue;
      if(0 < SocketRead(fdClient, strValue))
      {
       SocketWrite(fdClient, strValue.c_str(), strValue.length());
      }
      else
      {
       close(fdClient); 
      }
      // 要有延时，不然CPU使用率很高
      usleep(10);
     }
     catch(const SocketException& e)
     {
      cerr << e.what() << endl; 
      close(fdClient);
      break;
     }
    }
   }
   else /* parent */
   {
    close(fdClient); 
   }
}

return 0;
}

-------------------------- select.cpp --------------------------
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdlib.h>

#include <iostream>
#include <vector>
#include <arpa/inet.h>

#define SERVER_PORT 8888 
#define NUM_MON   5 
#define NUM_BUFFER 1024

#include <errno.h> 
using namespace std;

void SetOption(int s, int level, int optname, const void *optval, socklen_t optlen)
{
if (setsockopt(s, level, optname, optval, optlen) < 0)
{
   perror(strerror(errno));
}
}

int main(int argc, char*argv[])
{
int fdServer = -1;
int fdClient = -1;
int fdMax = -1;
int nRead = 0;
char buf[NUM_BUFFER];

int nSockAddrLen = sizeof(struct sockaddr_in);
struct sockaddr_in addrServer;
struct sockaddr_in addrSocket;
bzero(&addrServer, sizeof(struct sockaddr_in)); 
bzero(&addrSocket, sizeof(struct sockaddr_in));

int fdBuf[NUM_MON];
memset(fdBuf, -1, sizeof(fdBuf));

// 被监控的描述符集合
fd_set fsMon;
// 事件的描述符集合
fd_set fsRead;
FD_ZERO(&fsMon);
FD_ZERO(&fsRead);

if(-1 == (fdServer = socket(AF_INET, SOCK_STREAM, 0))) 
{
   perror(strerror(errno));
   exit(-1);
}

int nReuseAddr = 1;
SetOption(fdServer, SOL_SOCKET, SO_REUSEADDR, &nReuseAddr, sizeof(int));

addrServer.sin_family = AF_INET;
addrServer.sin_port = htons(SERVER_PORT);
addrServer.sin_addr.s_addr = INADDR_ANY;

if (-1 == bind(fdServer, (struct sockaddr *)&addrServer, sizeof(struct sockaddr))) 
{ 
   perror(strerror(errno));
   exit(-1);
}

if (-1 == listen(fdServer, 128))
{
   perror(strerror(errno));
   exit(-1);
}

// 服务端是被监控对象之一
FD_SET(fdServer, &fsMon);
fdMax = fdServer;

while (true)
{
   fsRead = fsMon;
   switch(select(fdMax + 1, &fsRead, NULL, NULL, NULL))
   {
    case -1:
     perror(strerror(errno));
     exit(-1);
    case 0:
     perror("timeout");
     continue;
    default:
     break;
   }

   // 是否为fdServer的可读事件
   if (FD_ISSET(fdServer, &fsRead)) 
   {
    if (0 > (fdClient = accept(fdServer, (struct sockaddr *)&addrSocket, (socklen_t*)&nSockAddrLen)))
    {
     perror(strerror(errno));
     exit(-1);
    }

    // socket加入fdBuf, fdBuf中是保存的所有socket的集合
    for (int i = 0; i < NUM_MON; ++i)
    {
     if(-1 == fdBuf[i]) 
     { 
      fdBuf[i] = fdClient;
      break;
     } 
    } 
    // 把socket加入监控集合
    FD_SET(fdClient, &fsMon) ;
    fdMax = max(fdMax, fdClient);
   
    continue; 
   }

   for (int i = 0; i < NUM_MON; ++i) 
   {
    if (-1 == fdBuf[i]) continue;
    if (!FD_ISSET(fdBuf[i], &fsMon)) continue;

    // 缓冲区中，是否有数据可读
    ioctl(fdBuf[i], FIONREAD, &nRead);
    if (0 >= nRead) 
    {
     // 非可读
     FD_CLR(fdBuf[i], &fsMon); 
     continue; 
    }
   
    read(fdBuf[i], buf, nRead) ;
    write(fdBuf[i], buf, nRead) ;
   }
} 
}

-------------------------- epoll.cpp --------------------------
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <stdexcept>
#include <fcntl.h>

#include <iostream>

using namespace std;

#define SERVER_PORT 8888

class SocketException : public std::logic_error
{
public:
SocketException(const std::string& what) throw ()
: std::logic_error(what) {};
};

int SocketRead(int& fd, std::string& strValue)
{
// 缓冲区中，是否有数据可读
int nRead = 0;
ioctl(fd, FIONREAD, &nRead);

if (nRead > 0) 
{
   auto_ptr<char> apBuf(new char[nRead]);
   read(fd, apBuf.get(), nRead) ;
   strValue.assign(apBuf.get(), nRead);
}
else
{
   cout << nRead << endl; 
   close(fd);
}
return nRead;
}

int SocketWrite(int& fd, const char* pBuf, int nBufLen)
{
// 参见fork.cpp
int nWrite = 0;
int nError = -1;

sighandler_t sh = signal(SIGPIPE, SIG_IGN);

while (nWrite < nBufLen)
{
   nError = send(fd, pBuf + nWrite, nBufLen - nWrite, 0); 
   if (0 > nError)
   {
    perror(strerror(errno));

    if (nError == EINTR) continue;

    if (nError == EPIPE) 
    {
     close(fd); 
    }

    signal(SIGPIPE, sh);
    throw SocketException(string("SocketWrite error, ") + strerror(errno));
   }
   else if (0 == nError)
   {
    // out pipe is closed
    signal(SIGPIPE, sh);
    throw SocketException(string("SocketWrite error, ") + strerror(errno));
   }
   else
   {
    nWrite += nError;
   }
}

signal(SIGPIPE, sh);
return nError;
}

void SetOption(int s, int level, int optname, const void *optval, socklen_t optlen)
{
if (setsockopt(s, level, optname, optval, optlen) < 0)
{
   perror(strerror(errno));
}
}

// 设置socket为非阻塞式
void SetNonBlocking(int fd)
{
int flags = fcntl(fd, F_GETFL);
flags |= O_NONBLOCK;
fcntl(fd, F_SETFL, flags); 
}

int main(int argc, char*argv[])
{
int nfds, epfd, fdServer, fdClient;
int maxevents = 1000;
struct epoll_event ev, *events;

epfd = epoll_create(128);

int nSockAddrLen = sizeof(struct sockaddr_in);
struct sockaddr_in addrServer;
struct sockaddr_in addrSocket;
bzero(&addrServer, sizeof(struct sockaddr_in)); 
bzero(&addrSocket, sizeof(struct sockaddr_in));

if(-1 == (fdServer = socket(AF_INET, SOCK_STREAM, 0))) 
{
   perror(strerror(errno));
   exit(-1);
}

int nReuseAddr = 1;
SetOption(fdServer, SOL_SOCKET, SO_REUSEADDR, &nReuseAddr, sizeof(int));

addrServer.sin_family = AF_INET;
addrServer.sin_port = htons(SERVER_PORT);
addrServer.sin_addr.s_addr = INADDR_ANY;

if (-1 == bind(fdServer, (struct sockaddr *)&addrServer, sizeof(struct sockaddr))) 
{ 
   perror(strerror(errno));
   exit(-1);
}

// 监控对象fdServer
ev.data.fd = fdServer;
// 事件：边沿触发，IN事件
ev.events = EPOLLIN | EPOLLET;

if (epoll_ctl(epfd, EPOLL_CTL_ADD, fdServer, &ev) < 0)
{
   perror(strerror(errno));
   exit(-1);
}
  
if (-1 == listen(fdServer, 64))
{
   perror(strerror(errno));
   exit(-1);
}

while(true)
{
   nfds = epoll_wait(epfd, events, maxevents, -1);
   if (0 > nfds)
   {
    cerr << "epoll_wait:" << strerror(errno) << endl;
   }

   for(int n = 0; n < nfds; ++n) 
   {
    // 事件主体为服务端？
    if(events[n].data.fd == fdServer) 
    {
     fdClient = accept(fdServer, (struct sockaddr *)&addrSocket, (socklen_t*)&nSockAddrLen);
     if(0 > fdClient)
     {
      perror(strerror(errno)); 
      continue;
     } 
    
     // 非阻塞式，咱们目标是，快点处理完来下一轮
     SetNonBlocking(fdClient);

     // socket加入监控列表
     ev.events = EPOLLIN | EPOLLET; 
     ev.data.fd = fdClient; 
     if (epoll_ctl(epfd, EPOLL_CTL_ADD, fdClient, &ev) < 0) 
     { 
      cerr << "epoll set insertion error: fd=" << fdClient << endl;
      return -1; 
     } 
    } 
    else 
    {
     int nError = 0;
     char buf[1024];

     while(true)
     {
      nError = read(events[n].data.fd, buf, sizeof(buf)); 
      cout << " read bytes:" << nError << endl;
      if (-1 == nError)
      {
       perror(strerror(errno));
       // 这些见文末说明
       if (nError == EINTR) continue;

       if (nError == EPIPE) 
       {
        // 从监控列表中移除
        epoll_ctl(epfd, EPOLL_CTL_DEL, events[n].data.fd, &ev);
        close(events[n].data.fd); 
        break;
       }      
       break;
      }
      else if (0 == nError)
      {
       // 从监控列表中移除
       epoll_ctl(epfd, EPOLL_CTL_DEL, events[n].data.fd, &ev);
       close(events[n].data.fd); 
       break; 
      }

      SocketWrite(events[n].data.fd, buf, nError);
     }
    }
   }
}

return 0;
}

小使
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux 编程之进程fork()详解及实例
01-10
Linux fork()详解： 在开始之前，我们先来了解一些基本的概念: 1. 程序， 没有在运行的可执行文件   进程, 运行中的程序  2. 进程调度的方法：   按时间片轮转   先来先服务   短时间优先   按优先...
select函数——单进程监视多个文件描述符
Like Linux
03-25 2673
程序期待着来自两个源端的输入，但不知道哪个源端的输入先到。如果程序试图从源端A读入，而实际上只有来自源端B的输入可用，那么程序就会发生阻塞，怎么办？ 保持阻塞状态，直到一组条件中至少有一个条件为真为止，这种方法称为  或同步（OR synchronization）。 1.监视多个文件描述符的一种方法是为每个描述符分别使用一个独立的进程 下面程序有两个命令行参数，即两个要监视的文件的名字，
Select()系统调用及文件描述符集fd_set的应用
重剑无锋
02-22 1974
【 原文由 张 卿 所发表 】  在网络程序中，一个进程同时处理多个文件描述符是很常见的情况。select()系统调用可以使进程检测同时等待的多个I/O设备，当没有设备准备好时，select()阻塞，其中任一设备准备好时，select()就返回。 select()的调用形式为： #include #include int select(int maxfd, fd_set *readfds, f
fd_set用法
韦编二绝
01-29 1138
    select()机制中提供一fd_set的数据结构，实际上是一long类型的数组，每一个数组元素都能与一打开的文件句柄(不管是socket句柄，还是其他文件或命名管道或设备句柄)建立联系，建立联系的工作由程序员完成，当调用select()时，由内核根据IO状态修改fe_set的内容，由此来通知执行了select()的进程哪一socket或文件可读。    多端口复用函数select在调
epoll与fork
weixin_30432579的博客
09-28 358
使用epoll时，如果在调用epoll_create之后，调用了fork创建子进程，那么父子进程虽然有各自epoll实例的副本，但是在内核中，它们引用的是同一个实例。子进程向自己的epoll实例添加、修改和删除文件描述符时，是可以影响到父进程的epoll_wait的。所以会发生意想不到的问题，分情况看一下： 1：向子进程中的epoll实例添加描述符，描述...
关于 fork, select, poll, epoll
Xuesengxinyi的博客
03-12 409
这一篇讲的非常详细,也非常透彻,有图示. https://blog.csdn.net/qq_36359022/article/details/81355897### 下面这几篇对于fork, select, poll, epoll的对比介绍的比较好,对比着学,才更容易理解 https://github.com/Mondego/rcat/wiki/fork,-select,-poll,-epoll,...
Fork()函数与Linux中的多线程编程
01-20
在Linux系统中创建进程有两种方式：一是由操作系统创建，二是由父进程创建进程（通常为子进程）。 　系统调用函数fork()是创建一个新进程的方式，当然vfork()也可以创建进程，但是实际上其还是调用了fork()函数。...
3_tcp_concurrent_fork.zip_linux 编程
09-23
基于TCP协议的父子进程并发服务器的通讯
浅谈Linux环境下并发编程中C语言fork()函数的使用
01-20
由fork创建的新进程被称为子进程（child process）。fork函数被调用一次，但返回两次。子进程的返回值是0，而父进程的返回值则是...fork有下面两种用法： （1）一个父进程希望复制自己，使父、子进程同时执行不同的代码
linux 多进程编程 fork
07-03
linux 多进程编程 forklinux 多进程编程 forklinux 多进程编程 forklinux 多进程编程 forklinux 多进程编程 forklinux 多进程编程 forklinux 多进程编程 forklinux 多进程编程 forklinux 多进程编程 forklinux 多...
Linux网络编程(四)——epoll+多线程实现简单的聊天（linux 服务器端 windows客户端）
06-13
Linux网络编程(四)——epoll+多线程实现简单的聊天（linux 服务器端 windows客户端）
Linux网络编程之聊天程序（TCP协议之fork进程）
Herok
04-14 6631
实现了服务端和客户端之间的相互聊天，不收顺序限制，可以同时进行。 服务端： server.c #include #include #include #include #include #include #include #include #include #include #define MAXBUF 1024 int main(i
linux网络编程-select、poll、epoll
littleflypig的博客
11-16 468
select、poll、epoll是linux下I/O多路转接的三种方式。其中epoll在高并发的服务器中用的比较多。 1. select 函数定义： int select(int nfds,fd_set* readfds,fd_set* writefds,fd_set* exceptfds,strcut timeval* timeout) 函数功能是将要监控的文件描述符集fd_set传入内核，...
linux网络编程系列-select和epoll的区别
weixin_30563319的博客
05-09 103
select和epoll属于I/O多路复用模型，用于持续监听多个socket，获取其IO事件。 select（轮询） 该模型轮询各socket，不管socket是否活跃，随着socket数的增加，性能逐渐下降。 #include <sys/select.h> #include <sys/time.h> int select (int maxfdpl...
epoll 三个方法 两种工作模式
x_i_y_u_e的专栏
08-12 4096
epoll是在2.6内核中提出的，是之前的select和poll的增强版本。相对于select和poll来说，epoll更加灵活，没有描述符限制。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需一次。一 epoll操作过程 epoll操作过程需要三个接口，分别如下：int epoll_create(int si
GitLab的fork模式使用方法
热门推荐
Zephyr_Syn
08-18 1万+
先将源项目fork到自己的目录下，这个可以直接在控制台操作： fork之后，查看自己的工作目录，可以看到在本人目录下已经存在该项目。 本地直接clone自己目录下的项目进行开发与提交，若不知道git具体开发与操作步骤，请自行百度，这里就不赘言了。 同步源代码，clone下来的项目右键选择Settings->Remote，设置源项目路径并保存，也可以使用git命令设置Remote：git remote add task http://xxxx/xxxx/xxxxtask.git(add之后的..
关于 多进程epoll 与 “惊群”问题
05-18 6445
http://blog.163.com/pandalove@126/blog/static/9800324520122633515612/   【遇到问题】     手头原来有一个单进程的linux epoll服务器程序，近来希望将它改写成多进程版本，主要原因有： 在服务高峰期间 并发的 网络请求非常海量，目前的单进程版本的程序有点吃不消：单进程时只有一个循环先后处理epoll_w
进程编程 linux fork
最新发布
09-25
进程编程是一种应用在Unix/Linux系统中的编程方法，其中一个重要的概念就是fork（分叉）。 在Linux中，fork是一个系统调用，它创建一个新的进程。通过fork，父进程可以生成一个与自己完全相同的子进程。父进程和子...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值