SocketChannel and OutputStream

[alzamabar]

Hi guys, I'm trying to write a very simple servlet container which uses NIO. I've got a Response class which receives in its constructor a SocketChannel is non blocking mode. This class implements javax.servlet.ServletResponse and I implemented the getWriter() method as follows (writer is of type PrintWriter, client is of type SocketChannel):

public PrintWriter getWriter() {
  writer = new PrintWriter(client.socket().getOutputStream(), true);
  return writer;
}

In my servlet I've got the following:

public void service(ServletRequest request, ServletResponse response) 
    throws ServletException, IOException {
  PrinterWriter out = response.getWriter();
  out.println("Roses are red.");
}   

I got the following exception:

java.nio.channels.IllegalBlockingModeException

Before returning the PrintWriter from getWriter I checked the channel which is is non-blocking state and open.
In the servlet, after getWriter the 'out' object is actually of type PrintWriter (not null) but when I first write something, I get this exception.

Please help.

Marco

[alzamabar]

I found the solution. The problem was indeed the blocking state of the SocketChannel. Even if I tried to set the blocking mode to true, the AbstractSelectableChannel was throwing the IllegalBlockingException. I had a look at the source, and this happened because the SocketChannel had a valid key associated with it. This is true, because I registered each SocketChannel client with a Selector, in order to be notified of bytes available on the client's input stream. I had code like the following:

  
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.socket().bind(new InetSocketAddress("localhost", 8080);
        Selector selector = Selector.open();
        ssc.register(selector, SelectionKey.OP_ACCEPT);
 
        while (!shutdown) {
            
            int n = selector.select();
            if (n == 0) continue;
            
            Iterator it = selector.selectedKeys.iterator();
            while (it.hasNext()) {
               SelectionKey key = (SelectionKey)it.next();
               if (key.isAcceptable()) {
                  ServerSocketChannel ssc = 
                    (ServerSocketChannel)key.channel();
               SocketChannel client = ssc.accept();
               
               //Registers the client with the selector for READ operation
               ...
 
               //...If I use the configureBlocking(true) method
               //here, I'll get an IllegalBlockingException
               
               //So I thought: ok, I remove the key and I should
               //be able to change the blocking method...
               it.remove();
               channel.configureBlocking(true);
 
               //But...I got the IllegalBlocking.... exception
               }
            }
            }
 

Then I had a closer look at my Nio book and actually to remove a key from service we need to invoke key.cancel() method.

So I replaced the above with the following:

 
 
//Until someone turns off the server, waits for connections
while (run) {
//Now waits until the operation of interest becomes
//available, which will result in the registered keys
//set being updated 
int nConnections = selector.select();

//Although this will never happen (unless something will
//stop the listening method), it's better to think of it
if (nConnections == 0) {
          continue;
}

//Here an operation of interest must have been occurred
//Loops through all the keys representing operation of
//interest being occurred, and retrieve the channels 
//associated with these
Iterator it = selector.selectedKeys().iterator();
while (it.hasNext()) {
  SelectionKey key = (SelectionKey)it.next();

  //A client connected to the server
  if (key.isAcceptable()) {
    ServerSocketChannel server = 
      (ServerSocketChannel)key.channel();//Retrieves the server

  //Returns the Socket to the client
  SocketChannel sc = server.accept();
 
          //Registers the client with the selector for reading operations
  this.registerChannel(selector, sc, SelectionKey.OP_READ);


} else if (key.isReadable()) {
  SocketChannel sc = (SocketChannel)key.channel();
  sc.configureBlocking(false);

  key.cancel();//HERE WE GO! This solves all the problems
 
          //I can set blocking to true if I need
          sc.configureBlocking(true);//This will work!

 

If you use key.cancel(), this removes the relationship between a selector and a channel, and therefore you can change the blocking mode as many times as you like. For instance, you may decide for non-blocking mode if you have to serve static content (because a FileChannel can transfer directly to a SocketChannel), or for blocking mode if you need to operate with Streams (like in the case where you are implementing the javax.servlet.ServletResponse interface and the getWriter() method needs to return a PrintWriter.

The rule is: blocking with blocking, non-blocking with non-blocking.
[ November 14, 2004: Message edited by: Marco Tedone ]