Non-blocking Server/Client is blocking...?!

Question

First, a simple question:
Why in most example code using Selectors, when iterating over the Set returned by Selector.selectedKeys() does the currently selected SelectionKey get removed from the Iterator? I see it all the time, but since the SelectionKey is still bound to the underlying Selector it seems to not really do anything.
Now to my main problem:
I been working with 1.4 for a week now trying to implement a simple test server/client, whereby the server constantly sends out the current time to any subscribing clients, who in turn display the time to stdout. Pretty straight forward, huh?
Well, everything seems to go fine...once. The Server accepts the client connection, sends out a the current time, the client (only one for now) receives it, displays to the screen, but then both server and client block on the Selector.select() method.
If I shut down the client, the server then continues through the select() method, finding one SelectionKey, tries to write to it and throws an IOException (since the client is no more). I'm catching that exception and then removing the channel from the Selector, so that the server may continue to service requests.
When starting a second client while the first is still running causes the following sequence of events:
Server: starts up
ClientA: connects to server
Server: broadcasts the time
ClientA: displays time
// nothing else happens until...
ClientB: connects to server
Server: broadcasts the time
ClientA: displays time
ClientB: displays time
//everything blocks again...
ClientA: disconnects from server
Server: broadcasts the time
ClientB: displays time
As you can see it seems everything blocks until a client does something (connect/disconnect).
I will post code if anyone asks, but I don't want to spam the board if no one is willing to help me.
-Justin

Answer 1

You got it!
//   ********** SERVER **********
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.CancelledKeyException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Set;
public class TestServer
  private static final int DEFAULT_PORT = 9999;
  public static void main(String[] args)
    TestServer s = new TestServer();
  }//end of main(String[])
  public TestServer()
    this(DEFAULT_PORT);
  }// end of TestServer()
  public TestServer(int port)
    InetSocketAddress addr = new InetSocketAddress(port);
    try
      Selector acceptSelector = Selector.open();
      Selector broadcastSelector = Selector.open();
      ConnectionList connections = new ConnectionList(broadcastSelector);
      Acceptor a = new Acceptor(acceptSelector, addr, connections);
      Broadcaster b = new Broadcaster(broadcastSelector, connections);
      a.start();
      b.start();
    }// end of try
    catch (Exception ex)
      ex.printStackTrace();
    }// end of catch
  }// end of TestServer(int)
  private static String status(Selector s)
    StringBuffer sb = new StringBuffer(100);
    sb.append("Selector: ");
    Set keys = s.keys();
    sb.append("\n\tNum Keys: ");
    sb.append(keys.size());
    Iterator iter = keys.iterator();
    int i = 0;
    while (iter.hasNext())
      try
        sb.append("\n\t[");
        sb.append(i++);
        sb.append("]:");
        SelectionKey key = (SelectionKey)iter.next();
        sb.append(" acceptable=");
        sb.append(key.isAcceptable());
        sb.append(" connectable=");
        sb.append(key.isConnectable());
        sb.append(" readable=");
        sb.append(key.isReadable());
        sb.append(" writable=");
        sb.append(key.isWritable());
      }// end of try
      catch (CancelledKeyException cke)
        sb.append("*** CANCELLED KEY");
      }// end of catch
    }// end of while
    return sb.toString();
  }// end of status(Selector)
  class Broadcaster extends Thread
    private final String TF = Broadcaster.class.getName();
    private int BUFFER_SIZE = 2048;
    private Selector selector_;
    private ConnectionList connections_;
    private ByteBuffer buffer_;
    public Broadcaster(Selector selector, ConnectionList connections)
      super("Broadcaster");
      selector_ = selector;
      connections_ = connections;
      buffer_ = ByteBuffer.allocateDirect(BUFFER_SIZE);
    public void run()
      while (true)
        try
          registerNewChannels();
          System.out.println("BroadcasterThread: Before select() "+status(selector_));
          System.out.println("BroadcasterThread: Selecting...");
          int keysReady = selector_.select();
          System.out.println("BroadcasterThread: After select() "+status(selector_));
          System.out.println("BroadcasterThread: "+keysReady+" ready Key(s)");
          if (keysReady > 0)
            transmit();
          }// end of if
        }// end of try
        catch (Exception ex)
          ex.printStackTrace();
          return;
        }// end of catch
      }// end of while
    protected void registerNewChannels()
    throws Exception
      SocketChannel channel = null;
      while (null != (channel = connections_.removeFirst()))
        channel.configureBlocking(false);
        channel.register(selector_, SelectionKey.OP_WRITE);
        System.out.println("BroadcasterThread: Registered connection from " + channel.socket().getInetAddress());
      }// end of while 
    }// end of registerNewChannels()
    public void transmit()
    throws Exception
      Set readyKeys = selector_.selectedKeys();
      System.out.println("BroadcasterThread: Selected Keys: "+readyKeys.size());
      SelectionKey tempKey = null;
      SocketChannel tempChannel = null;
      fillBuffer();
      for (Iterator i = readyKeys.iterator(); i.hasNext(); )
        tempKey = (SelectionKey)i.next();
        tempChannel = (SocketChannel)tempKey.channel();
        if (tempKey.isWritable())
          System.out.println("BroadcasterThread: Key selected is Writable");
          try
            tempChannel.write(buffer_);
            System.out.println("BroadcasterThread: Sent message to "+tempChannel.socket().getInetAddress());
          }// end of try
          catch (IOException ioe)
            System.err.println("BroadcasterThread: Lost Connection");
            tempChannel.close();
          }// end of catch
        }// end of if
        else
          System.out.println("BroadcasterThread: Key selected is not Writable");
        }// end of else
      }// end of for
      buffer_.clear();
    }// end of transmit()
    private void fillBuffer()
      buffer_.clear();
      /* Place Date in Buffer */
      long time = System.currentTimeMillis();
      Date d = new Date(time);
      System.out.println("BroadcasterThread: Broadcasting "+d);
      String date = d.toString()+"\n";
      byte[] datebuff = date.getBytes();
      buffer_.put(datebuff);
      /* Prepare for read operations */
      buffer_.flip();
    }// end of fillBuffer()
  }//end of inner class Broadcaster
  class Acceptor extends Thread
    private Selector selector_;
    private ConnectionList connList_;
    private final String TF = Acceptor.class.getName();
    public Acceptor(Selector selector, InetSocketAddress address, ConnectionList connList)
      super("Acceptor");
      selector_ = selector;
      connList_ = connList;
      try
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);
        ssc.socket().bind(address);
        System.out.println("AcceptorThread: Bound to " + address);
        ssc.register(selector_, SelectionKey.OP_ACCEPT);
      }// end of try
      catch (Exception ex)
        ex.printStackTrace();
      }// end of catch
    public void run()
      while (true)
        try
          System.out.println("AcceptorThread: Selecting...");
          int keysReady = selector_.select();// block till a channel is ready
          System.out.println("AcceptorThread: "+keysReady+" Keys Ready");
          if (keysReady > 0)
            acceptPendingConnections();
          }// end of if
        catch (Exception ex)
          ex.printStackTrace();
    protected void acceptPendingConnections()
    throws Exception
      Set readyKeys = selector_.selectedKeys();
      System.out.println("AcceptorThread: Selected "+readyKeys.size()+" Keys");
      for (Iterator i = readyKeys.iterator(); i.hasNext(); )
        SelectionKey key = (SelectionKey)i.next();
        i.remove();  
        ServerSocketChannel readyChannel = (ServerSocketChannel)key.channel();
        SocketChannel incomingChannel = readyChannel.accept();
        System.out.println("AcceptorThread: Connection from " + incomingChannel.socket().getInetAddress());
        connList_.add(incomingChannel);
      }// end of for
    }// end of acceptPendingConnections()
  }// end of inner class Acceptor
  class ConnectionList
    private LinkedList list_;
    private Selector selectorToNotify_;
    public ConnectionList(Selector toNotify)
      list_ = new LinkedList();
      selectorToNotify_ = toNotify;
    }// end of ConnectionList(Selector)
    public synchronized void add(SocketChannel newlyConnectedChannel)
      list_.add(newlyConnectedChannel);
      selectorToNotify_.wakeup();
    }// end of add(SocketChannel)
    public synchronized SocketChannel removeFirst()
      SocketChannel first = null;
      if (list_.size() > 0)
        first = (SocketChannel)list_.removeFirst();
      }//end of if
      return first;
    }// end of removeFirst()
  }// end of inner class ConnectionList
}// end of class TestServer
//   ********** CLIENT **********
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.CancelledKeyException;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.channels.WritableByteChannel;
import java.util.Iterator;
import java.util.Set;
public class TestClient
  public static final String TF = TestClient.class.getName();
  private static final String DEFAULT_SERVER_IP = "127.0.0.1";
  private static final int DEFAULT_SERVER_PORT = 9999;
  private InetSocketAddress serverAddr_; 
  private Selector connectSelector_;
  private Selector readSelector_; 
  private WritableByteChannel outputChannel_; 
  private ByteBuffer receiveBuffer_;
  private SocketChannel serverChannel_;
  public static void main(String[] args)
    TestClient c = new TestClient();
  }// end of main(String[])
  public TestClient()
    this(DEFAULT_SERVER_IP, DEFAULT_SERVER_PORT);
  }// end of TestClient()
  public TestClient(String ip, int port)
    try
      serverAddr_ = new InetSocketAddress(ip, port);
      connectSelector_ = Selector.open();
      readSelector_ = Selector.open();
      outputChannel_ = Channels.newChannel(System.out);
      receiveBuffer_ = ByteBuffer.allocateDirect(512);
      connect();
      run();
    }// end of try
    catch (Exception ex)
      ex.printStackTrace();
    }// end of catch
  }// end of TestClient(String, int)
  private void connect()
  throws Exception
    serverChannel_ = SocketChannel.open();
    serverChannel_.configureBlocking(false);
    serverChannel_.connect(serverAddr_);
    serverChannel_.register(connectSelector_, SelectionKey.OP_CONNECT);
    int numKeys = 0;
    while (numKeys <= 0)
      System.out.println("connect(): Selecting...");
      numKeys = connectSelector_.select();
      System.out.println("connect(): "+numKeys+" ready Key(s)");
      Set readyKeys = connectSelector_.selectedKeys();
      System.out.println("connect(): Selected Keys: "+readyKeys.size());
      if (numKeys > 0)
        SelectionKey tempKey = null;
        SocketChannel tempChannel = null;
        Iterator i = readyKeys.iterator();
        while (i.hasNext())
          tempKey = (SelectionKey)i.next(); 
          i.remove();  
          tempChannel = (SocketChannel)tempKey.channel();
          if (tempKey.isConnectable())
            System.out.println("connect(): Key selected is Connectable");
            if (tempChannel.isConnectionPending())
              System.out.println("connect(): Connection Pending");
              tempChannel.finishConnect();
              System.out.println("connect(): Connection Completed");
            }// end of if
          }// end of if
          else
            System.out.println("connect(): Key selected is not Connectable");
          }// end of else
        }// end of while
      }// end of if
    }// end of while
  }// end of connect()
  private void run()
  throws Exception
    serverChannel_.register(readSelector_, SelectionKey.OP_READ);
    while (true)
      System.out.println("run(): Before select() "+status(readSelector_));
      System.out.println("run(): Selecting...");
      int numKeys = readSelector_.select();
      System.out.println("run(): After select() "+status(readSelector_));
      System.out.println("run(): "+numKeys+" Ready Key(s)");
      if (numKeys > 0)
        processKeys();
      }// end of if
    }// end of while
  }// end of run()
  private void processKeys()
  throws Exception
    Set readyKeys = readSelector_.selectedKeys();
    System.out.println("processKeys(): Selected Keys: "+readyKeys.size());
    SelectionKey tempKey = null;
    SocketChannel tempChannel = null;
    for (Iterator i = readyKeys.iterator(); i.hasNext(); )
      tempKey = (SelectionKey)i.next();
      tempChannel = (SocketChannel)tempKey.channel();
      if (tempKey.isReadable())
        System.out.println("processKeys(): Key selected is Readable");
        try
          tempChannel.read(receiveBuffer_);
          receiveBuffer_.flip();
          outputChannel_.write(receiveBuffer_);
          receiveBuffer_.clear();
        }// end of try
        catch (IOException ioe)
          System.out.println("processKeys(): Lost Connection");
          tempKey.cancel();
        }// end of catch
      }// end of if
      else
        System.out.println("processKeys(): Key selected is not Readable");
      }// end of else
    }// end of for
  }// end of processKeys()
  private static String status(Selector s)
    StringBuffer sb = new StringBuffer(100);
    sb.append("Selector: ");
    Set keys = s.keys();
    sb.append("\n\tNum Keys: ");
    sb.append(keys.size());
    Iterator iter = keys.iterator();
    int i = 0;
    while (iter.hasNext())
      try
        sb.append("\n\t[");
        sb.append(i++);
        sb.append("]:");
        SelectionKey key = (SelectionKey)iter.next();
        sb.append(" acceptable=");
        sb.append(key.isAcceptable());
        sb.append(" connectable=");
        sb.append(key.isConnectable());
        sb.append(" readable=");
        sb.append(key.isReadable());
        sb.append(" writable=");
        sb.append(key.isWritable());
      }// end of try
      catch (CancelledKeyException cke)
        sb.append("*** CANCELLED KEY");
      }// end of catch
    }// end of while
    return sb.toString();
  }// end of status(Selector)
}// end of class TestClient