• Java NIO理解与使用

    Netty的使用或许我们看着官网user guide还是很容易入门的。因为java nio使用非常的繁琐，netty对java nio进行了大量的封装。对于Netty的理解，我们首先需要了解NIO的原理和使用。所以，我也特别渴望去了解NIO这种通信模式。

    官方的定义是：nio 是non-blocking的简称，在jdk1.4 里提供的新api 。Sun 官方标榜的特性如下： 为所有的原始类型提供(Buffer)缓存支持。字符集编码解码解决方案。 Channel ：一个新的原始I/O 抽象。 支持锁和内存映射文件的文件访问接口。 提供多路(non-bloking) 非阻塞式的高伸缩性网络I/O 。是不是很抽象？

    在阅读《NIO入门》这篇技术文档之后，收获了很多。包括对Java NIO的理解和使用，所以也特别的感谢作者。

    首先，还是来回顾以下从这篇文档中学到的要点。

    为什么要使用 NIO?
    NIO 的创建目的是为了让 Java 程序员可以实现高速 I/O 而无需编写自定义的本机代码。NIO 将最耗时的 I/O 操作(即填充和提取缓冲区)转移回操作系统，因而可以极大地提高速度。

    NIO最重要的组成部分

    通道 Channels
    缓冲区 Buffers
    选择器 Selectors


    Buffer 是一个对象， 它包含一些要写入或者刚读出的数据。

    在 NIO 库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的。在写入数据时，它是写入到缓冲区中的。任何时候访问 NIO 中的数据，您都是将它放到缓冲区中。
    缓冲区实质上是一个数组。通常它是一个字节数组，但是也可以使用其他种类的数组。但是一个缓冲区不 仅仅 是一个数组。缓冲区提供了对数据的结构化访问，而且还可以跟踪系统的读/写进程。

    Channel是一个对象，可以通过它读取和写入数据

    看完下面这个例子，基本上就理解buffer和channel的作用了

    1. package yyf.java.nio.ibm;
    2.  
    3. import java.io.*;
    4. import java.nio.*;
    5. import java.nio.channels.*;
    6.  
    7. public class CopyFile {
    8. 	static public void main(String args[]) throws Exception {
    9.  
    10. 		String infile = "c://test/nio_copy.txt";
    11. 		String outfile = "c://test/result.txt";
    12.  
    13. 		FileInputStream fin = new FileInputStream(infile);
    14. 		FileOutputStream fout = new FileOutputStream(outfile);
    15. 		// 获取读的通道
    16. 		FileChannel fcin = fin.getChannel();
    17. 		// 获取写的通道
    18. 		FileChannel fcout = fout.getChannel();
    19. 		// 定义缓冲区，并指定大小
    20. 		ByteBuffer buffer = ByteBuffer.allocate(1024);
    21.  
    22. 		while (true) {
    23. 			// 清空缓冲区
    24. 			buffer.clear();
    25. 			//从通道读取一个数据到缓冲区
    26. 			int r = fcin.read(buffer);
    27. 			//判断是否有从通道读到数据
    28. 			if (r == -1) {
    29. 				break;
    30. 			}
    31. 			//将buffer指针指向头部
    32. 			buffer.flip();
    33. 			//把缓冲区数据写入通道
    34. 			fcout.write(buffer);
    35. 		}
    36. 	}
    37. }

    缓冲区主要是三个变量

    position
    limit
    capacity
    这三个变量一起可以跟踪缓冲区的状态和它所包含的数据。我们将在下面的小节中详细分析每一个变量，还要介绍它们如何适应典型的读/写(输入/输出)进程。在这个例子中，我们假定要将数据从一个输入通道拷贝到一个输出通道。
    Position
    您可以回想一下，缓冲区实际上就是美化了的数组。在从通道读取时，您将所读取的数据放到底层的数组中。 position 变量跟踪已经写了多少数据。更准确地说，它指定了下一个字节将放到数组的哪一个元素中。因此，如果您从通道中读三个字节到缓冲区中，那么缓冲区的 position 将会设置为3，指向数组中第四个元素。
    同样，在写入通道时，您是从缓冲区中获取数据。 position 值跟踪从缓冲区中获取了多少数据。更准确地说，它指定下一个字节来自数组的哪一个元素。因此如果从缓冲区写了5个字节到通道中，那么缓冲区的 position 将被设置为5，指向数组的第六个元素。
    Limit
    limit 变量表明还有多少数据需要取出(在从缓冲区写入通道时)，或者还有多少空间可以放入数据(在从通道读入缓冲区时)。
    position 总是小于或者等于 limit。
    Capacity
    缓冲区的 capacity 表明可以储存在缓冲区中的最大数据容量。实际上，它指定了底层数组的大小 ― 或者至少是指定了准许我们使用的底层数组的容量。
    limit 决不能大于 capacity。

    缓冲区作为一个数组，这三个变量就是其中数据的标记，也很好理解。


    Selector（选择器）是Java NIO中能够检测一到多个NIO通道，并能够知晓通道是否为诸如读写事件做好准备的组件。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接。

    接下来来看看具体的使用把，我创建了一个直接收消息的服务器（一边接收一边写数据可能对于新手不好理解）

    服务端：

    1. package yyf.java.nio.test;
    2.  
    3. import java.net.InetSocketAddress;
    4. import java.net.ServerSocket;
    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.Iterator;
    11. import java.util.Set;
    12.  
    13. public class NioReceiver {
    14. 	@SuppressWarnings("null")
    15. 	public static void main(String[] args) throws Exception {
    16. 		ByteBuffer echoBuffer = ByteBuffer.allocate(8);
    17. 		ServerSocketChannel ssc = ServerSocketChannel.open();
    18. 		Selector selector = Selector.open();
    19. 		ssc.configureBlocking(false);
    20. 		ServerSocket ss = ssc.socket();
    21. 		InetSocketAddress address = new InetSocketAddress(8080);
    22. 		ss.bind(address);
    23. 		SelectionKey key = ssc.register(selector, SelectionKey.OP_ACCEPT);
    24. 		System.out.println("开始监听……");
    25. 		while (true) {
    26. 			int num = selector.select();
    27. 			Set selectedKeys = selector.selectedKeys();
    28. 			Iterator it = selectedKeys.iterator();
    29. 			while (it.hasNext()) {
    30. 				SelectionKey sKey = (SelectionKey) it.next();
    31. 				SocketChannel channel = null;
    32. 				if (sKey.isAcceptable()) {
    33. 					ServerSocketChannel sc = (ServerSocketChannel) key.channel();
    34. 					channel = sc.accept();// 接受连接请求
    35. 					channel.configureBlocking(false);
    36. 					channel.register(selector, SelectionKey.OP_READ);
    37. 					it.remove();
    38. 				} else if (sKey.isReadable()) {
    39. 					channel = (SocketChannel) sKey.channel();
    40. 					while (true) {
    41. 						echoBuffer.clear();
    42. 						int r = channel.read(echoBuffer);
    43. 						if (r <= 0) {
    44. 							channel.close();
    45. 							System.out.println("接收完毕，断开连接");
    46. 							break;
    47. 						}
    48. 						System.out.println("##" + r + " " + new String(echoBuffer.array(), 0, echoBuffer.position()));
    49. 						echoBuffer.flip();
    50. 					}
    51. 					it.remove();
    52. 				} else {
    53. 					channel.close();
    54. 				}
    55. 			}
    56. 		}
    57.  
    58. 	}
    59.  
    60. }

    客户端（NIO）： 

    1. package yyf.java.nio.test;
    2.  
    3. import java.net.InetSocketAddress;
    4. import java.nio.ByteBuffer;
    5. import java.nio.channels.SelectionKey;
    6. import java.nio.channels.Selector;
    7. import java.nio.channels.SocketChannel;
    8. import java.util.Iterator;
    9. import java.util.Set;
    10.  
    11. public class NioTest {
    12. 	public static void main(String[] args) throws Exception {
    13. 		ByteBuffer echoBuffer = ByteBuffer.allocate(1024);
    14. 		SocketChannel channel = null;
    15. 		Selector selector = null;
    16. 		channel = SocketChannel.open();
    17. 		channel.configureBlocking(false);
    18. 		// 请求连接
    19. 		channel.connect(new InetSocketAddress("localhost", 8080));
    20. 		selector = Selector.open();
    21. 		channel.register(selector, SelectionKey.OP_CONNECT);
    22. 		int num = selector.select();
    23. 		Set selectedKeys = selector.selectedKeys();
    24. 		Iterator it = selectedKeys.iterator();
    25. 		while (it.hasNext()) {
    26. 			SelectionKey key = (SelectionKey) it.next();
    27. 			it.remove();
    28. 			if (key.isConnectable()) {
    29. 				if (channel.isConnectionPending()) {
    30. 					if (channel.finishConnect()) {
    31. 						// 只有当连接成功后才能注册OP_READ事件
    32. 						key.interestOps(SelectionKey.OP_READ);
    33. 						echoBuffer.put("123456789abcdefghijklmnopq".getBytes());
    34. 						echoBuffer.flip();
    35. 						System.out.println("##" + new String(echoBuffer.array()));
    36. 						channel.write(echoBuffer);
    37. 						System.out.println("写入完毕");
    38. 					} else {
    39. 						key.cancel();
    40. 					}
    41. 				}
    42. 			}
    43. 		}
    44.  
    45. 	}
    46. }

    运行结果：

    1. 开始监听……
    2. ##8 12345678
    3. ##8 9abcdefg
    4. ##8 hijklmno
    5. ##2 pq
    6. 接收完毕，断开连接



    当然，BIO的客户端也可以，开启10个BIO客户端线程

    1. package yyf.java.nio.test;
    2.  
    3. import java.io.ByteArrayOutputStream;
    4. import java.io.IOException;
    5. import java.io.InputStream;
    6. import java.io.OutputStream;
    7. import java.net.InetAddress;
    8. import java.net.InetSocketAddress;
    9. import java.net.Socket;
    10. import java.net.UnknownHostException;
    11. import java.util.Random;
    12.  
    13. import yyf.java.test.Main;
    14.  
    15. public class BioClientTest {
    16. 	public static void main(String[] args) throws Exception {
    17. 		BioClient n = new BioClient();
    18. 		for (int i = 0; i < 10; i++) {
    19. 			Thread t1 = new Thread(n);
    20. 			t1.start();
    21. 		}
    22. 	}
    23. }
    24.  
    25. class BioClient implements Runnable {
    26. 	@Override
    27. 	public void run() {
    28.  
    29. 		try {
    30. 			Socket socket = new Socket("127.0.0.1", 8080);
    31. 			OutputStream os = socket.getOutputStream();
    32. 			InputStream is = socket.getInputStream();
    33. 			ByteArrayOutputStream bos = new ByteArrayOutputStream();
    34. 			String str = Thread.currentThread().getName() + "...........sadsadasJava";
    35. 			os.write(str.getBytes());
    36. 			StringBuffer sb = new StringBuffer();
    37. 			byte[] b = new byte[1024];
    38. 			int len;
    39. 			while ((len = is.read(b)) != -1) {
    40. 				bos.write(b, 0, len);
    41. 			}
    42. 			is.close();
    43. 			os.close();
    44. 			socket.close();
    45. 			System.out.println(Thread.currentThread().getName() + " 写入完毕 " + new String(bos.toByteArray()));
    46. 		} catch (Exception e) {
    47. 			e.printStackTrace();
    48. 		}
    49. 	}
    50.  
    51. }
    运行结果： 

    1. ##8 Thread-4
    2. ##8 ........
    3. ##8 ...sadsa
    4. ##7 dasJava
    5. 接收完毕，断开连接
    6. ##8 Thread-3
    7. ##8 ........
    8. ##8 ...sadsa
    9. ##7 dasJava
    10. 接收完毕，断开连接
    11. ##8 Thread-9
    12. ##8 ........
    13. ##8 ...sadsa
    14. ##7 dasJava
    15. 接收完毕，断开连接
    16. ##8 Thread-7
    17. ##8 ........
    18. ##8 ...sadsa
    19. ##7 dasJava
    20. 接收完毕，断开连接
    21. ##8 Thread-0
    22. ##8 ........
    23. ##8 ...sadsa
    24. ##7 dasJava
    25. 接收完毕，断开连接
    26. ##8 Thread-5
    27. ##8 ........
    28. ##8 ...sadsa
    29. ##7 dasJava
    30. 接收完毕，断开连接
    31. ##8 Thread-2
    32. ##8 ........
    33. ##8 ...sadsa
    34. ##7 dasJava
    35. 接收完毕，断开连接
    36. ##8 Thread-8
    37. ##8 ........
    38. ##8 ...sadsa
    39. ##7 dasJava
    40. 接收完毕，断开连接
    41. ##8 Thread-1
    42. ##8 ........
    43. ##8 ...sadsa
    44. ##7 dasJava
    45. 接收完毕，断开连接
    46. ##8 Thread-6
    47. ##8 ........
    48. ##8 ...sadsa
    49. ##7 dasJava
    50. 接收完毕，断开连接

    当然，这只是一个测试，对于一个服务器，是有读取，也有写出的，这是文档给的一个服务端例子 

    1. package yyf.java.nio.ibm;
    2.  
    3. import java.io.*;
    4. import java.net.*;
    5. import java.nio.*;
    6. import java.nio.channels.*;
    7. import java.util.*;
    8.  
    9. public class MultiPortEcho {
    10. 	private int ports[];
    11. 	private ByteBuffer echoBuffer = ByteBuffer.allocate(5);
    12.  
    13. 	public MultiPortEcho(int ports[]) throws IOException {
    14. 		this.ports = ports;
    15. 		go();
    16. 	}
    17.  
    18. 	private void go() throws IOException {
    19. 		Selector selector = Selector.open();
    20. 		for (int i = 0; i < ports.length; ++i) {
    21. 			ServerSocketChannel ssc = ServerSocketChannel.open();
    22. 			ssc.configureBlocking(false);
    23. 			ServerSocket ss = ssc.socket();
    24. 			InetSocketAddress address = new InetSocketAddress(ports[i]);
    25. 			ss.bind(address);
    26. 			SelectionKey key = ssc.register(selector, SelectionKey.OP_ACCEPT);
    27. 			System.out.println("Going to listen on " + ports[i]);
    28. 		}
    29.  
    30. 		while (true) {
    31. 			int num = selector.select();
    32. 			Set selectedKeys = selector.selectedKeys();
    33. 			Iterator it = selectedKeys.iterator();
    34. 			while (it.hasNext()) {
    35. 				SelectionKey key = (SelectionKey) it.next();
    36. 				if ((key.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
    37. 					ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
    38. 					SocketChannel sc = ssc.accept();
    39. 					sc.configureBlocking(false);
    40. 					SelectionKey newKey = sc.register(selector, SelectionKey.OP_READ);
    41. 					it.remove();
    42. 					System.out.println("Got connection from " + sc);
    43. 				} else if ((key.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
    44. 					SocketChannel sc = (SocketChannel) key.channel();
    45. 					int bytesEchoed = 0;
    46. 					while (true) {
    47. 						echoBuffer.clear();
    48. 						int r = sc.read(echoBuffer);
    49. 						if (r <= 0) {
    50. 							sc.close();
    51. 							break;
    52. 						}
    53. 						echoBuffer.flip();
    54. 						sc.write(echoBuffer);
    55. 						bytesEchoed += r;
    56. 					}
    57. 					System.out.println("Echoed " + bytesEchoed + " from " + sc);
    58. 					it.remove();
    59. 				}
    60.  
    61. 			}
    62. 			// System.out.println( "going to clear" );
    63. 			// selectedKeys.clear();
    64. 			// System.out.println( "cleared" );
    65. 		}
    66. 	}
    67.  
    68. 	static public void main(String args[]) throws Exception {
    69. 		int ports[] = new int[] { 8080 };
    70. 		for (int i = 0; i < args.length; ++i) {
    71. 			ports[i] = Integer.parseInt(args[i]);
    72. 		}
    73. 		new MultiPortEcho(ports);
    74. 	}
    75. }

    现在，我们就写个客户端去跟服务器通信，把发过去的返回来： 

    1. package yyf.java.nio;
    2.  
    3. import java.io.IOException;
    4. import java.net.InetSocketAddress;
    5. import java.net.SocketAddress;
    6. import java.nio.ByteBuffer;
    7. import java.nio.channels.SocketChannel;
    8.  
    9. import javax.swing.ButtonGroup;
    10.  
    11. public class NioClient {
    12. 	public static void main(String[] args) throws IOException {
    13. 		SocketChannel socketChannel = SocketChannel.open();
    14. 		SocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 8080);
    15. 		socketChannel.connect(socketAddress);
    16. 		String str = "你好a";
    17. 		ByteBuffer buffer = ByteBuffer.wrap(str.getBytes());
    18. 		socketChannel.write(buffer);
    19. 		socketChannel.socket().shutdownOutput();
    20. 	
    21. 		buffer.clear();
    22. 		byte[] bytes;
    23. 		int count = 0;
    24. 		while ((count = socketChannel.read(buffer)) > 0) {
    25. 			buffer.flip();
    26. 			bytes = new byte[count];
    27. 			buffer.get(bytes);
    28. 			System.out.println(new String(buffer.array()));
    29. 			buffer.clear();
    30. 		}
    31. 		socketChannel.socket().shutdownInput();
    32. 		socketChannel.socket().close();
    33. 		socketChannel.close();
    34. 	}
    35. }


    运行结果

    server：

    1. Going to listen on 8080
    2. Got connection from java.nio.channels.SocketChannel[connected local=/127.0.0.1:8080 remote=/127.0.0.1:63584]
    3. Echoed 7 from java.nio.channels.SocketChannel[closed]

    client： 

    你好a

    对于NIO的入门就先到这里。







  • 相关阅读:
    Flink Task 并行度
    flink笔记(三) flink架构及运行方式
    Flink笔记(二) DataStream Operator(数据流操作)
    poj 1463 Strategic game
    2014年3月29日小记
    AC自动机学习
    hdu 1028 Ignatius and the Princess III
    hdu 1542 Atlantis
    hdu 1575 Tr A
    hdu 4193 Non-negative Partial Sums
  • 原文地址：https://www.cnblogs.com/jpfss/p/9257185.html
Copyright © 2020-2023  润新知