int main()
{
  accept 쓰레드를 생성한다.
  int k=1 ; // 쓰레드 일련번호로 RTS번호를 지정하기 위해서 사용한다. 
  SIRTMIN에 대한 시그널 마스크 설정

  for (지정한 갯수 만큼)
  {
1.  connect(k) 쓰레드를 생성한다.
    k++;
  }
}

accept() 쓰레드
{
  socket->bind->listen;
  만들어진 듣기 소켓에 대하여 RTS반응하도록 한다.  
  while(1)
  {
2.  accept()를 통해서 연결이 발생하면 fcntl을 통해서 해당 소켓이 
    RTS를 발생하도록 한다. 
  }
}

connect() 쓰레드
{
  pthread_sigmask를 이용해서 RTS에 쓰레드가 반응하도록 한다.  
  반응하는 RTS번호는 쓰레드마다 다르다. 
  첫번째 생성된 쓰레드는 SIGRTMIN+1, 그다음은 SIGRTMIN+2.. 식이다.
  while(1)
  {
    sigwaitinfo()를 이용해서 RTS를 기다린다.   
    RTS가 발생하면 소켓지정자를 통해서 클라이언트와 통신한다.  
  }
}
				

typedf struct _fd_sig
{
   int signum;
   int pid;
} fd_sig;

multimap<int, fd_sig> pool_list;
				

fd_sig lfd_sig;
for (i = 0, k=1; i < thread_num; i++, k++)
{
  // 변수 k는 쓰레드가 기다릴 시그널의 번호이다. 
  // (SIGRTMIN+k)형식으로 사용된다.  
  pthread_create(&th_t, NULL, thread_func, (void *)&k);
  lfd_sig.signum = (k);
  lfd_sig.pid    = pid; // pthread_create를 통해서 생성된 쓰레드의 pid 
  pool_list.insert(pair<int, fd_sig>(0, lfd_sig));
}
				

#include <pthread.h>
#include <iostream>
#include <signal.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <vector>

#include <netinet/in.h>
#include <arpa/inet.h>

#include <map>

#ifndef __USE_GNU
#define __USE_GNU
#endif
#include <fcntl.h>

using namespace std;

pthread_mutex_t mutex_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t sync_cond  = PTHREAD_COND_INITIALIZER;

int gpid;
typedef struct _fd_sig
{
    int signum;
    int pid;
} fd_sig;

/*
 * 1
 * 쓰레드당 처리중인 소켓의 정보를 유지하기 
 * 위한 자료구조. 
 * key   : 처리중인 소켓의 수 
 * value : 쓰레드(RTS 정보)
 */
multimap<int, fd_sig> pool_list;
multimap<int, fd_sig>::iterator mi; 

// RTS overflow가 발생했을 때 실행되는 핸들러
void do_sigio(int signo)
{
    printf("SIGIO : RTS signal queue overflow\n");    
}

/* 
 * 기본 시그널 핸들로 초기화 및 등록
 * 여기에서는 RTS overflow의 처리를 위한 시그널 
 * 핸들러를 등록한다.  
 */
void init_signal_handler()
{
    struct sigaction sigact;
    sigemptyset(&sigact.sa_mask);
    sigact.sa_flags        = SA_SIGINFO;
    sigact.sa_restorer    = NULL;
    sigact.sa_handler    = do_sigio;
    if (sigaction(SIGIO, &sigact, NULL) < 0)
    {
        perror("sigaction SIGIO ");
        exit(0);
    }

    return ;
}

/*
 * 2
 * 인자로 주어지는 소켓지정자 fd가 RTS시그널을
 * 발생하도록 설정한다. 
 * 발생시키는 RTS시그널 번호는 sig_num에 의해서 
 * 결정된다. 
 */
int setup_sigio(int fd, int sig_num, int pid)
{
    if (fcntl(fd, F_SETFL, O_RDWR|O_NONBLOCK|O_ASYNC) < 0)
    {
        perror("fcntl NONBLOCK ");
        return -1;
    }
    if (fcntl(fd, F_SETSIG, SIGRTMIN+sig_num) < 0)
    {
        perror("fcntl SETSIG "); 
        return -1;
    }

    // 인자로 주어진 파일지정자 fd에서 이벤트가 발생할 경우  
    // pid를 가지는 쓰레드로 RTS SIGRTMIN+sig_num 시그널이 전달된다.  
    if (fcntl(fd, F_SETOWN, pid) < 0)
    {
        perror("fcntl SETOWN ");
        return -1;
    }
    return 0;
}

/*
 * 3 
 * 듣기 소켓을 만들고 
 * 연결을 기다린다. 
 * 만약 연결이 들어온다면 pool_list자료구조를 통해서 
 * 가장 적은 소켓을 처리하는 쓰레드를 알아오고 
 * 그 쓰레드에 해당되는 RTS시그널 번호로 RTS시그널을 
 * 발생하도록 소켓을 설정한다.  
 */
void *accept_listener(void *data)
{
    int server_sockfd, cli_sockfd;    
    fd_sig lfd_sig;
    int count;
    sigset_t set;
    int client_sockfd;
    socklen_t clilen;
    int ret;

    int signum = *((int *)data);
    struct sockaddr_in serveraddr, clientaddr;
    struct siginfo si;

    if ((server_sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("socket error ");
        exit(0);
    }

    bzero(&serveraddr, sizeof(serveraddr));
    serveraddr.sin_family        = AF_INET;
    serveraddr.sin_addr.s_addr    = htonl(INADDR_ANY);
    serveraddr.sin_port            = htons(1234);

    if (bind (server_sockfd, (struct sockaddr *)&serveraddr, 
            sizeof(serveraddr)) == -1)
    {
        perror("bind error ");
        exit(0);
    }

    if (listen(server_sockfd, 5) == -1)
    {
        perror("listen error ");
        exit(0);
    }
    if (setup_sigio(server_sockfd, signum, getpid()) == -1) 
    {
        printf("sigio error\n");
        exit(0);
    }

    sigemptyset(&set);
    sigaddset(&set, SIGRTMIN+signum);
    sigprocmask(SIG_BLOCK, &set, NULL);

    pthread_mutex_lock(&mutex_lock);
    pthread_cond_signal(&sync_cond);
    pthread_mutex_unlock(&mutex_lock);

    while(1)
    {
        int ret;
        ret = sigwaitinfo(&set, &si);
        if (ret == SIGRTMIN+signum)
        {
            if (si.si_fd == server_sockfd) 
            {
                cli_sockfd = accept(server_sockfd, 
                                (struct sockaddr *)&clientaddr,
                                &clilen);
                if(cli_sockfd < 0)
                {
                    printf("Accept error\n");
                    continue;
                }
                mi = pool_list.begin();
                lfd_sig = mi->second;
                count = mi->first+1;

                /*
                 * 연결소켓에 대해서 SIGRTMIN+signum RTS를 발생하도록 
                 * 설정한다. 
                 * fcntl()을 위해서 pid를 넘기는걸 주목하기 바란다.  
                 */
                cout << "Accept " << cli_sockfd << " : " 
                    << mi->second.signum << " : " 
                    << mi->second.pid << endl;
                setup_sigio(cli_sockfd, mi->second.signum, mi->second.pid);
                pool_list.erase(mi);
                pool_list.insert(pair<int, fd_sig>(count, lfd_sig));
            }
            else
            {
            }
        }
    }
}

/*
 * 클라이언트와 데이터를 주고 받을 쓰레드 함수이다. 
 * 클라이언트로 부터 읽은 데이터를 반향(echo)한다. 
 */
void *jecho(void *rts_num)
{

    int signum = *((int *)rts_num);
    int ret; 
    socklen_t clen;
    char buf[256];
    struct sockaddr_in cname;
    int n;

    // 쓰레드의 PID를 얻어온다.     
    gpid = getpid(); 

    sigset_t set;

    sigemptyset(&set);
    sigaddset(&set, SIGRTMIN+signum);
    pthread_sigmask(SIG_BLOCK, &set, NULL);

    pthread_mutex_lock(&mutex_lock);
    pthread_cond_signal(&sync_cond);
    pthread_mutex_unlock(&mutex_lock);

    struct siginfo si;
    fd_sig lfd_sig;
    int count;
    int lpid;

    while(1)
    {
        clen = sizeof(cname);
        ret = sigwaitinfo(&set, &si);
        memset(buf,0x00, 256); 
        if (ret == SIGRTMIN+signum)
        {
            if ((n = read (si.si_fd, buf, 255)) <= 0)
            {
                printf("read error \n");
                close(si.si_fd);
                mi = pool_list.begin();
                while(mi != pool_list.end())
                {
                    if (mi->second.signum == signum)
                    {
                        lfd_sig = mi->second;
                        count = mi->first - 1;
                        pool_list.erase(mi);
                        pool_list.insert(pair<int, fd_sig>(count, lfd_sig));
                    }
                    *mi++;
                }
            }    
            else
            {
                getsockname(si.si_fd, (struct sockaddr *)&cname, &clen);
                printf("%s(%d) : %s", inet_ntoa(cname.sin_addr), signum, buf);
                write(si.si_fd, buf, strlen(buf));
            }
        }
        else
        {
        }
    }
}

int main(int argc, char **argv)
{
    struct siginfo si;
    int status;
    int k;
    fd_sig lfd_sig;
    sigset_t set;
    unsigned int i;

    if (argc !=2 )
    {
        printf("Usage : ./rts_th [thread num]\n");
        exit(1);
    }
    int thread_num = atoi(argv[1]);
    vector<void *(*)(void *)> thread_list;
    vector<pthread_t> tident(thread_num);
    pthread_attr_t myattr;
    init_signal_handler();

    sigemptyset(&set);
    sigaddset(&set, SIGRTMIN);
    sigprocmask(SIG_BLOCK,&set, NULL);

    thread_list.push_back(accept_listener);
    for (i = 0; i < thread_num; i++) 
    {    
        thread_list.push_back(jecho);
    }

    /*
     * 쓰레드를 생성한다.  
     * 첫번째 쓰레드는 accept()전용 쓰레드이며
     * 이후 생성되는 쓰레드가 클라이언트 통신전용 쓰레드이다. 
     * 쓰레드를 생성할때 넘어가는 인자 K는 쓰레드가 기다릴 
     * RTS 시그널 번호이다. 
     * 각 쓰레드는 SIGRTSMIN+k 번호를 가지는 RTS를 기다리게된다.  
     */    
    for (i = 0, k = 1; i < thread_list.size(); i++, k++)
    {
        /*
         * 메인 쓰레드와 생성되는 쓰레드간에 정확한 데이터 
         * 전달이 필요하므로 뮤텍스와 조건변수를 이용해서  
         * 쓰레드 동기화를 시켜준다.
         */
        pthread_mutex_lock(&mutex_lock);
        pthread_create(&tident[i], NULL, thread_list[i], (void *)&k);

        /*
         * 쓰레드 자료구조
         * 각 쓰레드에서 처리하는 RTS번호와 처리중인 소켓의 갯수를
         * 유지한다. 
         */
        lfd_sig.signum = k;  
        pthread_cond_wait(&sync_cond, &mutex_lock);
        lfd_sig.pid    = gpid;
        if (i !=0)
            pool_list.insert(pair<int, fd_sig>(0, lfd_sig));
        pthread_mutex_unlock(&mutex_lock);
    }

    cout << "Thread Join " << endl;
    for (i = 0; i < thread_list.size(); i++)
    {
        pthread_join(tident[i], (void **)&status);
    }
    return 1;
}
				

스케쥴관련 자료구조
{
   현재 연결된 클라이언트수
   현재 처리해야될 클라이언트 소켓지시자

   쓰레드풀에 만들어진 쓰레드 상태 : 쓰레드풀 크기만큼의 배열 
   {
       0 이면 휴식상태 
       1 이면 작업상태 
       처리중인 소켓지시자
   }
};

main 함수시작
{
    아규먼트로 몇개의 쓰레드를 생성할지를 받음
    while(쓰레드 생성수만큼)
    {
        pthread_create 를 이용해서 쓰레드 생성
        // 통신쓰레드 함수
        {
            WAIT:
            main 쓰레드가 깨우길 기다린다. 
            만약 main 쓰레드로 부터 깨움이 있다면   
            {
                스케쥴 자료구조->현재 처리해야될 소켓지시자 를 읽어온다. 
                스케쥴 자료구조->자신의 상태를 1로 세팅한다.  
                스케쥴 자료구조->처리중인 소켓지시자를 세팅한다. 
                while(1)
                {
                    클라이언트와 통신한다. 
                    만약 에러가 발생하면 
                    {
                        스케쥴 자료구조->처리중인 소켓지시자를 0으로 세팅  
                        스케쥴 자료구조->자신의 상태를 0으로 세팅
                        스케쥴 자료구조->현재 연결된 클라이언트수 --; 
                        goto WAIT:
                    }
                }
            }
        } 
    }

    // main 쓰레드
    while(1)
    {
        만약 accept 를 통해서 연결이 발생한다면
        {
            스케쥴관련 자료구조->현재연결된 클라이언트수가 MAX 를 초과하지 않았다면
            {
                스케쥴관련 자료구조->현재연결된 클라이언트수 ++; 
                스케쥴관련 자료구조->현재처리해야될 클라이언트 소켓지시자 = accept();
                스케줄관련 자료구조->쓰레드풀에 만들어진 쓰레드상태 가 0인 
                  쓰레드를 찾아서 해당 쓰레드를 깨운다.  
            }
            그렇지 않고 초과했을경우
            {
                클랑리언트에게 에러메시지를 전송한다. 
            }
        }
    }
}
				

// 쓰레드 정보 구조체
struct ph
{
   int sockfd;    // 처리중인 소켓지정번호
   int index_num; // 쓰레드의 인덱스 번호
};

// 쓰레드 구조체 MAP
multimap<int, struct ph> phinfo;

struct schedul_info
{
    int client_num;      // 총 연결중인 클라이언트수 
    int current_sockfd;  // 가장최근에 연결된 소켓지정번호
    phinfo mphinfo;      // 쓰레드 구조체 map
} 
				

  1 2 3 4 5 6 7    99 100  : 쓰레드 번호
 +-+-+-+-+-+-+-+---+-+-+
 |0|0|0|0|0|0|0|...|0|0|
 +-+-+-+-+-+-+-+---+-+-+

 --> 연결이 들어왔다면 
  1 2 3 4 5 6 7    99 100  : 쓰레드 번호
 +-+-+-+-+-+-+-+---+-+-+
 |1|0|0|0|0|0|0|...|0|0|
 +-+-+-+-+-+-+-+---+-+-+
  |                   |  
  +----------->-------+
  가장 뒤로 자동으로 sort 됨

 --> Sort 후
  2 3 4 5 6 7 8   100 1 : 쓰레드 번호
 +-+-+-+-+-+-+-+---+-+-+
 |0|0|0|0|0|0|0|...|0|1|
 +-+-+-+-+-+-+-+---+-+-+

 --> 클라이언트가 99개가 접속해 있을경우
 +-+-+-+-+-+-+-+---+-+-+
 |0|1|1|1|1|1|1|...|1|1|
 +-+-+-+-+-+-+-+---+-+-+

 그럼으로 begin() 을 사용하게 될경우 
 언제나 휴식상태에 있는 쓰레드를 가져올수 있음