Selector.selectedKeys() random ordering vs. fairness

Question

All Sun's selector implementations are based on SelectorImpl, which keeps selectedKeys in a classic HashSet with a random order of elements.
Now, suppose I insist on processing the incoming requests in the exact order as they were received, to ensure fairness. The classic mechanism for ensuring fairness are threads, but this a single-thread solution, and even with threads, it would be more fair to dispatch firstly-received requests first.
So far the only solution seems to be a dirty (should I say dodgy) replace (via reflection) of the aforementioned HashSet with a LinkedHashSet. (tested on Linux/epoll, works)
If you know of any other solution please let me know.

Answer 1

Hi, thanks for replying to both of my comments. (the other thread: http://forum.java.sun.com/thread.jspa?threadID=407203&tstart=0 )
These two issues are correlated so I will sum it up here, as the other thread is old and in a wrong forum.
I'm getting the following results:
1. only a single OP_ACCEPT is signalled in any given select() operation
2. OP_READs are grouped to a single select(), no matter what time intervals they came in
Tested on Windows (sun.nio.ch.WindowsSelectorImpl) and Linux (sun.nio.ch.EPollSelectorImpl).
The accepts are fired inside of 100ms (linux) and 50ms (windows). The reads are split into 3 groups separated by 5 second wait.
I'm attaching my test program. The two tests are separated and must be manually switched on.
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
public class test2 {
     public static void main(String[] args) throws Exception {
          server server = new server();
          server.bind();
          int test = 1;
          p("running test " + test);
          if(test == 1) { //test the partitioning of read events into more select() operations
               client cc[] = new client[30];
               for(int i = 0; i < cc.length; i++) {
                    cc[i] = new client("" + i);
                    cc.connect_to_server();
               while(server.process_a_single_loop()); //process all the accepts
               for(int i = 0; i < cc.length; i++) { //send requests in 3 groups separated by 2 waits
                    cc[i].send_data_to_server("hello");
                    if(i == 9 || i == 19) {
                         p("waiting 5 sec");
                         Thread.sleep(5000L);
               while(server.process_a_single_loop()); //now process the reads
               p("done");
          if(test == 2) { //test the grouping of more accept events into a single select() operation
               connect_thread tt[] = new connect_thread[30];
               client cc[] = new client[30];
               for(int i = 0; i < cc.length; i++) {
                    cc[i] = new client("" + i); //create new clients
                    tt[i] = new connect_thread(cc[i]); //create connector threads
               //now quick-start the threads
               long max = 0L, start = System.currentTimeMillis();
               for(int i = 0; i < tt.length; i++)
                    tt[i].start();
               Thread.sleep(1000L); //let the dust settle
               for(int i = 0; i < tt.length; i++) { //gather client connect time statistics
                    if(max < tt[i].finished)
                         max = tt[i].finished;
               p("all connections happened inside of " + (max - start) + " ms");
               while(server.process_a_single_loop()); //now process the accepts
               p("done");
          server.unbind();
     static class connect_thread extends Thread {
          client c;
          long finished;
          connect_thread(client c) {
               this.c = c;
          public void run() {
               try {
                    c.connect_to_server();
                    finished = System.currentTimeMillis();
               catch(Exception e) {
                    e.printStackTrace();
     static void p(Object o) {
          System.out.println(o);
     static class server {
          ServerSocketChannel server_chan;
          Selector server_selector;
          int loop;
          void bind() throws Exception {
               server_chan = ServerSocketChannel.open();
               server_selector = Selector.open();
               server_chan.socket().bind(new InetSocketAddress (8401));
               server_chan.configureBlocking(false);
               server_chan.register(server_selector, SelectionKey.OP_ACCEPT);
               p("Used selector implementation: " + server_selector.getClass().getName());
          boolean process_a_single_loop() throws Exception {
               boolean anything_done = false;
               loop++;
               p("server - processing loop " + loop);
               server_selector.selectNow();
               Iterator<SelectionKey> it = server_selector.selectedKeys().iterator();
               while(it.hasNext()) {
                    anything_done = true;
                    SelectionKey key = it.next();
                    if(key.isAcceptable()) {
                         ServerSocketChannel server = (ServerSocketChannel) key.channel();
                         SocketChannel channel = server.accept();
                         channel.configureBlocking(false);
                         channel.register(server_selector, SelectionKey.OP_READ, channel);
                         p("server - accepted a new connection");
                    if(key.isReadable()) {
                         anything_done = true;
                         SocketChannel channel = (SocketChannel) key.attachment();
                         ByteBuffer bb = ByteBuffer.wrap(new byte[10000]);
                         channel.read(bb);
                         bb.flip();
                         String s = new String(bb.array(), bb.position(), bb.limit() - bb.position(), "UTF-16");
                         p("server - received data: " + s);
                    it.remove();
               return anything_done;
          void unbind() throws Exception {
               server_chan.close();
     static class client {
          String id;
          Socket socket;
          client(String id) throws Exception {
               this.id = id;
          void connect_to_server() throws Exception {
               socket = new Socket();
               //s.setTcpNoDelay(true);
               socket.connect(new InetSocketAddress("localhost", 8401));
          void send_data_to_server(String data) throws Exception {
               String buf = "hello from " + s() + ": " + data; // + "\n";
               socket.getOutputStream().write(buf.getBytes("UTF-16"));
          String s() {
               return "client[" + id + "]";
I think I can solve this "unfairness" problem by having a dedicated thread constantly transferring any new events from the selector to my own queue - the select() would be called frequently enough to get the events properly ordered.