JAVA(4)-BIO-NIO

1.BIO BlockingIO的意思。还是从最简单的说起,过程参看前篇，python版，本篇就是用JAVA再写了一遍。
  1.1一服务器端，一个客户端
  1.2.一个服务器端，多个客户端
2.NIO，非阻塞IO

---

1.BIO BlockingIO的意思。还是从最简单的说起。
  1.1一服务器端，一个客户端  
    

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket ss= new ServerSocket();
        ss.bind(new InetSocketAddress("localhost",8888));
        System.out.println("server start");
        Socket s=ss.accept();
 
        BufferedReader reader=new BufferedReader(new InputStreamReader(s.getInputStream()));
        String str=reader.readLine();

        System.out.println(str);
        System.out.println("server close");
        reader.close();
        s.close();
        ss.close();
    }

public class Client {
    public static void main(String[] args) throws IOException {
        Socket s = new Socket("localhost", 8888);
        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        bw.write("clientsendMsg");
        bw.flush();
        bw.close();
    }
}

运行的结果：Server 在 接收到client之前一直阻塞在那。


  1.2.一个服务器端，多个客户端
    添加了while(）对每个SOCKET启用一个线程
    缺点： 只要有一个有问题，下面的就进不来了。
    优点： 如果确定只有十几个客户端，其实这是高效的且简单。

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket ss= new ServerSocket();
        ss.bind(new InetSocketAddress("localhost",8888));
        System.out.println("server close");
        boolean started=true;

        while(started)
        {
            Socket s = ss.accept();

            BufferedReader reader = new BufferedReader(new InputStreamReader(s.getInputStream()));
            String str = reader.readLine();

            System.out.println(str);
            reader.close();
            s.close();
        }

        ss.close();
    }
}

2.NIO，非阻塞IO
  2.1非阻塞的都是带 channel的 双向读写
  2.2 下面的代码要用，需要加上try/catch..

public class Server
{
  public static void main(String[] args)
  {
    ServerSocketChannel ssc=ServerSocketChannel.open();
    ssc.socket().bind(new InetSocketAddress("127.0.0.1",8888));
    ssc.configureBlocking(false);//设置成非阻塞

     System.out.println("server started,listening on:"+ssc.getLocalAddress());
    //建立了一个大管家selector，管什么呢？管事件 OP_ACCEPT
    //建立管道了，
    Selector selector=Selector.open();
    ssc.register(selector,SelectionKey.OP_ACCEPT);
    while(true)
    {
      selector.select();//轮询看有没有事件 下面处理事件
      Set<SelectionKey > keys=selector.selectedkeys();
      Iterator<Selectionkey> it=keys.iterator();
      while(it.hasNext())
      {
        SelectionKey key=it.next();
        it.remove();
        handle(key);
      }
    }
  }
  //处理事件的过程
  private static void handle(Selectionkey key)
  {
    if(key.isAcceptable())//事件可以被连上了
    {
      
        ServerSocketChannel ssc=(ServerSocketChannel) key.channel();
ServerSocketChannel sc=ssc.accept();//接收，建立新通道
        sc.configureBlocking(false);//非阻塞
        //监听读事件
        sc.register(key.selector(),SelectionKey.OP_READ);
     
    }
    else if(key.isReadable())//客户端有数据了
    {
      SocketChannel sc=null;
    
        sc=(SocketChannel)key.channel();
        ByteBuffer buffer=ByteBuffer.allocate(512);
        buffer.clear();
        int len=sc.read(buffer);
       if(len!=-1)
       {
         System.out.println(new String(buffer.array(),0,len));
       }
        ByteBuffer bufferToWrite=ByteBuffer.wrap("helloClient".getBytes());
        sc.write(bufferToWrite);
 
        if(sc!=null)
        {
         
            sc.close();
          
      }
    }
  }
}