c socket 單線程多使用者並發

使用select函數可以以非阻塞的方式和多個socket通訊。程式只是示範select函數的使用，功能非常簡單，即使某個串連關閉以後也不會修改當前串連數，串連數達到最大值後會終止程式。

1. 程式使用了一個數組fd_A，通訊開始後把需要通訊的多個socket描述符都放入此數組。

2. 首先產生一個叫sock_fd的socket描述符，用於監聽連接埠。

3. 將sock_fd和數組fd_A中不為0的描述符放入select將檢查的集合fdsr。

4. 處理fdsr中可以接收資料的串連。如果是sock_fd，表明有新串連加入，將新加入串連的socket描述符放置到fd_A。

#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);
}

樓主真是太厲害了，select用的真是巧妙！完全實現在單線程的情況下多使用者通訊，我運行過代碼，非常成功！不過經過我覺得樓主在accept函數裡面fd_A[conn_amount++] = new_fd;可以稍加改進，按照樓主的意圖，會出現當一個使用者不斷串連再斷開的情況下，當串連次數超過maxconnection的時候，就會退出，因此fd_A[i]沒有很好的利用,不能實現動態管理，我建議僅將conn_amount僅作為用戶端串連數，而不是有串連就增加，當accept成功的時候，就加1，當recv＝0的時候就減1；建議將fd_A[conn_amount++] = new_fd;這句程式改為
for(i = 0;i < MAXCLIENT;i++)
{
if(fd[i] == 0)
{
fd[i] = new_fd;
break;
}

}
conn_amount++;
這樣就可以重複利用fd[i]的空間；
另外在recv傳回值<=0的時候，加一句conn_amount++;
還有一點，超過最大串連數的時候break應該為continue，這樣會更人性化一點，用戶端太多關閉它的請求就行了，沒必要自毀，這樣整個系統就可以動態與用戶端實現串連，很感謝樓主的貢獻，使我少走了很多彎路，現在在樓主的基礎上，我基本上已經實現了多使用者訪問的伺服器端程式，而且還加上了資料庫，我覺得這個世界是這麼的美妙！  

一個多月沒碰了，不過當時聽說select有這麼大的作用，很興奮，當時要實現單線程多使用者，剛好select提供了這一切，由於整個項目有很多內容，還包括資料庫和QT介面部分，因此，裡面會有像qDebug、emit 這樣的函數或者關鍵字，不過這不影響閱讀，朋友們可以根據需要用printf等函數代替或者去掉，這裡只提供socket串連部分，下面的函數中可能有部分是宏定義，比如BUF_SIZE，MAXCLIENT等。該函數除了實現動態管理最大串連數外，還限制了一個串連的空閑連線時間（MAX_IDLECONNCTIME），各位如看到下面讀取系統時間這部分即為串連控制，目的就是為了，當一個使用者在一定時間內沒有串連請求，也沒有發送和接受資料，伺服器就可以關掉這個串連，這樣同時還有效制止了一些非常規的斷開方法，比如用戶端突然斷電，拔掉網線等（這個時候，服務端是檢測不到的用戶端已斷開）。
這些代碼，經過長時間測試，沒有出現問題，朋友們如果有什麼更簡潔高效的方法，一定要共用出來哦！

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;
}
}

}
}