1 fd_set fd_in, fd_out;
 2 struct timeval tv;
 3 
 4 // Reset the sets
 5 FD_ZERO( &fd_in );
 6 FD_ZERO( &fd_out );
 7 
 8 // Monitor sock1 for input events
 9 FD_SET( sock1, &fd_in );
10 
11 // Monitor sock2 for output events
12 FD_SET( sock2, &fd_out );
13 
14 // Find out which socket has the largest numeric value as select requires it
15 int largest_sock = sock1 > sock2 ? sock1 : sock2;
16 
17 // Wait up to 10 seconds
18 tv.tv_sec = 10;
19 tv.tv_usec = 0;
20 
21 // Call the select
22 int ret = select( largest_sock + 1, &fd_in, &fd_out, NULL, &tv );
23 
24 // Check if select actually succeed
25 if ( ret == -1 )
26     // report error and abort
27 else if ( ret == 0 )
28     // timeout; no event detected
29 else
30 {
31     if ( FD_ISSET( sock1, &fd_in ) )
32         // input event on sock1
33 
34     if ( FD_ISSET( sock2, &fd_out ) )
35         // output event on sock2
36 }

 1 // The structure for two events
 2 struct pollfd fds[2];
 3 
 4 // Monitor sock1 for input
 5 fds[0].fd = sock1;
 6 fds[0].events = POLLIN;
 7 
 8 // Monitor sock2 for output
 9 fds[1].fd = sock2;
10 fds[1].events = POLLOUT;
11 
12 // Wait 10 seconds
13 int ret = poll( &fds, 2, 10000 );
14 // Check if poll actually succeed
15 if ( ret == -1 )
16     // report error and abort
17 else if ( ret == 0 )
18     // timeout; no event detected
19 else
20 {
21     // If we detect the event, zero it out so we can reuse the structure
22     if ( fds[0].revents & POLLIN )
23         fds[0].revents = 0;
24         // input event on sock1
25 
26     if ( fds[1].revents & POLLOUT )
27         fds[1].revents = 0;
28         // output event on sock2
29 }

 1 // Create the epoll descriptor. Only one is needed per app, and is used to monitor all sockets.
 2 // The function argument is ignored (it was not before, but now it is), so put your favorite number here
 3 int pollingfd = epoll_create( 0xCAFE );
 4 
 5 if ( pollingfd < 0 )
 6  // report error
 7 
 8 // Initialize the epoll structure in case more members are added in future
 9 struct epoll_event ev = { 0 };
10 
11 // Associate the connection class instance with the event. You can associate anything
12 // you want, epoll does not use this information. We store a connection class pointer, pConnection1
13 ev.data.ptr = pConnection1;
14 
15 // Monitor for input, and do not automatically rearm the descriptor after the event
16 ev.events = EPOLLIN | EPOLLONESHOT;
17 // Add the descriptor into the monitoring list. We can do it even if another thread is
18 // waiting in epoll_wait - the descriptor will be properly added
19 if ( epoll_ctl( epollfd, EPOLL_CTL_ADD, pConnection1->getSocket(), &ev ) != 0 )
20     // report error
21 
22 // Wait for up to 20 events (assuming we have added maybe 200 sockets before that it may happen)
23 struct epoll_event pevents[ 20 ];
24 
25 // Wait for 10 seconds, and retrieve less than 20 epoll_event and store them into epoll_event array
26 int ready = epoll_wait( pollingfd, pevents, 20, 10000 );
27 // Check if epoll actually succeed
28 if ( ret == -1 )
29     // report error and abort
30 else if ( ret == 0 )
31     // timeout; no event detected
32 else
33 {
34     // Check if any events detected
35     for ( int i = 0; i < ready; i++ )
36     {
37         if ( pevents[i].events & EPOLLIN )
38         {
39             // Get back our connection pointer
40             Connection * c = (Connection*) pevents[i].data.ptr;
41             c->handleReadEvent();
42          }
43     }
44 }