linux下socket采用select编程Demo

先来一个基本能使用的版本：
server端代码：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>
 
const int MYPORT = 1240;
const int BACKLOG = 5;
const int BUF_SIZE = 1024;
 
using namespace std;
 
int main()
{
    int sock_fd,new_fd;
     
    struct sockaddr_in server_addr,client_addr;
    char buf[BUF_SIZE];
     
    if((sock_fd = socket(AF_INET,SOCK_STREAM,0)) == -1)
    {
        perror("socket");
        exit(1);
    }
     
     
    int yes = 1;//yes = 1;(即TRUE)
     
    if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &yes,sizeof(yes)) == -1)
    {
        perror("setsockopt");
        exit(1);
    }
     
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(MYPORT);
    server_addr.sin_addr.s_addr = INADDR_ANY;
    memset(server_addr.sin_zero,'0',sizeof(server_addr.sin_zero));
     
    if (bind(sock_fd, (struct sockaddr * )&server_addr, sizeof(server_addr)) == -1)
    {
        perror("bind");
        exit(1);
    }
     
    if (listen(sock_fd, BACKLOG) == -1)
    {
        perror("listen");
        exit(1);
    }
     
    fd_set fdsr;
    int maxsock;
    int i;
    struct timeval tv;
    int fd_A[BACKLOG];//fd
    int con_amount = 0;//
    int ret;
     
    maxsock = sock_fd;
    //int sin_size = sizeof(client_addr);//int len ;  wrong
    socklen_t sin_size = sizeof(client_addr);
     
    while (1)
    {
        //select函数会清空它所检测的socket描述符集合，导致每次调用select()之前都必须把socket描述符重新加入到待检测的集合中
        FD_ZERO(&fdsr);
        FD_SET(sock_fd, &fdsr);
         
        tv.tv_sec = 30;//每一次查询  套接字是否就绪的时间
        tv.tv_usec = 0;
        //for(i = 0;i<BACKLOG;i++) //BACKLOG --段错误 吐核
        for (i = 0; i < con_amount; i++)
        {
            if (fd_A[i] != 0)
                FD_SET(fd_A[i],&fdsr);
        }
         
        ret = select(maxsock + 1, &fdsr, NULL, NULL, &tv);//
        if (ret < 0)
        {
            perror("select");
            break;
        }
        else if (ret == 0)// 没有准备就绪的文件描述符  就进入下一次循环
        {
            cout << "timeout" << endl;
            continue;
        }
        //有准备就绪的套接字，则分别检查哪些  连接套接字 和 监听套接字 已经就绪  分别进行数据读取和建立连接
        for (i = 0; i < con_amount; i++)
        {
            if (FD_ISSET(fd_A[i], &fdsr))
            {
                ret = recv(fd_A[i], buf, BUF_SIZE - 1, 0);
                if (ret > 0)
                {
                    buf[ret] = '\0';
                    cout << "msg from " << fd_A[i] << "is: " << buf << endl;
                }
                else//------------------client close 
                {
                    cout << "client " << fd_A[i] << " is closed!" << endl;
                    close(fd_A[i]);
                    //FD_CLR(fd_A[i],&fdsr);
                    fd_A[i] = 0;
                    /*
                    perro("recv");
                    exit(1);
                    */
                }
             
            }
        }//end of "for" 
        // 以下说明异常有来自客户端的连接请求 
        if (FD_ISSET(sock_fd, &fdsr))
        {
            //if((new_fd = accept(sock_fd,(struct sockaddr *)&client_addr,sizeof(client_addr)) == -1)//error
            if ((new_fd = accept(sock_fd, (struct sockaddr *)&client_addr, &sin_size)) == -1)
            {
                perror("accept");
                exit(1);
            }
             
            //
            if (con_amount < BACKLOG)
            {
                fd_A[con_amount++] = new_fd;
                //FD_SET(new_fd,&fdsr); // no need , fd_A[i] != 0 will be added to fdsr in the begin of each loop
                cout << "new client:" <<inet_ntoa(client_addr.sin_addr) << ":" << ntohs(client_addr.sin_port) << endl;
                 
                //update maxsock ------
                if (new_fd > maxsock)
                    maxsock = new_fd;
            }
            else
            {//send msg 
                cout << "Max connections arrived!" << endl;
                send(new_fd, "Bye", 4, 0);
                close(new_fd);
                //break;//
            }
     
        }
    }//end of "while(1)"
 
    /*
    close(sock_fd);
    for(i = 0;i<con_amount;i++)
    {
    if(fd_A[i] != 0)
    close(fd_A[i]);
    }
    */
      
    return 0;
}

客户端代码：

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
/* 服务器程序监听的端口号 */
//#define PORT 1240
/* 我们一次所能够接收的最大字节数 */
#define MAXDATASIZE 100

int main(int argc, char *argv[])
{
    /* 套接字描述符 */
    int sockfd, numbytes;
    char buf[MAXDATASIZE];
    int port;
    struct hostent *he;
    /* 连接者的主机信息 */
    struct sockaddr_in their_addr;
    /* 检查参数信息 */
    if (argc != 3)
    {
        /* 如果没有参数，则给出使用方法后退出 */
        fprintf(stderr,"usage: server_host server_port\n");
        exit(1);
    }
    /* 取得主机信息 */
    if ((he = gethostbyname(argv[1])) == NULL)
    {
        /* 如果 gethostbyname()发生错误，则显示错误信息并退出 */
        herror("gethostbyname");
        exit(1);
    }
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) 
    {
        /* 如果 socket()调用出现错误则显示错误信息并退出 */
        perror("socket");
        exit(1);
    }
     
    port = atoi(argv[2]);//
     
    /* 主机字节顺序 */
    their_addr.sin_family = AF_INET;
    /* 网络字节顺序，短整型 */
    their_addr.sin_port = htons(port);
    their_addr.sin_addr = *((struct in_addr *)he->h_addr);
    /* 将结构剩下的部分清零*/
    bzero(&(their_addr.sin_zero), 8);
    if (connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1)
    {
        /* 如果 connect()建立连接错误，则显示出错误信息，退出 */
        perror("connect");
        exit(1);
    }
     
    /*
    if((numbytes=recv(sockfd, buf, MAXDATASIZE, 0)) == -1)
    {
        // 如果接收数据错误，则显示错误信息并退出 
        perror("recv");
        exit(1);
    }
    buf[numbytes] = '\0';
    printf("Received: %s",buf);
    bzero(buf,100);*/
     
    strcpy(buf,"Received your message!\n");
    send(sockfd, buf, strlen(buf), 0);
    /*
    sleep(100);
    strcpy(buf,"Received your message2!\n");
    send(sockfd,buf,strlen(buf),0);
    */
     
    //close(sockfd);
    return 0;
}

以上内容引自：https://blog.csdn.net/hishentan/article/details/38308053
下面是完善一些的版本：

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

#define MYPORT 1234    // the port users will be connecting to
#define BACKLOG 5     // how many pending connections queue will hold
#define BUF_SIZE 200

int fd_A[BACKLOG];    // accepted connection fd
int conn_amount;    // current connection amount

void showclient()
{
    int i;
    printf("client amount: %d\n", conn_amount);
    for (i = 0; i < BACKLOG; i++) {
        printf("[%d]:%d  ", i, fd_A[i]);
    }
    printf("\n\n");
}

int main(void)
{
    int sock_fd, new_fd;  // listen on sock_fd, new connection on new_fd
    struct sockaddr_in server_addr;    // server address information
    struct sockaddr_in client_addr; // connector's address information

    socklen_t sin_size;
    int yes = 1;
    char buf[BUF_SIZE];
    int ret;
    int i;

    if ((sock_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        perror("socket");
        exit(1);
    }

    if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
        perror("setsockopt");
        exit(1);
    }
  
    server_addr.sin_family = AF_INET;         // host byte order
    server_addr.sin_port = htons(MYPORT);     // short, network byte order
    server_addr.sin_addr.s_addr = INADDR_ANY; // automatically fill with my IP
    memset(server_addr.sin_zero, '\0', sizeof(server_addr.sin_zero));

    if (bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind");
        exit(1);
    }

    if (listen(sock_fd, BACKLOG) == -1) {
        perror("listen");
        exit(1);
    }

    printf("listen port %d\n", MYPORT);
    fd_set fdsr;
    int maxsock;
    struct timeval tv;
    conn_amount = 0;
    sin_size = sizeof(client_addr);
    maxsock = sock_fd;
    while (1) {
        // initialize file descriptor set
        FD_ZERO(&fdsr);
        FD_SET(sock_fd, &fdsr);

        // timeout setting
        tv.tv_sec = 30;
        tv.tv_usec = 0;

        // add active connection to fd set
        for (i = 0; i < BACKLOG; i++) {
            if (fd_A[i] != 0) {
                FD_SET(fd_A[i], &fdsr);
            }
        }

        ret = select(maxsock + 1, &fdsr, NULL, NULL, &tv);

        if (ret < 0) {
            perror("select");
            break;
        } else if (ret == 0) {
            printf("timeout\n");
            continue;
        }

        // check every fd in the set
        for (i = 0; i < conn_amount; i++) {
            if (FD_ISSET(fd_A[i], &fdsr)) {
                ret = recv(fd_A[i], buf, sizeof(buf), 0);
                if (ret <= 0) {        // client close
                    printf("client[%d] close\n", i);
                    close(fd_A[i]);
                    FD_CLR(fd_A[i], &fdsr);
                    fd_A[i] = 0;
                } else {        // receive data
                    if (ret < BUF_SIZE)
                        memset(&buf[ret], '\0', 1);
                    printf("client[%d] send:%s\n", i, buf);
                }
            }
        }

        // check whether a new connection comes
        if (FD_ISSET(sock_fd, &fdsr)) {
            new_fd = accept(sock_fd, (struct sockaddr *)&client_addr, &sin_size);
            if (new_fd <= 0) {
                perror("accept");
                continue;
            }

            // add to fd queue
            if (conn_amount < BACKLOG) {
                fd_A[conn_amount++] = new_fd;
                printf("new connection client[%d] %s:%d\n", conn_amount,
                        inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

                if (new_fd > maxsock)
                    maxsock = new_fd;
            } else {
                printf("max connections arrive, exit\n");
                send(new_fd, "bye", 4, 0);
                close(new_fd);
                break;
            }
        }

        showclient();

    }



    // close other connections
    for (i = 0; i < BACKLOG; i++) {
        if (fd_A[i] != 0) {
            close(fd_A[i]);
        }
    }

    exit(0);
}

继续优化后的版本：

void run()
{
    char msg[BUF_SIZE];
    int Listen_socket,ret,on;
    struct sockaddr_in local_addr;
    struct sockaddr_in client_addr;
    int i;
    fd_set fdsr; //文件描述符集的定义
    socklen_t addr_size;
    addr_size = sizeof(struct sockaddr_in);

    int conn_amount = 0; //当前最大活跃连接数
    int new_fd;
    struct timeval tv;

    //建立socket套接字
    if( (Listen_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1)
    {
        emit err_msg_signal("failed create socket");
    }

    //bind API 函数将允许地址的立即重用
    on = 1;
    ret = setsockopt( Listen_socket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on) );

    int nNetTimeout=2000;//2秒
    //设置发送时限
    setsockopt(Listen_socket,SOL_SOCKET,SO_SNDTIMEO,(char *)&nNetTimeout,sizeof(int) );
    //设置接收时限
    setsockopt(Listen_socket,SOL_SOCKET,SO_RCVTIMEO,(char *)&nNetTimeout,sizeof(int));

    //设置本机服务类型
    local_addr.sin_family = AF_INET;
    local_addr.sin_port = htons(port);
    local_addr.sin_addr.s_addr = INADDR_ANY;

    //while(flag_port == 0)
    //绑定本机IP和端口号
    if(bind(Listen_socket, (struct sockaddr*)&local_addr, sizeof(struct sockaddr)) == -1)
    {
        emit err_msg_signal("failed bind");
    }

    //监听客户端连接
    if(listen(Listen_socket, 8) == -1)
    {
        emit err_msg_signal("failed listen");
    }


    QTime current_time;
    current_time = QTime::currentTime();
    int flag_minutechange = 0,lastminute = current_time.currentTime().minute();
    int maxsock = Listen_socket;
    /***************************************
    以下为并发连接处理，系统关键部分
    ***************************************/

    while (1)
    {

        if( current_time.currentTime().minute() != lastminute) //每次循环开始都读取系统时间，与上次分钟数比较，为以下超时判断提供依据
        {
            lastminute = current_time.currentTime().minute();
            flag_minutechange = 1;
        }

        FD_ZERO(&fdsr); //每次进入循环都重建描述符集
        FD_SET(Listen_socket, &fdsr);
        for (i = 0; i < MAXCLIENT; i++) //将存在的套接字加入描述符集
        {
            if (fd[i] != 0)
            {
                FD_SET(fd[i], &fdsr);
                if (flag_minutechange == 1)
                {
                    con_time[i]--;
                    if (con_time[i] <= 0)
                    {
                        close(fd[i]);
                        FD_CLR(fd[i], &fdsr);
                        fd[i] = 0;
                        conn_amount--;
                    }
                }

            }
        }
        flag_minutechange = 0;
        tv.tv_sec = 1;
        tv.tv_usec = 0;
        ret = select(maxsock + 1, &fdsr, NULL, NULL,&tv); //关键的select()函数，用来探测各套接字的异常
        //如果在文件描述符集中有连接请求或发送请求，会作相应处理，
        //从而成功的解决了单线程情况下阻塞进程的情况，实现多用户连接与通信

        if (ret < 0) //<0表示探测失败
        {
            qDebug()<<"failed select\n";
            break;
        }
        else if (ret == 0) //=0表示超时，下一轮循环
        {
            //qDebug()<<"timeout\n";
            continue;
        }

        // 如果select发现有异常，循环判断各活跃连接是否有数据到来
        for (i = 0; i < conn_amount; i++)
        {
            if (FD_ISSET(fd[i], &fdsr))
            {
                ret = recv(fd[i], msg, BUF_SIZE, 0);
                if (ret <= 0) // recv<=0,表明客户端关闭连接，服务器也关闭相应连接，并把连接套接子从文件描述符集中清除
                {
                    qDebug("client[%d] close\n", i);
                    close(fd[i]);
                    FD_CLR(fd[i], &fdsr);
                    fd[i] = 0;
                    conn_amount--;
                }
                else //否则表明客户端有数据发送过来，作相应接受处理
                {
                    con_time[i] = MAX_IDLECONNCTIME; //重新写入fd[i]的超时数，再此之后如果MAX_IDLECONNCTIME分钟内此连接无反应，服务器会关闭该连接
                    if (ret < BUF_SIZE)
                        emit err_msg_signal("client ip: " + QString::fromLatin1(inet_ntoa(client_addr.sin_addr)) +
                        " port: " + QString::number(ntohs(client_addr.sin_port))+" coming data");
                    qDebug("client[%d] send:%s\n", i, msg);
                    msg[ret] = '\0';
                    emit recv_msg_signal(QString::fromLatin1(msg),fd[i]);
                    //send(fd[i],msg,ret,0);
                }
            }
        }
        // 以下说明异常有来自客户端的连接请求
        if (FD_ISSET(Listen_socket, &fdsr))
        {
            new_fd = accept(Listen_socket, (struct sockaddr *)&client_addr, &addr_size);
            if (new_fd <= 0)
            {
                qDebug("failed accept");
                continue;
            }

            // 判断活跃连接数时候是否小于最大连接数，如果是，添加新连接到文件描述符集中
            if (conn_amount < MAXCLIENT)
            {
                for(i = 0;i < MAXCLIENT;i++)
                {
                    if(fd[i] == 0)
                    {

                        fd[i] = new_fd;
                        con_time[i] = MAX_IDLECONNCTIME; //每次新建立连接，设置该连接的超时数，如果此连接此后MAX_IDLECONNCTIME分钟内无反应，关闭该连接
                        break;
                    }

                }
                conn_amount++;
                //fd[conn_amount++] = new_fd;
                qDebug("new connection client[%d] %s:%d\n", conn_amount,
                inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
                emit err_msg_signal("client ip: " + QString::fromLatin1(inet_ntoa(client_addr.sin_addr)) +
                " port: " + QString::number(ntohs(client_addr.sin_port)));
                if (new_fd > maxsock)
                    maxsock = new_fd;
            }
            else
            {
                qDebug("MAXCLIENT arrive, exit\n");
                send(new_fd, "over MAXCLIENT\n", 25, 0);
                close(new_fd);
                continue;
            }
        }

    }
}

以上内容引自：
https://www.cnblogs.com/faraway/archive/2009/03/06/1404449.html