title: java.nio.channels.IllegalBlockingModeException while reading content from client through a channel
body: <p>Am very new to NIO am building a chat application i got connection in all the client but while reading content from client i got <code>java.nio.channels.IllegalBlockingModeException</code>. please help me here is the code where the exception occures. while reaching <code>while (rbc.read(b) != -1)</code> of <code>PrintRequest class</code> Exception occures</p>
  
  <pre><code>public class PrintRequest extends Thread
  {
  
      public  PrintRequest(SocketChannel sc,int i)throws Exception
      {
          System.out.println("going to enter the try block of PrintRequest");        
          try
          {   
                 System.out.println("Am in the try block of PrintRequest");    
  
                 ReadableByteChannel rbc = Channels.newChannel(sc.socket().getInputStream()); 
                 System.out.println("checking in PrintRequest 0001");
                 WritableByteChannel wbc = Channels.newChannel(System.out); 
                 System.out.println("checking in PrintRequest 0010");
                 ByteBuffer b = ByteBuffer.allocateDirect(1024); // read 1024 bytes 
                  // int numBytesRead = sc.read(b);
                   System.out.println("checking in PrintRequest 0011");
                   while (rbc.read(b) != -1) 
                   {
                       System.out.println("Am  in while loop of PrintRequest ");
                      b.flip();
                      while (b.hasRemaining())
                      { 
                           wbc.write(b);
                           System.out.println();
                      }
                      b.clear();
                   }
  
          }
          catch(Exception E)
          {
              System.out.println("Exception in printlnRequest  "+E);
          }                          
      }  }
  </code></pre>
  
  <p>my server code:</p>
  
  <pre><code>public class Server
  {
  
    private Selector selector;
  
   private ServerSocketChannel channel;
  
    public void listner()
     {
  
             try
      {
        this.selector = Selector.open();
        this.channel = ServerSocketChannel.open();
        this.channel.configureBlocking(false);
        this.channel.socket().bind(new InetSocketAddress(8888));
        this.channel.register(this.selector, 16);
      }
      catch (IOException e)
      {
        throw new RuntimeException("Could not register listener", e);
      }}
  
  
    public void non_Socket()throws Exception
      {
  
          try
          {
               int i=0;
               this.channel = ServerSocketChannel.open();
               this.channel.configureBlocking(false);
               this.channel.socket().bind(new InetSocketAddress(80));
  
              while(true)
              {
  
                  this.selector = Selector.open();
                  this.channel.register(this.selector, 16);
  
                  Set&lt;SelectionKey&gt; keys = this.selector.selectedKeys();
                  Iterator&lt;SelectionKey&gt; iterator = keys.iterator();
                  int readyChannels = selector.select();
                  if(readyChannels == 0) continue;
                  Set&lt;SelectionKey&gt; selectedKeys = selector.selectedKeys();
                  Iterator&lt;SelectionKey&gt; keyIterator = selectedKeys.iterator();
                  while(keyIterator.hasNext()) 
                  {
                       SelectionKey key  = keyIterator.next();
                       if(key.isAcceptable()) 
                       {
                            // a connection was accepted by a ServerSocketChannel.
                            System.out.println("a connection was accepted by a ServerSocketChannel");
                            SocketChannel sc = this.channel.accept();
                            sc.configureBlocking(false);
                            System.out.println("Received an incoming connection from " + sc.socket().getRemoteSocketAddress()); 
                            System.out.println("checking 0101");
                            // new PrintRequest(sc,i).start(); 
                            System.out.println("checking 0110");
  
                            if(sc == null )
                              {
                                  System.out.println("Please login");
                                  Thread.sleep(6000);
                              }
                            else
                            {
                                  System.out.println("Last Login was successful");
                                 // new PrintRequest(sc,i).start(); 
                                  PrintRequest pr=new PrintRequest(sc,i);
                                  new Thread(pr).start();
  
                            }
  
  
                       }
                       else if (key.isConnectable())
                       {
                               // a connection was established with a remote server.
                           System.out.println("a connection was established with a remote server");
  
  
                       }
                       else if (key.isWritable()) 
                       {
                          // a channel is ready for writing
                           System.out.println(" a channel is ready for writing");
                       }
  
                       else if (key.isReadable()) 
                       {
                          // a channel is ready for reading
                           System.out.println(" a channel is ready for Reading");
                       } 
                       System.out.println(" a channel is prepare for Reading");
                       keyIterator.remove();
                       Thread.sleep(5000);
                  }
  
             }
          }
  
          catch(Exception E)
          {
              System.out.println(" Here    : "+E);
          }
          finally
                { 
                     if (channel != null) 
                     { 
                      try 
                      { 
                              channel.close(); 
                      }
                      catch (Exception e) 
                      { 
                              e.printStackTrace(); 
                      }
                     }
                 }
      }
  
  
      public static void main(String [] abc) throws Exception
      {
          new Server().non_Socket();
      }}
  </code></pre>
  
  <p>Client side:</p>
  
  <pre><code>public class Client 
  {
  
      public void non_Client_Socket()
      {
          SocketChannel sChannel=null;
          try
          {
              sChannel = SocketChannel.open();
              sChannel.connect(new InetSocketAddress("localhost", 80));
              while (!sChannel.finishConnect())
              {
                  System.out.println("Channel is not connected yet");
                  Thread.sleep(5000);
              }
  
              System.out.println("Channel is ready to use");
  
              /* ----------  going to send data to server ------------*/   
              System.out.println("please enter the text");
              BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
              while(true)
                  {
                      System.out.println("Enter the text");
                      String HELLO_REQUEST =stdin.readLine().toString();
                      if(HELLO_REQUEST.equalsIgnoreCase("end"))
                      {
                          break;
                      }
  
                      System.out.println("Sending a request to HelloServer");    
                      ByteBuffer buffer = ByteBuffer.wrap(HELLO_REQUEST.getBytes());    
                      sChannel.write(buffer); 
                  }  
          }
          catch(Exception E)
          {
  
          }
  
           finally
          {       
              if (sChannel != null)
              {            
                  try 
                  {             
                     sChannel.close();            
                  }
                  catch (Exception e)
                  {           
                      e.printStackTrace();       
                  }       
              } 
  
          }  } 
           /* ----------  the data is written in sChannel server will read from this channel  ------------   */
  
  
  
  
      public static void main(String [] args)throws Exception
      {
          new Client().non_Client_Socket();
      }}
  </code></pre>