Multiple non-blocking selectors in threads

Question

About networking in java and sockets i read alot. I know about the 2 implementations witk thread per client and non-blocking IO (usage of select()). I ran a few tests of my own and i could't decide. So I wrote a server that uses them both. The Ideea is to have no more than 100 clients per each selector and each selector runs in a thread. so when you have 4000 clients you actualy have 40 threads running each 100 clients:D
However I'm stuck. I wrote this piece of code that has 2 objects one work thread with his own selector and a main thread with an accepting selector. The problem is that when I connect to it via telnet it only works when there is an even number of clients:(( when client nr 1 connects it blocks on channel.register(workSelector,SelectionKey.OP_READ);when client 2 gets connected it works:((
HELP!!!
here is the
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
//work thread with own selector
class workThread implements Runnable{
     public int userCount=0;
     public int ID=0;
     private Charset charset;
     private CharsetEncoder encoder;
     private CharsetDecoder decoder;
     private ByteBuffer buffer;
     private ConcurrentHashMap userMap;
     public Selector workSelector = null;
     public void addClient(SelectableChannel channel, int ops) throws IOException{
          if (channel == null) return;
          //channel.configureBlocking(false);
          System.out.println("Channel was added in workSelector : "+channel);
          channel.register(workSelector,SelectionKey.OP_READ);
          System.out.println("Client was added in work selector : " + ID);
          userCount++;
          System.out.println("Client nr : "+userCount);
     public boolean find(String name){
          return true;
     public workThread() throws IOException{
          charset = Charset.forName("ISO-8859-1");
          encoder = charset.newEncoder();
          decoder     = charset.newDecoder();     
          buffer = ByteBuffer.allocate(256);
//          System.out.println("S-a creat selectorul");
          workSelector = Selector.open();
          System.out.println("Selector open ");
     private void doRead(SelectionKey key) throws IOException{
          SocketChannel clientChannel = (SocketChannel)key.channel();
          buffer.clear();
          System.out.println("Speaking to client");
          if(clientChannel.read(buffer) == -1){
               key.cancel();
               clientChannel.close();
          }else{
               buffer.flip();
               String message = decoder.decode(buffer).toString();
               System.out.println(message);
               if(message.trim().equals(".")){
                    clientChannel.write(encoder.encode(CharBuffer.wrap("BYE")));
                    key.cancel();
                    clientChannel.close();
               }else{
                    buffer.flip();
                    clientChannel.write(buffer);
     private void doWrite(SelectionKey key){
          System.out.println("WRITE!!!");
     public void run(){
          while(true){
               try{
               if(workSelector.select() > 0){
                    Set keys1 = workSelector.selectedKeys();
                    for(Iterator itr = keys1.iterator();itr.hasNext();){
                         SelectionKey key = (SelectionKey)itr.next();
                         itr.remove();
                         if(key.isReadable()) {doRead(key);}
                    //     if(key.isWritable()) {doWrite(key);}
          }catch(IOException e){
               System.out.println("Error in workthread "+ID+" "+e);
//main thread
public class msselect implements Runnable{
     private ServerSocketChannel server;
     private ServerSocket sock;
     private Selector acceptSelector;
     private workThread wk;
     public static void main(String args[]){
          try{
          msselect x = new msselect("80.97.89.73",6500,5);
          new Thread(x).start();
          }catch(IOException ex){
               System.out.println("Probleme"+ex);
     msselect(String host, int port, int numT) throws IOException{
          server = ServerSocketChannel.open();
          sock = server.socket();
          sock.bind(new InetSocketAddress(port));
          server.configureBlocking(false);
          acceptSelector = Selector.open();
          server.register(acceptSelector, SelectionKey.OP_ACCEPT);
/*          for(int i=0;i<numT;i++){
               wk[i] = new workThread();
               wk.ID = i;
               new Thread(wk[i]).start();
          wk = new workThread();
          wk.ID = 1;
          server.register(wk.workSelector, SelectionKey.OP_ACCEPT);
          new Thread(wk).start();
     public void run(){
          while(true){
               try{
               acceptSelector.select();
               Set keys = acceptSelector.selectedKeys();
               for(Iterator itr = keys.iterator();itr.hasNext();){
                    SelectionKey key = (SelectionKey)itr.next();
                    itr.remove();
                    if(key.isAcceptable()){
                         SocketChannel client = null;
                         client = server.accept();
                         client.configureBlocking(false);
                         System.out.println("Accepted "+client);
                         wk.addClient(client,SelectionKey.OP_READ);
          }catch(IOException e){
               System.out.println("Main Thread error"+e);

Answer 1

I compiled and ran your code.
The call channel.register(...) should block while selector is blocked in workSelector.select(). The fact that the registration succeeds is that you registered the server channel with both the work selector and the acceptor selector. The work selector is returning from select() because of a new client connection is accepted and is a matter of thread scheduling that the client.register() succeeeds (but only sometimes).
Possible solution:
- don't register the server channel with the work selector;
- probably call workSelector.wakeup() to make the client channel registration possible.