IO、BUFFER、BIO、NIO介绍

朱雀 2022-04-15 06:09 314阅读 0赞

# 缓冲区buffer介绍 #

缓冲区(Buffer)就是在**内存**中预留指定大小的存储空间用来对I/O的数据做临时存储，这部分预留的内存空间叫缓冲区。

使用缓冲区有两个好处：  
1、减少实际物理读写次数  
2、缓冲区在创建时就被分配内存，这块内存区域一直被重用，可以减少动态分配和回收内存的次数

一般在实际过程中，我们一般是先将文件读入内存，再从内存写入到别的地方，这样在输入输出过程中我们都可以用缓存来提升IO性能。

在java nio中，缓冲区的作用也是用来临时存储数据，可以理解为是I/O操作中数据的中转站。缓冲区直接为通道(channel)服务，写入数据到通道或从通道读取数据，这样利用缓冲区数据来传递就可以达到对数据高效处理的目的。在nio中主要有八种缓冲区类（其中MappedByteBuffer是专门用于内存映射的一种ByteBuffer）:  
ByteBuffer（常用）,CharBuffer,ShortBuffer,IntBuffer,LongBuffer,FloatBuffer,DoubleBuffer

## 2、Fields ##

所有缓冲区都有4个属性：capacity、limit、position、mark，并遵循mark<=position<=limit<=capacity，下表时对这4个属性的解释：

<table> 
 <thead> 
  <tr> 
   <th>字段</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>position</td> 
   <td>当前读到的位置</td> 
  </tr> 
  <tr> 
   <td>limit</td> 
   <td>当前写到的位置</td> 
  </tr> 
  <tr> 
   <td>capacity</td> 
   <td>容量</td> 
  </tr> 
  <tr> 
   <td>mark</td> 
   <td>标记，调用mark()来设置mark=position，在调用reset()可以让position恢复到标记位置</td> 
  </tr> 
 </tbody> 
</table>

## 3、另外一些常用的方法 ##

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>limit(),limit(10)</td> 
   <td>前者get，后者set</td> 
  </tr> 
  <tr> 
   <td>reset()</td> 
   <td>把position设置成mark的值</td> 
  </tr> 
  <tr> 
   <td>clear()</td> 
   <td>position=0,limit=capacity,mark=-1</td> 
  </tr> 
  <tr> 
   <td>flip()</td> 
   <td>limit=position,position=0,mark=-1；将缓冲区状态由存数据变为准备取数据</td> 
  </tr> 
  <tr> 
   <td>rewind()</td> 
   <td>把position设为0，mark设为-1,不改变limit的值</td> 
  </tr> 
  <tr> 
   <td>remaining()</td> 
   <td>return limit-position</td> 
  </tr> 
  <tr> 
   <td>hasRemaining()</td> 
   <td>return position &lt; limit,是否还有未读内容</td> 
  </tr> 
  <tr> 
   <td>compact</td> 
   <td>把position到limit间的内容移到0到limit间,position和limit的取值分别变为limit-position、capacity;<br> 也即将未读的内容拷贝到缓冲区开头，现在buffer准备好写数据，但是不会覆盖未读的数据;<br> 如果先将position设置到limit,再compact，那么相当于clear</td> 
  </tr> 
  <tr> 
   <td>get()</td> 
   <td>相对读，从position读取一个byte,并将position+1,为下次读写做准备</td> 
  </tr> 
  <tr> 
   <td>get(int index)</td> 
   <td>绝对读，读取byteBuffer底层bytes下标为index的byte,不改变position</td> 
  </tr> 
  <tr> 
   <td>get(byte[]dst,int offset,int length)</td> 
   <td>从position开始相对读，读length个byte,并写入dst下标从offset到offset+length的区域</td> 
  </tr> 
  <tr> 
   <td>put(byte b)</td> 
   <td>相对写，向position写入一个byte,并将position+1,为下次读写做准备</td> 
  </tr> 
  <tr> 
   <td>put(int index,byte b)</td> 
   <td>绝对写，想byteBuffer底层的bytes中下标为index的位置插入byte b，不改变position</td> 
  </tr> 
  <tr> 
   <td>put(ByteBuffer src)</td> 
   <td>用相对写，把src中可读的部分(position-limit)写入到此byteBuffer)</td> 
  </tr> 
  <tr> 
   <td>put(byte[]src,int offset,int length</td> 
   <td>将src数组中offset到offset+length的数据写入到position之后，并将position+length</td> 
  </tr> 
 </tbody> 
</table>

4.Buffer 写读原理图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDQ0NDE5_size_16_color_FFFFFF_t_70][]

第一步：初始化状态下的数组new byte\[5\]，position为0，limit为5，capacity为5.

第二步：写入两个字节后  >>  position为2，limit为5，capacity为5.

第三步：因为所有可操作的数据处于position和limit之间，所以读之前要调用 flip()方法，flip调用之后，position为0，limit为2.

flip方法源代码展示：

![20181122150913116.png][]

第四步:读取状态，读取完毕后：position为2，limit为2。

第五步：读完之后要面临再次写入数据，在写入数据之前要处于清空状态，调用 clear()方法，调用clear后 position为0，limit为5

备注：所谓的处于清空状态或者调用clear方法并不是清空数组中之前写入的两个字节的数据，只是单出的改变position和limit的位置，上一次读入的数据依然存在。

clear()方法源码展示：

![20181122151513607.png][]

第六步：再次写入一个字节的数据，position为1，limit为5.   看图理解步骤。

备注：读数据前先flip：因为buffer可操作的数据处于position和limit之间，否则读不出数据。

写数据前先clear：可能是为写操作提供更宽阔的空间吧

以上原理代码测试：

package com.***.demo;
    import java.nio.ByteBuffer;
    public class TestBuffer {
    	public static void main(String[] args) {
    		//1.创建buffer
    		byte[] bytes=new byte[5];
    		ByteBuffer buffer=ByteBuffer.wrap(bytes);
    		System.out.println("初始状态 :capacity:"+buffer.capacity()+",position:"+buffer.position()+",limit:"+buffer.limit());
    		 //初始状态：capacity为5 position为0  limit为5
    		//写2个字节
    		buffer.put((byte)'a');
    		buffer.put((byte)'b');
    		System.out.println("写2字节 :capacity:"+buffer.capacity()+",position:"+buffer.position()+",limit:"+buffer.limit());
             //写两个字节：capacity为5 position为2  limit为5
    		buffer.flip();
    		
    		//读两个字节
    		while(buffer.hasRemaining()){
    			System.out.println(buffer.get());
    		}
    		System.out.println("读完2字节 :capacity:"+buffer.capacity()+",position:"+buffer.position()+",limit:"+buffer.limit());
    		 //读完两个字节：capacity为5 position为2  limit为2
    		buffer.clear();
    		buffer.put((byte)'c');
    		
    		buffer.flip();
    		//读两个字节
    		while(buffer.hasRemaining()){
    			System.out.println(buffer.get());
    		}
    	}
    }

## buffer 其他方法： ##

java.nio.Buffer类是一个抽象类，不能被实例化。Buffer类的直接子类，如ByteBuffer等也是抽象类，所以也不能被实例化。

但是ByteBuffer类提供了4个静态工厂方法来获得ByteBuffer的实例：

方法描述：

<table> 
 <tbody> 
  <tr> 
   <td style="width:219px;">allocate(int capacity)&nbsp;&nbsp;</td> 
   <td style="width:630px;">从堆空间中分配一个容量大小为capacity的byte数组作为缓冲区的byte数据存储器</td> 
  </tr> 
  <tr> 
   <td style="width:219px;">allocateDirect(int capacity)</td> 
   <td style="width:630px;">是不使用JVM堆栈而是通过操作系统来创建内存块用作缓冲区，它与当前操作系统能够更好的耦合，因此能进一步提高I/O操作速度。但是分配直接缓冲区的系统开销很大，因此只有在缓冲区较大并长期存在，或者需要经常重用时，才使用这种缓冲区</td> 
  </tr> 
  <tr> 
   <td style="width:219px;">wrap(byte[] array)&nbsp;</td> 
   <td style="width:630px;">这个缓冲区的数据会存放在byte数组中，bytes数组或buff缓冲区任何一方中数据的改动都会影响另一方。其实ByteBuffer底层本来就有一个bytes数组负责来保存buffer缓冲区中的数据，通过allocate方法系统会帮你构造一个byte数组</td> 
  </tr> 
  <tr> 
   <td style="width:219px;">wrap(byte[] array,<br> &nbsp;int offset, int length)&nbsp;&nbsp; &nbsp;</td> 
   <td style="width:630px;">在上一个方法的基础上可以指定偏移量和长度，这个offset也就是包装后byteBuffer的position，而length呢就是limit-position的大小，从而我们可以得到limit的位置为length+position(offset)</td> 
  </tr> 
 </tbody> 
</table>

### buffer 读、写、赋值操作 ###

代码测试buffer读操作：

package com.***.demo;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    
    public class TestFileWriter {
    	public static void main(String[] args) throws IOException {
    		//1.获取通道
    		 FileChannel writeChannel=new FileOutputStream("write.txt").getChannel();
    		 //2.创建buffer
    		 String value="你好,hello world!";
    		 ByteBuffer buffer=ByteBuffer.wrap(value.getBytes());
    		 
    		 writeChannel.write(buffer);
    		 
    		 writeChannel.close();
    		 
    	}
    }

代码测试buffer写操作：

package com.***.demo;
    
    import java.io.ByteArrayOutputStream;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    
    public class TestFileRead {
    	public static void main(String[] args) throws IOException {
    		//1.获取通道
    		FileChannel readChannel=new FileInputStream("write.txt").getChannel();
    		
    		//2.创建缓冲区
    		ByteBuffer buffer=ByteBuffer.allocate(1024);
    		
    		//创建一个可变长的字节数组 
    		ByteArrayOutputStream bos=new ByteArrayOutputStream();
    		
    		//3.读取数据
    		while(true){
    			buffer.clear();//还原buffer状态 ,确保有足够的空间
    			//将数据读进缓冲区 返回实际读取的字节数 如果读到流结尾返回-1
    			int len=readChannel.read(buffer);
    			if(len==-1) break;
    			buffer.flip();
    			//读buffer
    			bos.write(buffer.array(),0, len);
    		}
    		System.out.println("读到数据:"+new String(bos.toByteArray()));
    		//关闭通道
    		readChannel.close();
    	}
    }

代码测试buffer复制操作：

package com.***.demo;
    
    import java.io.ByteArrayOutputStream;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    
    public class TestFileCopy {
    	public static void main(String[] args) throws IOException {
    		//1.获取通道
    		FileChannel readChannel=new FileInputStream("write.txt").getChannel();
    		FileChannel writeChannel=new FileOutputStream("write1.txt").getChannel();
    		//2.创建缓冲区
    		ByteBuffer buffer=ByteBuffer.allocate(1024);
    		//3.读取数据
    		while(true){
    			buffer.clear();//还原buffer状态 ,确保有足够的空间
    			//将数据读进缓冲区 返回实际读取的字节数 如果读到流结尾返回-1
    			int len=readChannel.read(buffer);
    			if(len==-1) break;
    			buffer.flip();
    			//读buffer
    			writeChannel.write(buffer);
    		}
    		//关闭通道
    		readChannel.close();
    		writeChannel.close();
    	}
    }

## BIO 网络编程模型 : ServerSocket (服务器)/Socket(客户端) ##

###    服务端: ###

1.  创建ServerSocket
2.  绑定监听端口
3.  等待请求到来
4.  请求和响应 socket.getInputStream()/socket.getOutputStream();

代码测试：

package com.***.demo.bio;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.PrintWriter;
    import java.net.InetSocketAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    import javax.lang.model.element.ExecutableElement;
    
    
    public class ServerBootstrap {
    	public static void main(String[] args) throws IOException {
    		start04();
    	}
    	/**
    	 * 处理多线程  
    	 * @throws IOException
    	 */
    	public static void start04() throws IOException{
    		//1.创建ServerSocket
    		ServerSocket ss=new ServerSocket();
    		//2.绑定监听端口
    		ss.bind(new InetSocketAddress(9999));
            ExecutorService executorService=Executors.newFixedThreadPool(5);
    		while(true){
    			System.out.println("我在9999监听...");
    			final Socket socket = ss.accept();
    			executorService.submit(new Runnable() {
    				@Override
    				public void run() {
    					// TODO Auto-generated method stub
    					try {
    						System.out.println("处理请求中... "+Thread.currentThread().getId());
    						//获取用户的意图 请求 套路
    						InputStream inputStream = socket.getInputStream();
    						InputStreamReader isr=new InputStreamReader(inputStream);
    						BufferedReader br=new BufferedReader(isr);
    						StringBuilder sb = new StringBuilder();
    						String line=null;
    						while((line=br.readLine())!=null){
    							sb.append(line);
    						}
    						//给客户端响应
    						OutputStream outputStream = socket.getOutputStream();
    						PrintWriter pw=new PrintWriter(outputStream);
    						pw.println("你好客户端,我是服务器,我收到:"+sb.toString());
    						pw.flush();
    						socket.shutdownOutput();//告知客户端 服务器 响应已经完成 
    						//释放资源
    						socket.close();
    					} catch (Exception e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				}
    			});
    			
    		}
    	}
    	/**
    	 * 处理多线程  
    	 * @throws IOException
    	 */
    	public static void start03() throws IOException{
    		//1.创建ServerSocket
    		ServerSocket ss=new ServerSocket();
    		//2.绑定监听端口
    		ss.bind(new InetSocketAddress(9999));
    		//3.等待客户端连接  request inputStream/response outputStream
    		while(true){
    			System.out.println("我在9999监听...");
    			final Socket socket = ss.accept();
    			new Thread(){
    				public void run() {
    					try {
    						System.out.println("处理请求中...");
    						//获取用户的意图 请求 套路
    						InputStream inputStream = socket.getInputStream();
    						InputStreamReader isr=new InputStreamReader(inputStream);
    						BufferedReader br=new BufferedReader(isr);
    						StringBuilder sb = new StringBuilder();
    						String line=null;
    						while((line=br.readLine())!=null){
    							sb.append(line);
    						}
    						System.out.println("服务器读到:"+sb.toString());
    						//给客户端响应
    						OutputStream outputStream = socket.getOutputStream();
    						PrintWriter pw=new PrintWriter(outputStream);
    						pw.println("你好客户端,我是服务器,我收到:"+sb.toString());
    						pw.flush();
    						socket.shutdownOutput();//告知客户端 服务器 响应已经完成 
    						//释放资源
    						socket.close();
    					} catch (Exception e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				};
    			}.start();
    			
    		}
    	}
    	/**
    	 * 多个请求响应
    	 * @throws IOException
    	 */
    	public static void start02() throws IOException{
    		//1.创建ServerSocket
    		ServerSocket ss=new ServerSocket();
    		//2.绑定监听端口
    		ss.bind(new InetSocketAddress(9999));
    		//3.等待客户端连接  request inputStream/response outputStream
    		while(true){
    			System.out.println("我在9999监听...");
    			Socket socket = ss.accept();
    			System.out.println("处理请求中...");
    			
    			StringBuilder sb;
    			//获取用户的意图 请求 套路
    			InputStream inputStream = socket.getInputStream();
    			InputStreamReader isr=new InputStreamReader(inputStream);
    			BufferedReader br=new BufferedReader(isr);
    			sb = new StringBuilder();
    			String line=null;
    			while((line=br.readLine())!=null){
    				sb.append(line);
    			}
    			System.out.println("服务器读到:"+sb.toString());
    			//给客户端响应
    			OutputStream outputStream = socket.getOutputStream();
    			PrintWriter pw=new PrintWriter(outputStream);
    			pw.println("你好客户端,我是服务器,我收到:"+sb.toString());
    			pw.flush();
    			socket.shutdownOutput();//告知客户端 服务器 响应已经完成 
    			//释放资源
    			socket.close();
    		}
    	}
    	/**
    	 * 单个请求响应
    	 * @throws IOException
    	 */
    	public static void start01() throws IOException{
    		//1.创建ServerSocket
    		ServerSocket ss=new ServerSocket();
    		//2.绑定监听端口
    		ss.bind(new InetSocketAddress(9999));
    		//3.等待客户端连接  request inputStream/response outputStream
    		System.out.println("我在9999监听...");
              //accept() 这个方法会处于阻塞状态直到有客户端请求进来
    		Socket socket = ss.accept();
    		System.out.println("处理请求中...");
    		//socket 中有 request inputStream/response outputStream，用来获取客户端请求和响应客户端
    		System.out.println("我在9999监听...");
    		//获取用户的意图 请求 套路 
    		InputStream inputStream = socket.getInputStream();
    		InputStreamReader isr=new InputStreamReader(inputStream);
    		BufferedReader br=new BufferedReader(isr);
    		StringBuilder sb=new StringBuilder();
    		String line=null;
    		while((line=br.readLine())!=null){
    			sb.append(line);
    		}
    		System.out.println("服务器读到:"+sb.toString());
    		//给客户端响应
    		OutputStream outputStream = socket.getOutputStream();
    		PrintWriter pw=new PrintWriter(outputStream);
    		pw.println("你好客户端,我是服务器,我收到:"+sb.toString());
    		pw.flush();
    		socket.shutdownOutput();//告知客户端 服务器 响应已经完成 
    		//释放资源
    		socket.close();
    	}
    }

### 客户端: ###

1.  创建Socket对象
2.  连接服务器
3.  创建请求和获取响应socket.getOutputStream()/socket.getInputStream()

代码测试：

缺点:通过线程池实现服务器的并发访问,但是无法避免服务器线程因为IO没有就绪,被白白挂起处于阻塞状态.

## NIO 网络编程：缓冲区 Buffer/通道Channel /通道选择器 Selector(网络编程讲解) ##

通道选择器 用于管理 通道 确保所有和通道相关的操作都是非阻塞.

1.  必须把通道交给通道选择器 注册(通道/IO事件类型)
2.  交给通道选择器管理 要求通道必须是非阻塞

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDQ0NDE5_size_16_color_FFFFFF_t_70 1][]

###  服务端: ###

1.  创建SeverSocketChannel
2.  绑定监听端口
3.  设置SeverSocketChannel为非阻塞
4.  创建通道选择器
5.  注册通道到通道选择器
6.  迭代遍历通道选择器 就绪的IO通道

###  客户端 ###

1.  创建SocketChannel
2.  连接服务器
3.  发送请求/获取响应  SocketChannel\#write(buffer)/SocketChannel\#read(buffer)

服务端：

package com.***i.demo.nio3;
    
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    import java.nio.channels.SelectableChannel;
    import java.nio.channels.SelectionKey;
    import java.nio.channels.Selector;
    import java.nio.channels.ServerSocketChannel;
    import java.nio.channels.SocketChannel;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Set;
    
    public class ServerBootstrap {
    	private static List<SelectionKey> writeQuene=new ArrayList<SelectionKey>();
    	public static void addWriteEventToQuene(SelectionKey key,Selector selector){
    		synchronized (writeQuene) {
    			writeQuene.add(key);
    		}
    		selector.wakeup();
    	}
    	public static void main(String[] args) throws IOException {
    		start01();
    	}
    	public static void start01() throws IOException{
    		//1.创建ServerSocketChannel
    		ServerSocketChannel ssc=ServerSocketChannel.open();
    		//2.绑定监听端口
    		ssc.bind(new InetSocketAddress(9999));
    		//3.设置通道非阻塞
    		ssc.configureBlocking(false);
    		//4.创建通道选择器
    		 Selector selector=Selector.open();
    	    //5.注册通道
    		ssc.register(selector, SelectionKey.OP_ACCEPT);
    		 
    		//6.迭代遍历 通道选择器 获取就绪的IO通道 
    		while(true){
    			//返回可用通道个数'
    			System.out.println("我在9999监听....");
    			int num = selector.select();
    			if(num>0){
    				//事件表
    				Set<SelectionKey> selectedKeys = selector.selectedKeys();
    				Iterator<SelectionKey> iterator = selectedKeys.iterator();
    				while(iterator.hasNext()){
    					SelectionKey key = iterator.next();
    					//处理 对应事件类型
    					if(key.isAcceptable()){
    						System.out.println("处理Accept请求...");
    						ServerSocketChannel serverSocketChannel=(ServerSocketChannel) key.channel();
    						//这里 可以立即获取一个 socketChannel
    						SocketChannel socketChannel = serverSocketChannel.accept();
    						socketChannel.configureBlocking(false);
    						socketChannel.register(selector, SelectionKey.OP_READ);
    					}else if(key.isReadable()){
    					   key.cancel();//取消 通道选择器对该通道的管理
    					   RquestProcessor.process(key, selector);
    					}else if(key.isWritable()){
    					  key.cancel();
    					  ResponseProcessor.process(key, selector);
    					}
    					//放置 同一事件被重复执行多次
    					iterator.remove();
    				}
    				
    			}else{
    				//TODO nothing 
    				//注册写事件
    				while(writeQuene.size()>0){
    					System.out.println("main 线程注册写事件...");
    					SelectionKey key = writeQuene.remove(0);
    					SocketChannel channel = (SocketChannel) key.channel();
    					channel.register(selector, SelectionKey.OP_WRITE, key.attachment());
    				}
    			}
    		}
    	} 
    }
    
    
    
    
    
    package com.***.demo.nio3;
    
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.nio.ByteBuffer;
    import java.nio.channels.ClosedChannelException;
    import java.nio.channels.SelectionKey;
    import java.nio.channels.Selector;
    import java.nio.channels.SocketChannel;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class RquestProcessor {
    	private static ExecutorService executorService=Executors.newFixedThreadPool(10);
    	public static void process(final SelectionKey key,final Selector selector){
    		executorService.submit(new Runnable() {
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				try {
    					System.out.println("处理Read请求...");
    					SocketChannel socketChannel=(SocketChannel) key.channel();
    					//读取用户的意图 套路
    					ByteBuffer buffer=ByteBuffer.allocate(1024);
    					ByteArrayOutputStream bos=new ByteArrayOutputStream();
    					while(true){
    						buffer.clear();
    						int len=socketChannel.read(buffer);
    						if(len==-1) break;
    						buffer.flip();
    						bos.write(buffer.array(),0,len);
    					}
    					System.out.println("读结束..");
    					//socketChannel.register(selector, SelectionKey.OP_WRITE,bos);
    					key.attach(bos);
    					ServerBootstrap.addWriteEventToQuene(key, selector);
    					System.out.println("注册写成功...");
    				} catch (Exception e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		});
    	}
    }
    
    
    
    package com.***.demo.nio3;
    
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.nio.ByteBuffer;
    import java.nio.channels.ClosedChannelException;
    import java.nio.channels.SelectionKey;
    import java.nio.channels.Selector;
    import java.nio.channels.SocketChannel;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class ResponseProcessor {
    	private static  ExecutorService executorService=Executors.newFixedThreadPool(10);
    	public static void process(final SelectionKey key,final Selector selector){
    		executorService.submit(new Runnable() {
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				try {
    					System.out.println("处理Write请求...");
    					SocketChannel socketChannel=(SocketChannel) key.channel();
    					//写回响应 套路
    					ByteArrayOutputStream attachment = (ByteArrayOutputStream) key.attachment();
    					ByteBuffer buffer=ByteBuffer.wrap(attachment.toByteArray());
    					socketChannel.write(buffer);
    					socketChannel.shutdownOutput();//告知客户端 已经结束
    					//释放资源
    					socketChannel.close();
    				} catch (IOException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    		});
    	}
    }

客户端：

package com.***.demo.nio;
    
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    import java.nio.channels.SelectionKey;
    import java.nio.channels.Selector;
    import java.nio.channels.SocketChannel;
    import java.util.Iterator;
    
    import javax.xml.ws.handler.MessageContext.Scope;
    
    public class Bootstrap {
    	public static void main(String[] args) throws IOException {
    		for(int i=0;i<100;i++){
    			new Thread(){
    				public void run() {
    					try {
    						String sendMsg = sendMsg("你好!");
    						System.out.println(sendMsg);
    					} catch (IOException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				};
    			}.start();
    		}
    	}
    	public static String sendMsg2(String msg) throws IOException{
    		//1.创建 SocketChannel
    		SocketChannel sc=SocketChannel.open();
    		//2.连接服务器
    		sc.connect(new InetSocketAddress("127.0.0.1", 9999));
    		//3.设置为非阻塞
    		sc.configureBlocking(false);
    		//4.创建通道选择器
    		Selector selector=Selector.open();
    		//5.注册 写事件
    		sc.register(selector, SelectionKey.OP_WRITE);
    		boolean isReadFinish=false;
    		ByteArrayOutputStream bos=new ByteArrayOutputStream();
    		while(!isReadFinish){
    			int num=selector.select();
    			if(num>0){
    				Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
    				while(iterator.hasNext()){
    					SelectionKey key = iterator.next();
    					if(key.isWritable()){
    						//发送请求
    						ByteBuffer buffer=ByteBuffer.wrap(msg.getBytes());
    						sc.write(buffer);
    						sc.shutdownOutput();//告知服务器 流的截止
    						sc.register(selector, SelectionKey.OP_READ);
    					}else if(key.isReadable()){
    						//创建可变长的字节数组
    						ByteBuffer buffer=ByteBuffer.allocate(1024);
    						while(true){
    							buffer.clear();
    							int len=sc.read(buffer);
    							if(len==-1) break;
    							buffer.flip();
    							bos.write(buffer.array(),0, len);
    						}
    						sc.close();
    						isReadFinish=true;
    					}
    					iterator.remove();
    				}
    			}else{
    				//TODO nothing
    			}
    		}
    		return new String(bos.toByteArray());
    	}
    	public static String sendMsg(String msg) throws IOException{
    		//1.创建 SocketChannel
    		SocketChannel sc=SocketChannel.open();
    		//2.连接服务器
    		sc.connect(new InetSocketAddress("127.0.0.1", 9999));
    		
    		//发送请求
    		ByteBuffer buffer=ByteBuffer.wrap(msg.getBytes());
    		sc.write(buffer);
    		sc.shutdownOutput();//告知服务器 流的截止
    		
    		
    		//读取请求 
    		//创建可变长的字节数组
    		ByteArrayOutputStream bos=new ByteArrayOutputStream();
    		while(true){
    			buffer.clear();
    			int len=sc.read(buffer);
    			if(len==-1) break;
    			buffer.flip();
    			bos.write(buffer.array(),0, len);
    		}
    		sc.close();
    		return new String(bos.toByteArray());
    	}
    }

![20190304210628997.png][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDQ0NDE5_size_16_color_FFFFFF_t_70]: /images/20220415/49c577289d5e48129f944bc76d92d82d.png
[20181122150913116.png]: /images/20220415/d5db74500b7f4131b3f3fd22e7ff2f3b.png
[20181122151513607.png]: /images/20220415/838c31e27a6f492db8472cd8b9eefa57.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MDQ0NDE5_size_16_color_FFFFFF_t_70 1]: /images/20220415/418b640ade7e4aacb3d8c0e8891a305f.png
[20190304210628997.png]: /images/20220415/100e9802be994588acd4135b65124d49.png