Linux 网络select模型

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <netdb.h>
#include <pthread.h>


#define DEF_STD_ERROR (-1)
#define DEF_BIND_PORT (12455)


#ifndef TRUE
#define TRUE 1
#define FALSE 0
#define BOOL int
#endif


//set socket(TRUE:block, FALSE:no block)

void set_block(int sock,BOOL flag)
{
        int ret;
        if(flag == TRUE)
        {
                ret = fcntl(sock,F_GETFL);
                ret ^= O_NONBLOCK;
                fcntl(sock,F_SETFL,ret);
        }
        else
        {
                ret = fcntl(sock,F_GETFL);
                ret |= O_NONBLOCK;
                fcntl(sock,F_SETFL,ret);
        }
}


//thread param 
struct thread_param
{
        fd_set my_set;
        int my_count;
        int my_max;
        pthread_mutex_t my_mutex;
};

void * deal_thread(void *param)
{
        struct thread_param *p=(struct thread_param*)param;
        fd_set read_set;
        int ret;
        int i;
        struct timeval my_tv;
        my_tv.tv_sec = 0;
        my_tv.tv_usec = 10;
        while(1)
        {
                //clear
                FD_ZERO(&read_set);
                //fill
                memcpy(&read_set,&p->my_set,sizeof(read_set));
                //select
                ret = select(p->my_max+1,&read_set,NULL,NULL,&my_tv);
                //judge
                if(ret < 0)
                {
                        printf("%s",strerror(errno));
                        break;
                }
                else if(ret == 0)//chao shi
                {
                        usleep(10);
                        continue;
                }
                //check
                for(i = p->my_max;i>2;i--)
                {
                        if(FD_ISSET(i,&read_set)>0)
                        {
                                //recv
                                printf("sock[%d]:\n",i);
                                sleep(1);
                        }
                }

        }
}


int main(int argc,char *argv[])
{
        int ret;
        int sock;
        struct sockaddr_in addr;
        pid_t child;
        char buf[1024];
        int len;
        pthread_t thread;
        fd_set read_set;
        struct thread_param param;
        param.my_count = 0;
        param.my_max = 2;
        FD_ZERO(¶m.my_set);
        pthread_mutex_init(¶m.my_mutex,NULL);
        //create socket
        sock = socket(AF_INET,SOCK_STREAM,0); 
        if(sock == DEF_STD_ERROR)
        {
                printf("%s",strerror(errno));
                return -1;
        }
        //init address
        addr.sin_family = AF_INET;
        addr.sin_port = htons(DEF_BIND_PORT);
        addr.sin_addr.s_addr = inet_addr("192.168.1.127");
        ret = bind(sock,(struct sockaddr*)&addr,sizeof(addr));
        if(ret == DEF_STD_ERROR)
        {
                printf("%s",strerror(errno));
                close(sock);
                return -1;
        }
        //listen
        ret = listen(sock,5);
        if(ret == DEF_STD_ERROR)
        {
                printf("%s",strerror(errno));
                close(sock);
                return -1;
        }
        //set no block
        set_block(sock,FALSE);
        //accept
        while(1)
        {
                ret = accept(sock,NULL,NULL);
                if(ret == DEF_STD_ERROR)
                {
                        if(errno == EAGAIN)
                        {
                                //printf("yi bu...\n");
                                usleep(10);
                                continue;
                        }
                        else
                        {
                                printf("%s",strerror(errno));
                                break;
                        }
                }
                param.my_max = param.my_max > ret ? param.my_max:ret;
                                //add to read_set
                pthread_mutex_lock(¶m.my_mutex);
                if(param.my_count < 1024)
                {
                        FD_SET(ret,¶m.my_set);
                        param.my_count++;
                }
                //if is first ,create thread
                if(param.my_count == 1)
                {
                        pthread_create(&thread,NULL,deal_thread,¶m);
                }
		pthread_mutex_unlock(¶m.my_mutex);
        }
        //wait child thread
        pthread_join(thread,NULL);//WaitForSignalObject
        //pthread_mutex_destory(¶m.my_mutex);
        //close
        close(sock);
        return 0;
}