NIO AIO

最新推荐文章于 2022-04-30 21:31:03 发布

qq_22895415

最新推荐文章于 2022-04-30 21:31:03 发布

阅读量116

点赞数

分类专栏：并发

本文链接：https://blog.csdn.net/qq_22895415/article/details/86085747

版权

并发专栏收录该内容

3 篇文章 0 订阅

订阅专栏

NIO-非阻塞IO，AIO-异步IO，NIO由JDK1.4引入，AIO由JDK1.7引入。

NIO主要解决普通IO中的性能瓶颈，比如当accept()的阻塞操作返回时，数据可能并没有传输过来，也就是readable()状态为false,此时我们负责处理的线程只能阻塞来等待这个数据。同理，写入状态也需要等待，这是不值得的。

AIO不需要等待任务完成就可以返回，之后可以通过回调函数或者future对象来获取结果，AIO可以控制线程数量，减少过多的线程带来的内存消耗和CPU调度的开销。

阻塞IO

我们可以使用NIO三个组件来构成一个简单的客户端，网络端的通信例子：

public class Server {
	public static void main(String[] args) throws IOException {
		ServerSocketChannel ssc = ServerSocketChannel.open();
		ssc.socket().bind(new InetSocketAddress(8080));
		while (true) {
			//阻塞，直到有一个连接进来
			SocketChannel sc = ssc.accept();
			//开启线程处理，在while循环中监听8080
			SocketHander handler = new SocketHander(socketChannel);//本质是一个线程，后面单独说这个类
			new Thread(handler).start();
		}
	}
}

关于SocketHandler：

public class SocketHandler implements Runnable {
	
	private SocketChannel sc;

	public SocketHandler(SocketChannel sc) {
		this.sc = sc;
	}
	
	@override
	public void run() {
		ByteBuffer buffer = ByteBuffer.allocate(1024);
		try {
			int num;
			while ((num = sc.read(buffer)) > 0) {
				//读取buffer
				buffer.filp();
				byte[] bytes = new byte[num];
				buffer.get(bytes);
				String res = new String(bytes, "UTF-8");
				System.out.println("received:" + res);
				//回复
				ByteBuffer writeBuffer = ByteBuffer.wrap("Received data. Your request data is :" + res);
				buffer.clear();
			}
		} catch(IOException e) {
			IOUtils.closeQuietly(sc);
		}
	}
}

客户端调用：

public class SocketChannelTest {
	public static void main(String[] args) throws IOException {
	SocketChannel sc = SocketChannel.open(new InetSocketAddress("localhost", 8080));
	//发送请求
	ByteBuffer buffer = ByteBuffer.wrap("12345".getBytes());
	sc.write(buffer);
	//读取响应
	ByteBuffer readBuffer = ByteBuffer.allocate(1024);
	int num;
	while (num = sc.read(readBuffer)) > 0) {
			readBuffer.flip();
			byte[] re = new byte[num];
			readBuffer.get(re);
			String result = new String(re, "UTF-8");
			System.out.println("Return data:" + result);
		}
	}
}

非阻塞IO

由于阻塞模式有诸多缺点，所以引入了NIO。NIO的核心在于使用一个Selector来管理多个通道，可以是SocketChannel，也可以是ServerSocketChannel。将各个通道注册到Selector上，指定监听的事件。
可以说对比传统IO，NIO对于一个新连接不再新开一个线程，而是通过轮询多路复用器来绑定多个连接，读写都由它来完成。

NIO中selector是对底层操作系统实现的一个抽象，管理通道状态每个底层系统的实现都不同。

NIO面向Selector编程实例代码：（客户端同上）

public class SelectorServer {
	public static void main(String[] args) {
		Selector selector = Selector.open();
		ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.socket().bind(new InetSocketAddress(8080));
		//注册到selector中监听OP_ACCEPT事件
		ssc.configureBlocking(false);
		ssc.register(selector, SelectionKey.OP_ACCEPT);
		
		while (true) {
			int readyChannelNum = selector.select();
			if (readyChannelNum == 0) {
				continue;
			}
			Set<SelectionKey> readyKeys = selector.selectedKeys();
			Iterator<SelectionKey> iterator = readyKeys.iterator();
			while (iterator.hasNext()) {
				SelectionKey key = iterator.next();
				iterator.remove();
				if (key.isAcceptable()) {
					SocketChannel sc = ssc.accept();
					//由于有连接不代表有数据，所以将channel注册到selector监听OP_READ事件
					sc.configureBlocking(false);
					sc.register(selector, SelectionKey.OP_READ);
				} else if (key.isReadable()) {
					//有数据可读，因为在上一个分支中注册了socketChannel,直接从key中拿出
					SocketChannel sc = (SocketChannel) key.channel();
					ByteBuffer readBuffer = ByteBuffer.allocate(1024);
					int num = sc.read(readBuffer);
					if (num > 0) {
						System.out.println("Received Data: " + new String(readBuffer.array()).trim());
						ByteBuffer buffer = ByteBuffer.wrap("Return data to client... ".getBytes());
						sc.write(buffer);
					} else if (num == -1) {
						socketChannel.close();
					}
				}
			}
		}
	}
}

在NIO模型中，一个连接来了后，直接注册到selector上，通过检查selector，就可以批量检测出可以读取（readable）的连接，进而读取数据。实际开发过程中，每一个线程对应着一批连接，相比传统IO一个线程对应一个连接的情况，消耗的线程资源大幅降低；同时因为大大削减了线程的数量，线程切换的消耗也大幅降低。

同时，IO模型读写单位是字节，每次从操作系统底层一个字节一个字节的读取，而NIO维护的是一个buffer，buffer有一个容量，相当于一个字节块，这样效率会更高。

对照代码，整理一下NIO的思路：

NIO模型中通常两个线程，每个线程绑定一个Selector。例子中服务器selector 负责轮询是否有新连接。
服务端检测到连接后，不再新建一个新的线程，而是直接将连接绑定到selector上，这样不会出现多线程自旋的情况。
selector通过while自旋，如果有多条连接建立，selector.select()方法可以轮询出来建立channel，等待数据可读取的时候处理。
数据的读取，以buffer为单位。

总结：NIO编程复杂，不友好，需要自己实现线程模型，功能复杂的NIO模型bug几率飙升，难以debug.

AIO

在jdk1.7中称为NIO.2，java中的AIO是由一个线程池负责执行任务，然后回调或者自己查询结果，控制线程数量，减少过多的线程带来的内存消耗和CPU在线程调度上的开销。

AIO适合IO操作时间重量级的情况。

AIO一共三个类需要关注，分别是AsynchronousSocketChannel、AsynchronousServerSocketChannel和AsynchronousFileChannel。显然是在之前三种channel上加了Asynchronous前缀。（还有DatagramChannel）

AIO也提供了回调和Future实例的使用方式。

返回Future实例

JDK线程池就是这么使用的，Future接口的语义也是通用的。

future.isDone() - 判断操作是否完成，包括正常完成、异常抛出、取消
future.cancel(true) - 取消操作，方式是中断。参数true说的是，即使任务在执行，也会进行中断。
future.isCancelled() - 是否被取消，只有在任务正常结束之前被取消，才会返回true.
future.get() - 获取执行结果，是阻塞的。
future.get(10, TimeUnit.SECONDS) - 上一个方法默认执行0，设置阻塞的超时时间。

回调函数

提供java.nio.channels.CompletionHandler接口。它定义了两个方法，分别在异步操作成功和失败时回调：

public interface CompletionHandler<V,A> {
	void completed(V result, A attachment);	
	void failed(Throwable exc, A attachment);
}

使用例子：

AsynchronousServerSocketChannel listener = AsynchronousServerSocketChannel.open().bind(null);

//可以传递Attachment
listener.accpet(attachment, new CompletionHandler<AsynchronousSocketChannel, Object>(){
	public void completed(AsynchronousSocketChannel client, Object attachment) {
	//操作成功
	}
	public void failed(Throwable exc, Object attachemnt) {
	//操作失败
	}
});

Asynchronous IO

异步文件IO AsynchronousFileChannel

文件IO不支持非阻塞，但是可以采用异步的方式提高性能。

实例化：

AsynchronousFileChannel channel = AsynchronousFileChannel.open(Paths.get("path"));

read()方法:

public abstract Future<Integer> read(ByteBuffer dst, long position);
public abstract <A> void read(ByteBuffer dst, long position, A attachemnt, CompletionHandler<Integer, ? super A> handler);

write()方法：

public abstract Future<Integer> write(ByteBuffer src, long position);
public abstract <A> write(ByteBuffer src, long position, A attachment, CompletionHandler<Integer, ? super A> handler);

AIO文件读写都需要一个文件的开始位置，开始位置为0；
AIO读写也是与Buffer打交道

锁定：

public abstract Future<FileLock> lock(long position, long size, boolean shared);
public abstract <A> void lock(long position, long size, boolean shared, A attachment, CompletionHandler<FileLock, ? super A> handler);

锁定文件部分数据以进行排他性操作，pos指定起始位置，size指定锁定区域大小，shared指定需要共享锁还是排它锁。

尝试获取锁：

public abstract FileLock tryLock(long position, long size, boolean shared) throws IOException;

如果被锁住，立刻返回null，否则返回FileLock对象。

force():立即将数据刷入磁盘，参数设置为true代表将属性信息也更新到磁盘。

public abstract void force(boolean metaData) throws IOException;

AsynchronousServerSocketChannel

服务端代码（回调函数）：

public class SscExample {

    public static void main(String[] args) throws IOException {
        AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open()
                .bind(new InetSocketAddress("localhost", 8080));
        Attachment att = new Attachment();
        att.setServer(server);

        server.accept(att, new CompletionHandler<AsynchronousSocketChannel, Attachment>() {
            @Override
            public void completed(AsynchronousSocketChannel client, Attachment attachment) {
                try {
                    SocketAddress clientAddr = client.getRemoteAddress();
                    System.out.println("Received new connection:" + clientAddr);

                    attachment.getServer().accept(attachment, this);
                    Attachment newAtt = new Attachment();
                    newAtt.setServer(server);
                    newAtt.setClient(client);
                    newAtt.setReadMode(true);
                    newAtt.setBuffer(ByteBuffer.allocate(2048));

                    client.read(newAtt.getBuffer(), newAtt, new CompletionHandler<Integer, Attachment>() {
                        @Override
                        public void completed(Integer result, Attachment attachment) {
                            if (attachment.isReadMode()) {
                                ByteBuffer buffer = attachment.getBuffer();
                                buffer.flip();
                                byte bytes[] = new byte[buffer.limit()];
                                buffer.get(bytes);
                                String msg = new String(buffer.array()).trim();
                                System.out.println("Received data from client: " + msg);

                                buffer.clear();
                                buffer.put("Response from server!".getBytes(Charset.forName("UTF-8")));
                                attachment.setReadMode(false);
                                buffer.flip();
                                attachment.getClient().write(buffer, attachment, this);
                            } else {
                                try {
                                    attachment.getClient().close();
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                        }

                        @Override
                        public void failed(Throwable exc, Attachment attachment) {
                            System.out.println("Connection disconnected");
                        }
                    });
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void failed(Throwable exc, Attachment attachment) {
                System.out.println("accept failed");
            }
        });
        try {
            Thread.currentThread().join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

自定义Attachment类：

public class Attachment {
        private AsynchronousServerSocketChannel server;
        private AsynchronousSocketChannel client;
        private boolean readMode;
        private ByteBuffer buffer;

        public AsynchronousServerSocketChannel getServer() {
            return server;
        }

        public void setServer(AsynchronousServerSocketChannel server) {
            this.server = server;
        }

        public AsynchronousSocketChannel getClient() {
            return client;
        }

        public void setClient(AsynchronousSocketChannel client) {
            this.client = client;
        }

        public boolean isReadMode() {
            return readMode;
        }

        public void setReadMode(boolean readMode) {
            this.readMode = readMode;
        }

        public ByteBuffer getBuffer() {
            return buffer;
        }

        public void setBuffer(ByteBuffer buffer) {
            this.buffer = buffer;
        }
    }

AsynchronousSocketChannel

客户端代码配合服务端使用：

public class ScExample {
    public static void main(String[] args) throws Exception {
        AsynchronousSocketChannel client = AsynchronousSocketChannel.open();
        Future future = client.connect(new InetSocketAddress("localhost", 8080));
        //此处阻塞等待连接成功
        future.get();

        Attachment att = new Attachment();
        att.setClient(client);
        att.setReadMode(false);
        att.setBuffer(ByteBuffer.allocate(1024));
        byte[] data = "I am a bot!".getBytes();

        att.getBuffer().put(data);
        att.getBuffer().flip();

        client.write(att.getBuffer(), att, new CompletionHandler<Integer, Attachment>() {
            @Override
            public void completed(Integer result, Attachment attachment) {
                ByteBuffer buffer = attachment.getBuffer();
                if (attachment.isReadMode()) {
                    buffer.flip();
                    byte[] bytes = new byte[buffer.limit()];
                    buffer.get(bytes);
                    String msg = new String(bytes, Charset.forName("UTF-8"));
                    System.out.println("Received data form server: " + msg);
                    try {
                        attachment.getClient().close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                } else {
                    attachment.setReadMode(true);
                    buffer.clear();
                    attachment.getClient().read(buffer, attachment, this);
                }
            }

            @Override
            public void failed(Throwable exc, Attachment attachment) {
                System.out.println("No reply from server");
            }
        });
        Thread.sleep(2000);

    }
}

Asynchronous Channel Groups

AIO 存在一个线程池，负责接受任务，处理IO事件，回调等。线程池在group内部，group一旦关闭，线程池就会关闭。

上面提到的服务端和客户端channel是属于group的，当我们调用他们的open()方法的时候，相应的channel就属于默认的group，由JVM自动构造并管理。可以通过启动参数来配置JVM的group。

如果要自定义group，可以使用以下的方法：

AsynchronousChannelGroup.withCachedThreadPool(ExecutorService executor, int initialSize)
AsynchronousChannelGroup.withFixedThreadPool(int nThreads, ThreadFactory threadFactory)
AsynchronousChannelGroup.withThreadPool(ExecutorService executor)

长得和线程池Executors静态方法很像。使用例子：

AsynchronousChannelGroup group = AsynchronousChannelGroup.withFixedThreadPool(10, Executors.defaultThreadFactory());
AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open(group);
AsynchronousSocketChannel client = AsynchronousSocketChannel.open(group);