BIO、NIO、AIO系列一：NIO

一、几个基本概念

1.同步、异步、阻塞、非阻塞

同步：用户触发IO操作，你发起了请求就得等着对方给你返回结果，你不能走，针对调用方的，你发起了请求你等

异步：触发触发了IO操作，即发起了请求以后可以做自己的事，等处理完以后会给你返回处理完成的标志，针对调用方的，你发起了请求你不等

阻塞：你调用我，我试图对文件进行读写的时候发现没有可读写的文件，我的程序就会进入等待状态，等可以读写了，我处理完给你返回结果，这里的等待和同步的等待有很大的区别，针对服务提供方的，你调用我我发现服务不可用我等

非阻塞：你调用我，我试图对文件读写的时候发现没有读写的文件，不等待直接返回，等我发现可以读写文件处理完了再给你返回成功标志，针对服务提供方的，你调用我我不等，我处理完了给你返回结果

2、Java对BIO、NIO、AIO的支持：

Java BIO ： 同步阻塞：你调用我，你等待我给你返回结果，我发现没有可读写的资源我也等待，两个一起等，JDK1.4以前的唯一选择，适用于数目比较少并且比较固定的架构，对服务器资源要求比较高，大家都在等资源，等服务提供方处理完了再给你返回结果

Java NIO ：同步非阻塞： 你调用我，你等待我给你返回结果，我发现没有可以读写的资源，我不等待先直接返回，等我发现有可以读写的资源以后处理完给你返回结果，适用于连接数目多且连接时间比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4开始支持。

Java AIO(NIO.2) ： 异步非阻塞：你调用我，你不等待继续做自己的事，我发现没有可以读写的资源，我也不等待继续做我自己的事，等有可以读写的资源的时候我处理完给你返回结果，适用于连接数目多且连接时间比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。

3、BIO、NIO、AIO适用场景分析:

BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解。

NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4开始支持。

AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。

另外，I/O属于底层操作，需要操作系统支持，并发也需要操作系统的支持，所以性能方面不同操作系统差异会比较明显。

二、NIO基础

1、传统BIO模型-InputStream、OutputStream

传统BIO是一种同步的阻塞IO，IO在进行读写时，该线程将被阻塞，线程无法进行其它操作。

IO流在读取时，会阻塞。直到发生以下情况：1、有数据可以读取。2、数据读取完成。3、发生异常。

服务端：

BioServer.java

 1 import java.io.IOException;
 2 import java.net.ServerSocket;
 3 import java.net.Socket;
 4 
 5 
 6 public class BioServer {
 7     public static void main(String[] args) {
 8         int port=8080; //服务端默认端口
 9         if(args != null && args.length>0){
10             try {
11                 port = Integer.valueOf(args[0]);
12             } catch (NumberFormatException e) {
13             }
14         }
15         ServerSocket server = null;
16         try {
17             server = new ServerSocket(port);
18             System.out.println("启动了服务端，端口:"+port);
19             Socket socket = null;
20             while(true){
21                 socket = server.accept();//阻塞等待客户端连接
22                 new Thread(new BioServerHandler(socket)).start();
23             }
24         } catch (Exception e) {
25             e.printStackTrace();
26         } finally {
27             if(server!=null){
28                 System.out.println("关闭了服务.");
29                 try {
30                     server.close();
31                     server = null;
32                 } catch (IOException e) {
33                     e.printStackTrace();
34                 }
35             }
36         }
37     }
38 }

BioServerHandler.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;

public class BioServerHandler implements Runnable {

    private Socket socket;
    public BioServerHandler(Socket socket){
        this.socket = socket;
    }
    
    @Override
    public void run() {
        BufferedReader in = null;
        try {
            in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            String body = null;
            while(true){
                body = in.readLine(); //阻塞等待数据可以被读取
                if(body == null){
                    break;
                }
                System.out.println("服务器接收到指令:"+body);
            }
        } catch (Exception e) {
            if(in != null){
                try {
                    in.close();
                    in = null;//
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
                this.socket = null;
            }
        }
    }

}

客户端：

BioServerClient.java

 1 import java.io.IOException;
 2 import java.io.PrintWriter;
 3 import java.net.Socket;
 4 
 5 public class BioServerClient {
 6 
 7     public static void main(String[] args) {
 8         int port=8080; //服务端默认端口
 9         if(args != null && args.length>0){
10             try {
11                 port = Integer.valueOf(args[0]);
12             } catch (NumberFormatException e) {
13             }
14         }
15         Socket socket = null;
16         PrintWriter out = null;
17         try {
18             socket = new Socket("127.0.0.1", port);
19             out = new PrintWriter(socket.getOutputStream(), true);
20             out.println("9527");
21             System.out.println("客户端向服务端发送了指令");
22         } catch (Exception e) {
23             e.printStackTrace();
24         } finally {
25             if(out !=null){
26                 out.close();
27                 out = null;
28             }
29             if(socket != null){
30                 try {
31                     socket.close();
32                 } catch (IOException e) {
33                     e.printStackTrace();
34                 }
35                 socket = null;
36             }
37         }
38     }
39 }

2、伪异步IO模型

以传统BIO模型为基础，通过线程池的方式维护所有的IO线程，实现相对高效的线程开销及管理。

服务端：

TimeServer.java

 1 import java.io.IOException;
 2 import java.net.ServerSocket;
 3 import java.net.Socket;
 4 public class TimeServer {
 5     public static void main(String[] args) {
 6         int port=8080; //服务端默认端口
 7         ServerSocket server = null;
 8         try {
 9             server = new ServerSocket(port);
10             System.out.println("The time server is start in port:"+port);
11             Socket socket = null;
12             //通过线程池的方式维护所有的IO线程，实现相对高效的线程开销及管理
13             TimeServerHandlerExecutePool singleExecutor = new TimeServerHandlerExecutePool(50, 10000);
14             
15             while(true){
16                 socket = server.accept();
17 //                new Thread(new TimeServerHandler(socket)).start();
18                 singleExecutor.execute(new TimeServerHandler(socket));
19             }
20         } catch (Exception e) {
21             e.printStackTrace();
22         } finally {
23             if(server!=null){
24                 System.out.println("The time server is close.");
25                 try {
26                     server.close();
27                     server = null;
28                 } catch (IOException e) {
29                     e.printStackTrace();
30                 }
31             }
32         }
33     }
34 }

TimeServerHandler.java

 1 import java.io.BufferedReader;
 2 import java.io.IOException;
 3 import java.io.InputStreamReader;
 4 import java.io.PrintWriter;
 5 import java.net.Socket;
 6 import java.util.Date;
 7 
 8 
 9 public class TimeServerHandler implements Runnable {
10 
11     private Socket socket;
12     public TimeServerHandler(Socket socket){
13         this.socket = socket;
14     }
15     
16     @Override
17     public void run() {
18         BufferedReader in = null;
19         PrintWriter out = null;
20         try {
21             in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
22             out = new PrintWriter(this.socket.getOutputStream(), true);
23             String currentTime = null;
24             String body = null;
25             while(true){
26                 body = in.readLine();
27                 if(body == null){
28                     break;
29                 }
30                 System.out.println("The time server(Thread:"+Thread.currentThread()+") receive order:"+body);
31                 currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new Date(System.currentTimeMillis()).toString() : "BAD ORDER";
32                 out.println(currentTime);
33             }
34         } catch (Exception e) {
35             if(in != null){
36                 try {
37                     in.close();
38                     in = null;//
39                 } catch (IOException e1) {
40                     e1.printStackTrace();
41                 }
42             }
43             if(out != null){
44                 try {
45                     out.close();
46                     out = null;
47                 } catch (Exception e1) {
48                     e1.printStackTrace();
49                 }
50             }
51             if(socket != null){
52                 try {
53                     socket.close();
54                 } catch (IOException e1) {
55                     e1.printStackTrace();
56                 }
57                 this.socket = null;
58             }
59         }
60     }
61 
62 }

服务端线程池TimeServerHandlerExecutePool.java

 1 import java.util.concurrent.ArrayBlockingQueue;
 2 import java.util.concurrent.ExecutorService;
 3 import java.util.concurrent.ThreadPoolExecutor;
 4 import java.util.concurrent.TimeUnit;
 5 
 6 public class TimeServerHandlerExecutePool {
 7 
 8     private ExecutorService executor;
 9     
10     public TimeServerHandlerExecutePool(int maxPoolSize, int queueSize) {
11         executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(), maxPoolSize, 120l, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(queueSize));
12     }
13 
14     public void execute(Runnable task) {
15         executor.execute(task);
16     }
17 
18 }

客户端：

TimeServerClient.java

 1 import java.io.BufferedReader;
 2 import java.io.IOException;
 3 import java.io.InputStreamReader;
 4 import java.io.PrintWriter;
 5 import java.net.Socket;
 6 
 7 public class TimeServerClient {
 8 
 9     public static void main(String[] args) {
10         int port=8080; //服务端默认端口
11         Socket socket = null;
12         BufferedReader in = null;
13         PrintWriter out = null;
14         try {
15             socket = new Socket("127.0.0.1", port);
16             in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
17             out = new PrintWriter(socket.getOutputStream(), true);
18             out.println("QUERY TIME ORDER");
19             System.out.println("Send order to server succeed.");
20             String resp = in.readLine();
21             System.out.println("Now is : "+resp);
22         } catch (Exception e) {
23             e.printStackTrace();
24         } finally {
25             if(out !=null){
26                 out.close();
27                 out = null;
28             }
29             if(in != null){
30                 try {
31                     in.close();
32                 } catch (IOException e) {
33                     e.printStackTrace();
34                 }
35             }
36             if(socket != null){
37                 try {
38                     socket.close();
39                 } catch (IOException e) {
40                     e.printStackTrace();
41                 }
42                 socket = null;
43             }
44         }
45     }
46 }

3、NIO模型

NIO（JDK1.4）模型是一种同步非阻塞IO，主要有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector（多路复用器）。传统IO基于字节流和字符流进行操作，而NIO基于Channel和Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(多路复用器)用于监听多个通道的事件（比如：连接打开，数据到达）。因此，单个线程可以监听多个数据通道。

NIO和传统IO（一下简称IO）之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。

IO的各种流是阻塞的。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。 NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。

NIO优点：

1、通过Channel注册到Selector上的状态来实现一种客户端与服务端的通信。

2、Channel中数据的读取是通过Buffer , 一种非阻塞的读取方式。

3、Selector 多路复用器单线程模型，线程的资源开销相对比较小。

NIO缺点：

1. API使用复杂。

2. 需要具备一些多线程编码能力

3. 断线重连问题比较严重

4. NIO还有一些BUG

Channel(通道)

传统IO操作对read()或write()方法的调用，可能会因为没有数据可读/可写而阻塞，直到有数据响应。也就是说读写数据的IO调用，可能会无限期的阻塞等待，效率依赖网络传输的速度。最重要的是在调用一个方法前，无法知道是否会被阻塞。

NIO的Channel抽象了一个重要特征就是可以通过配置它的阻塞行为，来实现非阻塞式的通道。

Channel是一个双向通道，与传统IO操作只允许单向的读写不同的是，NIO的Channel允许在一个通道上进行读和写的操作。

FileChannel:文件

SocketChannel:

ServerSocketChannel:

DatagramChannel: UDP

Buffer(缓冲区)

Bufer顾名思义，它是一个缓冲区，实际上是一个容器，一个连续数组。Channel提供从文件、网络读取数据的渠道，但是读写的数据都必须经过Buffer。

Buffer缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该模块内存。为了理解Buffer的工作原理，需要熟悉它的三个属性：capacity、position和limit。

属性：capacity、position和limit。

position和limit的含义取决于Buffer处在读模式还是写模式。不管Buffer处在什么模式，capacity的含义总是一样的。见下图：

capacity：作为一个内存块，Buffer有固定的大小值，也叫作“capacity”，只能往其中写入capacity个byte、long、char等类型。一旦Buffer满了，需要将其清空（通过读数据或者清楚数据）才能继续写数据。

position：当你写数据到Buffer中时，position表示当前的位置。初始的position值为0，当写入一个字节数据到Buffer中后，position会向前移动到下一个可插入数据的Buffer单元。position最大可为capacity-1。当读取数据时，也是从某个特定位置读，将Buffer从写模式切换到读模式，position会被重置为0。当从Buffer的position处读取一个字节数据后，position向前移动到下一个可读的位置。

limit：在写模式下，Buffer的limit表示你最多能往Buffer里写多少数据。写模式下，limit等于Buffer的capacity。当切换Buffer到读模式时， limit表示你最多能读到多少数据。因此，当切换Buffer到读模式时，limit会被设置成写模式下的position值。换句话说，你能读到之前写入的所有数据（limit被设置成已写数据的数量，这个值在写模式下就是position）

Buffer的分配：对Buffer对象的操作必须首先进行分配，Buffer提供一个allocate(int capacity)方法分配一个指定字节大小的对象。

向Buffer中写数据：写数据到Buffer中有两种方式：

1、从channel写到Buffer

int bytes = channel.read(buf); //将channel中的数据读取到buf中

2、通过Buffer的put()方法写到Buffer

buf.put(byte); //将数据通过put()方法写入到buf中

flip()方法：将Buffer从写模式切换到读模式，调用flip()方法会将position设置为0，并将limit设置为之前的position的值。

从Buffer中读数据：从Buffer中读数据有两种方式：

1、从Buffer读取数据到Channel

int bytes = channel.write(buf); //将buf中的数据读取到channel中

2、通过Buffer的get()方法读取数据

byte bt = buf.get(); //从buf中读取一个byte

rewind()方法：Buffer.rewind()方法将position设置为0，使得可以重读Buffer中的所有数据，limit保持不变。Buffer中的数据，读取完成后，依然保存在Buffer中，可以重复读取。

clear()与compact()方法：一旦读完Buffer中的数据，需要让Buffer准备好再次被写入，可以通过clear()或compact()方法完成。如果调用的是clear()方法，position将被设置为0，limit设置为capacity的值。但是Buffer并未被清空，只是通过这些标记告诉我们可以从哪里开始往Buffer中写入多少数据。如果Buffer中还有一些未读的数据，调用clear()方法将被"遗忘 "。compact()方法将所有未读的数据拷贝到Buffer起始处，然后将position设置到最后一个未读元素的后面，limit属性依然设置为capacity。可以使得Buffer中的未读数据还可以在后续中被使用。

mark()与reset()方法：通过调用Buffer.mark()方法可以标记一个特定的position，之后可以通过调用Buffer.reset()恢复到这个position上。

Selector(多路复用器)

Selector与Channel是相互配合使用的，将Channel注册在Selector上之后，才可以正确的使用Selector，但此时Channel必须为非阻塞模式。Selector可以监听Channel的四种状态（Connect、Accept、Read、Write），当监听到某一Channel的某个状态时，才允许对Channel进行相应的操作。

Connect：某一个客户端连接成功后

Accept：准备好进行连接

Read:可读

Write:可写

4、NIO示例：

服务端：

MultiplexerTimeServer.java

  1 package com.studyio.demo3;
  2 
  3 import java.io.IOException;
  4 import java.net.InetSocketAddress;
  5 import java.nio.ByteBuffer;
  6 import java.nio.channels.SelectionKey;
  7 import java.nio.channels.Selector;
  8 import java.nio.channels.ServerSocketChannel;
  9 import java.nio.channels.SocketChannel;
 10 import java.util.Date;
 11 import java.util.Iterator;
 12 import java.util.Set;
 13 
 14 /**
 15  * 
 16  * @author lgs
 17  * 
 18  * 
 19  */
 20 public class MultiplexerTimeServer implements Runnable {
 21 
 22     private Selector selector;
 23     private ServerSocketChannel serverChannel;
 24     private volatile boolean stop;
 25     
 26     public MultiplexerTimeServer(int port) {
 27         try {
 28             //打开服务端的一个通道channel：ServerSocketChannel
 29             serverChannel = ServerSocketChannel.open();
 30             //把服务端的通道设置为非阻塞模式
 31             serverChannel.configureBlocking(false);
 32             //绑定监听的端口地址
 33             serverChannel.socket().bind(new InetSocketAddress(port), 1024);
 34             //创建Selector(多路复用器)线程
 35             selector = Selector.open();
 36             //将服务端通道ServerSocketChannel注册到Selector，交给Selector监听,告诉客户端服务端是可以连接的了
 37             serverChannel.register(selector, SelectionKey.OP_ACCEPT);
 38             System.out.println("The time server is start in port:"+port);
 39         } catch (Exception e) {
 40             e.printStackTrace();
 41             System.exit(1);
 42         }
 43     }
 44 
 45     public void stop(){
 46         this.stop = true;
 47     }
 48     @Override
 49     public void run() {
 50         //处理客户端消息
 51         while(!stop){
 52             try {
 53                 //通过Selector循环准备就绪的Key,这个key指的是客户端的通道
 54                 selector.select();
 55                 //拿到key以后把key放入迭代器iterator
 56                 Set<SelectionKey> selectionKeys = selector.selectedKeys();
 57                 Iterator<SelectionKey> iterator = selectionKeys.iterator();
 58                 SelectionKey selectionKey = null;
 59                 while(iterator.hasNext()){
 60                     selectionKey = iterator.next();
 61                     //取到key以后就移出，避免重复取
 62                     iterator.remove();
 63                     try {
 64                         //处理客户端传递过来的数据
 65                         handleInput(selectionKey);
 66                     } catch (Exception e) {
 67                         if(selectionKey!=null){
 68                             selectionKey.cancel();
 69                             if(selectionKey.channel()!=null){
 70                                 selectionKey.channel().close();
 71                             }
 72                         }
 73                     }
 74                 }
 75             } catch (Exception e) {
 76                 e.printStackTrace();
 77             }
 78         }
 79         if(selector !=null){
 80             try {
 81                 selector.close();
 82             } catch (IOException e) {
 83                 e.printStackTrace();
 84             }
 85         }
 86     }
 87 
 88     /**
 89      * 处理客户端传递过来的数据
 90      * @param selectionKey
 91      * @throws IOException
 92      */
 93     private void handleInput(SelectionKey selectionKey) throws IOException {
 94         if(selectionKey.isValid()){
 95             //客户端是可连接的
 96             if (selectionKey.isAcceptable()) {
 97                 ServerSocketChannel server = (ServerSocketChannel) selectionKey.channel();
 98                 //多路复用器监听到新的客户端连接，处理连接请求，完成TCP三次握手。
 99                 SocketChannel client = server.accept();
100                 //设置为非阻塞模式
101                 client.configureBlocking(false);
102                 // 将新连接注册到多路复用器上，监听其读操作，读取客户端发送的消息。
103                 client.register(selector, SelectionKey.OP_READ);
104             }
105             //客户端是可读的
106             if(selectionKey.isReadable()){
107                 //获取取客户端的通道
108                 SocketChannel client = (SocketChannel) selectionKey.channel();
109                 ByteBuffer receivebuffer = ByteBuffer.allocate(1024);
110                 //读取客户端请求消息到缓冲区
111                 int count = client.read(receivebuffer);   //非阻塞    
112                 if (count > 0) {
113                     receivebuffer.flip();
114                     byte[] bytes = new byte[receivebuffer.remaining()]; //remaining()方法
115                     //从缓冲区读取消息到bytes数组里面
116                     receivebuffer.get(bytes);
117                     String body = new String(bytes, "UTF-8");
118                     System.out.println("The time server(Thread:"+Thread.currentThread()+") receive order : "+body);
119                     //将currentTime响应给客户端（客户端Channel）
120                     String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new Date(System.currentTimeMillis()).toString() : "BAD ORDER";
121                     //服务端向客户端响应数据,通过客户端的通道传递数据
122                     doWrite(client, currentTime);
123                 }else if(count < 0){
124                     selectionKey.channel();
125                     client.close();
126                 }else{
127                     
128                 }
129             }
130         }
131     }
132 
133     /**
134      * 服务端向客户端响应数据,通过客户端的通道传递数据
135      * @param client
136      * @param currentTime
137      * @throws IOException
138      */
139     private void doWrite(SocketChannel client, String currentTime) throws IOException {
140         if(currentTime != null && currentTime.trim().length()>0){
141             ByteBuffer sendbuffer = ByteBuffer.allocate(1024);
142             sendbuffer.put(currentTime.getBytes());
143             sendbuffer.flip();
144             //将客户端响应消息写入到客户端Channel中。
145             client.write(sendbuffer);
146             System.out.println("服务器端向客户端发送数据--：" + currentTime);
147         }else{
148             System.out.println("没有数据");
149         }
150     }
151 
152 }

服务端入口程序TimeServer.java

public class TimeServer {

    public static void main(String[] args) {
        int port=8080; //服务端默认端口
        MultiplexerTimeServer timeServer=new MultiplexerTimeServer(port);
        new Thread(timeServer, "NIO-MultiplexerTimeServer-001").start();
    }
}

客户端：

TimeClientHandler.java

  1 package com.studyio.demo3;
  2 
  3 import java.io.IOException;
  4 import java.net.InetSocketAddress;
  5 import java.nio.ByteBuffer;
  6 import java.nio.channels.SelectionKey;
  7 import java.nio.channels.Selector;
  8 import java.nio.channels.SocketChannel;
  9 import java.util.Iterator;
 10 import java.util.Set;
 11 
 12 /**
 13  * 
 14  * @author lgs
 15  * 
 16  */
 17 public class TimeClientHandler implements Runnable {
 18     
 19     private String host;
 20     private int port;
 21     private SocketChannel socketChannel;
 22     private Selector selector;
 23     private volatile boolean stop;
 24     
 25     public TimeClientHandler(String host, int port) {
 26         this.host = host;
 27         this.port = port;
 28         try {
 29             //客户端打开一个通道SocketChannel
 30             socketChannel = SocketChannel.open();
 31             //创建Selector(多路复用器)线程
 32             selector = Selector.open();
 33             //设置为非阻塞模式
 34             socketChannel.configureBlocking(false);
 35         } catch (Exception e) {
 36             e.printStackTrace();
 37             System.exit(1);
 38         }
 39     }
 40 
 41     @Override
 42     public void run() {
 43         try {
 44             //连接服务端并发送数据
 45             doConnect();
 46         } catch (Exception e) {
 47             e.printStackTrace();
 48             System.exit(1);
 49         }
 50         //处理服务端响应的数据,和服务端处理客户端发送的数据一样
 51         while(!stop){
 52             //轮训通道的状态
 53             try {
 54                 selector.select(1000);
 55                 Set<SelectionKey> selectionKeys = selector.selectedKeys();
 56                 Iterator<SelectionKey> iterator = selectionKeys.iterator();
 57                 SelectionKey selectionKey = null;
 58                 while(iterator.hasNext()){
 59                     selectionKey = iterator.next();
 60                     //取到key以后就移出，避免重复取
 61                     iterator.remove();
 62                     try {
 63                         //处理服务端响应的数据
 64                         handleInput(selectionKey);
 65                     } catch (Exception e) {
 66                         if(selectionKey!=null){
 67                             selectionKey.cancel();
 68                             if(selectionKey.channel()!=null){
 69                                 selectionKey.channel().close();
 70                             }
 71                         }
 72                     }
 73                 }
 74             } catch (Exception e) {
 75                 e.printStackTrace();
 76                 System.exit(1);
 77             }
 78         }
 79         if(selector !=null){
 80             try {
 81                 selector.close();
 82             } catch (IOException e) {
 83                 e.printStackTrace();
 84             }
 85         }
 86     }
 87 
 88     /**
 89      * 处理服务端响应的数据
 90      * @param selectionKey
 91      * @throws Exception
 92      */
 93     private void handleInput(SelectionKey selectionKey) throws Exception {
 94         if(selectionKey.isValid()){
 95             SocketChannel client = (SocketChannel) selectionKey.channel();
 96             if (selectionKey.isConnectable()){
 97                 if(client.finishConnect()){
 98                     client.register(selector, SelectionKey.OP_READ);
 99                     doWrite(client);
100                 }else{
101                     System.exit(1);
102                 }
103             }
104             if (selectionKey.isReadable()) {
105                 ByteBuffer receivebuffer = ByteBuffer.allocate(1024);
106                 int count = client.read(receivebuffer);
107                 if (count > 0) {
108                     receivebuffer.flip();
109                     byte[] bytes = new byte[receivebuffer.remaining()]; //remaining()方法
110                     receivebuffer.get(bytes);
111                     String body = new String(bytes, "UTF-8");
112                     System.out.println("Now is "+body);
113                     this.stop = true;
114                 }else if(count < 0){
115                     selectionKey.channel();
116                     client.close();
117                 }else{
118                     
119                 }
120             }
121         }
122     }
123 
124     /**
125      * 连接服务端并发送数据
126      * @throws Exception
127      */
128     private void doConnect() throws Exception {
129         //连接服务端
130         boolean connect = socketChannel.connect(new InetSocketAddress(host, port));
131         //判断是否连接成功，如果连接成功，则监听Channel的读状态。
132         if(connect){
133             //连接成功就把客户端的通道注册到多路复用器上，并设置通道状态为可读
134             socketChannel.register(selector, SelectionKey.OP_READ);
135             //写数据  写给服务端
136             doWrite(socketChannel);
137         }else{
138             //如果没有连接成功，则向多路复用器注册Connect(可连接)状态
139             socketChannel.register(selector, SelectionKey.OP_CONNECT);
140         }
141         
142     }
143 
144     /**
145      * 写数据  写给服务端
146      * @param channel
147      * @throws IOException
148      */
149     private void doWrite(SocketChannel channel) throws IOException {
150         ByteBuffer sendbuffer = ByteBuffer.allocate(1024);
151         sendbuffer.put("QUERY TIME ORDER".getBytes());
152         sendbuffer.flip();
153         //向Channel中写入客户端的请求指令  写到服务端 写到通道里面
154         channel.write(sendbuffer);
155         if(!sendbuffer.hasRemaining()){
156             System.out.println("Send order to server succeed.");
157         }
158     }
159 }

客户端程序入口：TimeServerClient.java

public class TimeServerClient {
    
    public static void main(String[] args) {
        int port=8080; //服务端默认端口
        new Thread(new TimeClientHandler("127.0.0.1", port), "NIO-TimeServerClient-001").start();
    }
}

posted @ 2018-03-21 12:42 小不点啊阅读(1100) 评论(0) 编辑收藏举报

刷新页面返回顶部

小不点啊