JAVA NIO

2018-09-14  本文已影响13人  云师兄

引子

在学习一个新东西之前，都需要先知道为什么需要这个东西。NIO也是如此，它和之前的IO有什么区别，为了加深理解，我先从NIO涉及到的网络方面来切入学习。

java 网络基础知识

java传统的网络通信分为客户端程序和服务端程序两个部分。
客户端程序大致步骤为：

Socket socket = new Socket(...); // 打开套接字， 负责进行网络通信
InputStream is = socket.getInputStream(); // 获取流
in.nextLine(); // 读取数据

服务端程序大致步骤为：

ServerSocket serverSocket = new ServerSocket(...); // 创建服务端套接字
Socket incoming = serverSocket.accept(...); // 监听端口，等待客户端连接
InputStream inputStream = incoming.getInputStream();  // 获取流
// 处理逻辑，返回数据给客户端...

服务端这种写法的问题在于使用ServerSocket的accept()方法时会导致当前线程阻塞，而且，getInputStream()读方法同样也会导致线程阻塞。只能支持一个客户端连接服务器，为了支持多个客户端同时连接服务器，需要修改服务端程序如下：

while(true){
  Socket income =s .accpet(); // 等待连接
  Thread t = new Thread(...); // 创建线程，将accept后的socket实例在线程内部进行相关的逻辑处理
  t.start(); // 启动线程
}

这样写的好处在于，监听到一个新的客户端连接后，就创建一个新的线程，在新的线程内部进行读写操作，这样就不会阻塞其他线程，就不会因为当前线程的读写操作影响到客户端的连接了。当然，accpet方法导致的阻塞问题还是没有解决，所以还是不能满足高性能服务器的要求，为实现服务器更高的吞吐量，我们需要学习java的NIO。事实上，说到这才刚开始引出我今天要分享的主题:NIO。

NIO

NIO中涉及一些新的概念，上网阅读了一些文章帮助理解，发现有篇文章写得挺好，分享一下：
http://www.iteye.com/magazines/132-Java-NIO，有需要可以先读一下这篇文章：

Java NIO 核心部分如下：

刚开始学，我就简单的把Channels理解为连接，对标Socket；把Buffers理解为缓冲区，是InputStream流和OutInputStream的集合，所以网络数据传输就是Channels和Buffers之间的数据传递。


channel-buffer

Channel和Buffer有好几种类型。下面是JAVA NIO中的一些主要Channel的实现：

Selector允许单线程处理多个 Channel,这是在一个单线程中使用一个Selector处理3个Channel的图示：


捕获.PNG

要使用Selector，得向Selector注册Channel，然后调用它的select()方法。这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回，线程就可以处理这些事件，事件的例子有如新连接进来，数据接收等。

NIO和IO的区别

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

SocketChannel

SocketChannel是Channel的一种，本篇文章主要也是要讨论网络中涉及到的NIO，所以接下来来着重讨论下SocketChannel。下面部分内容参考https://blog.csdn.net/u011381576/article/details/79876754这篇文章，有需要的同学也可以看下这篇问题。
NIO的channel抽象的一个重要特征就是可以通过配置它的阻塞行为，以实现非阻塞式的信道。

 channel.configureBlocking(false)

在非阻塞式信道上调用一个方法总是会立即返回。这种调用的返回值指示了所请求的操作完成的程度。例如，在一个非阻塞式ServerSocketChannel上调用accept()方法，如果有连接请求来了，则返回客户端SocketChannel，否则返回null。
使用了SocketChannel后，客户端程序可以写作如下：

        ByteBuffer buffer = ByteBuffer.allocate(1024);
        SocketChannel socketChannel = null;
        socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);
        socketChannel.connect(new InetSocketAddress("10.10.195.115",8080));
        if(socketChannel.finishConnect())
        {
           int i=0;
           while(true)
           {
                    TimeUnit.SECONDS.sleep(1);
                    String info = "I'm "+i+++"-th information from client";
                    buffer.clear();
                    buffer.put(info.getBytes());
                    buffer.flip();
                    while(buffer.hasRemaining()){
                        System.out.println(buffer);
                        socketChannel.write(buffer);
                    }
                }
            }

            if(socketChannel!=null){
                socketChannel.close();
            }
      }

服务端程序用到了selector选择器，代码如下：

public class ServerConnect
{
    private static final int BUF_SIZE=1024;
    private static final int PORT = 8080;
    private static final int TIMEOUT = 3000;
    public static void main(String[] args)
    {
        selector();
    }
    public static void selector() {
        Selector selector = null;
        ServerSocketChannel ssc = null;
        try{
            selector = Selector.open();
            ssc= ServerSocketChannel.open();
            ssc.socket().bind(new InetSocketAddress(PORT));
            ssc.configureBlocking(false);
            ssc.register(selector, SelectionKey.OP_ACCEPT);
            while(true){
                if(selector.select(TIMEOUT) == 0){
                    System.out.println("==");
                    continue;
                }
                Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
                while(iter.hasNext()){
                    SelectionKey key = iter.next();
                    if(key.isAcceptable()){
                        handleAccept(key);
                    }
                    if(key.isReadable()){
                        handleRead(key);
                    }
                    if(key.isWritable() && key.isValid()){
                        handleWrite(key);
                    }
                    if(key.isConnectable()){
                        System.out.println("isConnectable = true");
                    }
                    iter.remove();
                }
            }
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            try{
                if(selector!=null){
                    selector.close();
                }
                if(ssc!=null){
                    ssc.close();
                }
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }
    public static void handleAccept(SelectionKey key) throws IOException{
        ServerSocketChannel ssChannel = (ServerSocketChannel)key.channel();
        SocketChannel sc = ssChannel.accept();
        sc.configureBlocking(false);
        sc.register(key.selector(), SelectionKey.OP_READ,ByteBuffer.allocateDirect(BUF_SIZE));
    }
    public static void handleRead(SelectionKey key) throws IOException{
        SocketChannel sc = (SocketChannel)key.channel();
        ByteBuffer buf = (ByteBuffer)key.attachment();
        long bytesRead = sc.read(buf);
        while(bytesRead>0){
            buf.flip();
            while(buf.hasRemaining()){
                System.out.print((char)buf.get());
            }
            System.out.println();
            buf.clear();
            bytesRead = sc.read(buf);
        }
        if(bytesRead == -1){
            sc.close();
        }
    }
    public static void handleWrite(SelectionKey key) throws IOException{
        ByteBuffer buf = (ByteBuffer)key.attachment();
        buf.flip();
        SocketChannel sc = (SocketChannel) key.channel();
        while(buf.hasRemaining()){
            sc.write(buf);
        }
        buf.compact();
    }
}

注意：

  1. ServerSocketChannel可以设置成非阻塞模式。在非阻塞模式下，accept() 方法会立刻返回，如果还没有新进来的连接,返回的将是null。 因此，需要检查返回的SocketChannel是否是null。

Selector

Selector的创建：

Selector selector = Selector.open();

为了将Channel和Selector配合使用，必须将Channel注册到Selector上，通过

SelectableChannel.register() //SelectableChannel是ServerSocketChannel的父类

方法来实现。
与Selector一起使用时，Channel必须处于非阻塞模式下。这意味着不能将FileChannel与Selector一起使用，因为FileChannel不能切换到非阻塞模式。而套接字通道都可以。
register()方法的第二个参数。这是一个“interest集合”，意思是在通过Selector监听Channel时对什么事件感兴趣。可以监听四种不同类型的事件：Connect，Accept， Read，Write。通道触发了一个事件意思是该事件已经就绪。所以，某个channel成功连接到另一个服务器称为“连接就绪”。一个server socket channel准备好接收新进入的连接称为“接收就绪”。一个有数据可读的通道可以说是“读就绪”。等待写数据的通道可以说是“写就绪”。这四种事件用SelectionKey的四个常量来表示：

1. SelectionKey.OP_CONNECT
2. SelectionKey.OP_ACCEPT
3. SelectionKey.OP_READ
4. SelectionKey.OP_WRITE

SelectionKey

当向Selector注册Channel时，register()方法会返回一个SelectionKey对象。这个对象包含了一些你感兴趣的属性：

int readySet = selectionKey.readyOps();

可以用像检测interest集合那样的方法，来检测channel中什么事件或操作已经就绪。但是，也可以使用以下四个方法，它们都会返回一个布尔类型：

selectionKey.isAcceptable();
selectionKey.isConnectable();
selectionKey.isReadable();
selectionKey.isWritable();

从SelectionKey访问Channel和Selector很简单。如下：

Channel  channel  = selectionKey.channel();
Selector selector = selectionKey.selector();

通过Selector选择通道

一旦向Selector注册了一或多个通道，就可以调用几个重载的select()方法。这些方法返回你所感兴趣的事件（如连接、接受、读或写）已经准备就绪的那些通道。换句话说，如果你对“读就绪”的通道感兴趣，select()方法会返回读事件已经就绪的那些通道。

下面是select()方法：

int select()
int select(long timeout)
int selectNow()

select()阻塞到至少有一个通道在你注册的事件上就绪了。
select(long timeout)和select()一样，除了最长会阻塞timeout毫秒(参数)。
selectNow()不会阻塞，不管什么通道就绪都立刻返回（译者注：此方法执行非阻塞的选择操作。如果自从前一次选择操作后，没有通道变成可选择的，则此方法直接返回零。）。
select()方法返回的int值表示有多少通道已经就绪。亦即，自上次调用select()方法后有多少通道变成就绪状态。如果调用select()方法，因为有一个通道变成就绪状态，返回了1，若再次调用select()方法，如果另一个通道就绪了，它会再次返回1。如果对第一个就绪的channel没有做任何操作，现在就有两个就绪的通道，但在每次select()方法调用之间，只有一个通道就绪了。
一旦调用了select()方法，并且返回值表明有一个或更多个通道就绪了，然后可以通过调用selector的selectedKeys()方法，访问“已选择键集（selected key set）”中的就绪通道。如下所示：

Set selectedKeys = selector.selectedKeys();

当向Selector注册Channel时，Channel.register()方法会返回一个SelectionKey 对象。这个对象代表了注册到该Selector的通道。
注意每次迭代末尾的keyIterator.remove()调用。Selector不会自己从已选择键集中移除SelectionKey实例。必须在处理完通道时自己移除。下次该通道变成就绪时，Selector会再次将其放入已选择键集中。
SelectionKey.channel()方法返回的通道需要转型成你要处理的类型，如ServerSocketChannel或SocketChannel等。

上一篇 下一篇

猜你喜欢

热点阅读