Java BIO, NIO, AIO 简单理解

最新推荐文章于 2024-04-18 15:18:04 发布
最新推荐文章于 2024-04-18 15:18:04 发布
阅读量1.1k 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/funnyrand/article/details/41243671
版权

1， 同步 VS. 异步

比较的是当某种事件发生时调用处理函数的方式，

同步：应用程序主动调用处理函数，

异步：操作系统调用应用程序的处理函数（也叫回调函数），对应用程序而言是被动过程。

 

2， 阻塞 VS. 非阻塞

阻塞：应用程序发起IO请求，IO请求（假设是网络上的IO）会经过网络、网卡、操作系统等，在这个过程中应用程序必须等到操作系统完成IO操作，才能继续后面的事情，因此称为阻塞，

非阻塞：应用程序在发起IO请求后不必等待操作系统完成IO操作，应用程序可以继续做后面的事情，应用程序可以主动查询（轮训）某种IO事件是否完成，并调用相应的处理函数，或者在IO事件发生时操作系统调用应用程序的回调函数。

 

3， BIO，NIO，AIO

 JDK版本  同步and 阻塞 模型类型隐喻
BIO1.0同步阻塞一连接一线程

一个人开了一个餐厅，需要负责迎客（Accept connection）、

等待客户点菜（Read data）、炒菜（处理请求）、

等待客户用餐（Write data）、收银（Close connection），此人在任何时刻

只能服务于一个客户，新来的客户必须等待。

改进型：一人迎客，之后再交由店里空闲的员工独自完成点菜、炒菜、

等待客户用餐、收银等操作，即多线程模式，这在一定程度上能提高性能。

NIO1.4同步非阻塞

一请求一线程，Reactor

一个人开了一个餐厅，负责迎客等所有操作，迎客后让客户点菜，在客户点菜的过程中可以

做其它的操作，并每隔一段时间查看客户是否点菜完毕，如果点菜完毕则开始

炒菜。其它操作类似，如客户用餐，不用等待客户用餐，只需每隔一段时间查看

客户是否用餐完毕，再进行后续操作。

改进型：一个人负责检查是否有某种事件发生，如是否有新客户到来，是否有某个客户点菜

完毕，是否有某个客户用餐完毕等等，多个员工负责处理事件，如某个客户点菜完毕

则让一个空闲的员工来炒菜，如果某个客户用餐完毕，则让一个空闲的员工来收银等等。

由于不用等待客户（即没有IO阻塞），在很大程度上提高了系统系能。

AIO1.7异步非阻塞

一有效请求一线程，Proactor，

需要OS支持，Windows：IOCP，Linux：epoll

 

与NIO类似，只是不用主动查询是否有某种事件发生，而是被告知该事件已发生。如客户

点菜完毕后会主动说“我已经点菜完毕了”，然后让一个空闲的员工来取菜单并炒菜。

AIO是真正意义的异步IO，需要OS支持，在读IO数据时操作系统会将数据读入到应用程序

指定的缓存（ByteByffer）中，应用程序直接使用即可，不像NIO还要应用程序自己读取。

AIO能简化应用程序的编写，因为其只关心有效的请求，将指定的请求绑定到对应的回调函数

中即可，OS会自动调用回调函来处理请求。

 

 

4， BIO代码片段

package com.my.study.io.bio;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Server {
	private static final int PORT = 8888;
	private ServerSocket serverSocket = null;

	private ExecutorService service = Executors.newFixedThreadPool(5);

	private void startServer() {
		try {
			serverSocket = new ServerSocket(PORT);
			System.out.println("Server started on port: " + PORT);

			while (true) {
				Socket socket = serverSocket.accept();

				System.out.println("Received a new connection.");

				service.submit(new RequestResolver(socket));
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private static class RequestResolver implements Runnable {
		private Socket socket;

		public RequestResolver(Socket socket) {
			this.socket = socket;
		}

		public void run() {

			DataInputStream din = null;
			DataOutputStream dout = null;

			try {

				long threadId = Thread.currentThread().getId();

				InputStream in = socket.getInputStream();
				din = new DataInputStream(in);
				String str = din.readUTF();
				System.out.println("Thread: " + threadId + ", read message: "
						+ str);

				OutputStream out = socket.getOutputStream();
				dout = new DataOutputStream(out);
				dout.writeUTF("Response from server.");
			} catch (IOException e) {
				e.printStackTrace();
			} finally {
				if (din != null) {
					try {
						din.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}

				if (dout != null) {
					try {
						din.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}

				if (!socket.isClosed()) {
					try {
						socket.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}

	public static void main(String[] args) {
		new Server().startServer();
	}
}


package com.my.study.io.bio;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class Client {

	private static final int PORT = 8888;

	private static void testSendMessage() {

		Socket socket = null;

		DataInputStream din = null;
		DataOutputStream dout = null;

		try {
			socket = new Socket("127.0.0.1", PORT);

			OutputStream out = socket.getOutputStream();
			dout = new DataOutputStream(out);
			dout.writeUTF("This message is from a client.");

			InputStream in = socket.getInputStream();
			din = new DataInputStream(in);
			String str = din.readUTF();
			System.out.println("Response from server: " + str);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (din != null) {
				try {
					din.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}

			if (dout != null) {
				try {
					din.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}

			if (!socket.isClosed()) {
				try {
					socket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	public static void main(String[] args) {
		testSendMessage();
	}
}
 
5，NIO代码片段
<pre class="java" name="code">package com.my.study.io.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class Server {
	private static final int PORT = 8888;
	private Selector selector;

	private void startServer() {
		try {
			selector = Selector.open();
			ServerSocketChannel serverSocketChannel = ServerSocketChannel
					.open();
			serverSocketChannel.configureBlocking(false);
			SocketAddress address = new InetSocketAddress(PORT);
			serverSocketChannel.bind(address);
			serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

			System.out.println("Server started on port: " + PORT);
			while (true) {
				int selectCode = selector.select(1000);
				if (selectCode == 0) {
					continue;
				}

				Set<SelectionKey> keys = selector.selectedKeys();
				Iterator<SelectionKey> it = keys.iterator();
				while (it.hasNext()) {
					SelectionKey key = it.next();
					if (key.isAcceptable()) {
						System.out.println("Received a request.");
						serverSocketChannel = (ServerSocketChannel) key
								.channel();
						SocketChannel socketChannel = serverSocketChannel
								.accept();
						socketChannel.configureBlocking(false);
						socketChannel.register(selector, SelectionKey.OP_READ);
					} else if (key.isReadable()) {
						readData(key);
					} else {
						System.out.println("Key is no recognised, key: " + key);
					}
					it.remove();
				}

			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private void readData(SelectionKey key) {
		SocketChannel socketChannel = (SocketChannel) key.channel();
		ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024);
		try {
			socketChannel.read(buffer);
			byte[] bytes = buffer.array();
			String message = new String(bytes).toString();
			System.out.println("Received message from client: " + message);

			socketChannel.write(ByteBuffer.wrap("Response from server."
					.getBytes()));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		new Server().startServer();
	}
}


package com.my.study.io.nio;

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;

public class Client {

	private Selector selector;

	public void initClient(String ip, int port) throws IOException {
		SocketChannel channel = SocketChannel.open();
		channel.configureBlocking(false);
		this.selector = Selector.open();
		channel.connect(new InetSocketAddress(ip, port));
		channel.register(selector, SelectionKey.OP_CONNECT);
	}

	public void listen() throws IOException {
		while (true) {
			int selectCode = selector.select(1000);
			if (selectCode == 0) {
				continue;
			}

			Iterator<SelectionKey> it = this.selector.selectedKeys().iterator();
			while (it.hasNext()) {
				SelectionKey key = (SelectionKey) it.next();
				if (key.isConnectable()) {
					SocketChannel channel = (SocketChannel) key.channel();
					if (channel.isConnectionPending()) {
						channel.finishConnect();

					}
					channel.configureBlocking(false);
					channel.register(this.selector, SelectionKey.OP_READ);

					channel.write(ByteBuffer.wrap(new String(
							"Message from a client.").getBytes()));
				} else if (key.isReadable()) {
					readData(key);
				}
				it.remove();
			}
		}
	}

	public void readData(SelectionKey key) throws IOException {
		SocketChannel channel = (SocketChannel) key.channel();
		ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024);
		channel.read(buffer);
		byte[] data = buffer.array();
		String msg = new String(data).trim();
		System.out.println("Response from server: " + msg);
	}

	public static void main(String[] args) throws IOException {
		Client client = new Client();
		client.initClient("localhost", 8888);
		client.listen();
	}

}


 

6，AIO代码片段
 

<pre class="java" name="code">package com.my.study.io.aio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.TimeUnit;

public class Server {
	private static final int PORT = 8888;

	private AsynchronousServerSocketChannel server;

	private void startServer() {
		try {
			server = AsynchronousServerSocketChannel.open().bind(
					new InetSocketAddress(PORT));

			System.out.println("Server started on port: " + PORT);

			server.accept(null,
					new CompletionHandler<AsynchronousSocketChannel, Object>() {
						final ByteBuffer buffer = ByteBuffer
								.allocate(1024 * 1024);

						public void completed(AsynchronousSocketChannel result,
								Object attachment) {
							buffer.clear();
							try {
								result.read(buffer).get(100, TimeUnit.SECONDS);
								buffer.flip();
								String str = new String(buffer.array());
								System.out.println("Received message: " + str);

								result.write(ByteBuffer
										.wrap("Response from server."
												.getBytes()));
							} catch (Exception e) {
								e.printStackTrace();
							} finally {
								try {
									result.close();
									server.accept(null, this);
								} catch (IOException e) {
									e.printStackTrace();
								}
							}
						}

						public void failed(Throwable exc, Object attachment) {
							System.out.println("Failed: " + exc);
						}
					});
			while (true) {
				System.out.println("Server main thread.");
				try {
					Thread.sleep(1000 * 60 * 60 * 24 * 365 * 100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static void main(String[] args) {
		new Server().startServer();
	}
}


package com.my.study.io.aio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;

public class Client {
	private AsynchronousSocketChannel client;

	private void start() {
		try {
			client = AsynchronousSocketChannel.open();
		} catch (IOException e) {
			e.printStackTrace();
			return;
		}

		client.connect(new InetSocketAddress("127.0.0.1", 8888), null,
				new CompletionHandler<Void, Object>() {
					public void completed(Void result, Object attachment) {
						client.write(ByteBuffer
								.wrap("Request message from client.".getBytes()));
					}

					public void failed(Throwable exc, Object attachment) {
						System.out.println("Connect Failed: " + exc);
					}
				});

		final ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024);
		client.read(buffer, null, new CompletionHandler<Integer, Object>() {
			public void completed(Integer result, Object attachment) {
				String str = new String(buffer.array());
				System.out.println("Response from server: " + str);
			}

			public void failed(Throwable exc, Object attachment) {
				System.out.println("Read Failed: " + exc);
			}
		});
		
		while (true) {
			System.out.println("Client main thread.");
			try {
				Thread.sleep(1000 * 60 * 60 * 24 * 365 * 100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	public static void main(String[] args) {
		new Client().start();
	}
}
 


                

        

        

    

  


    

      

        

            

              
                
                  尘世中迷途小码农
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
java BIO NIO AIO

				
			

			

				

					07-18
				

			

		

		

			
				
Java BIO NIO AIO  Java BIO、NIO、AIO是 Java 中的三种 I/O 模式，每种模式都有其特点和应用场景。下面对每种模式进行详细解释。  Java BIO  Java BIO（ Blocking I/O）是一种同步阻塞式的 I/O 模式，即服务器实现...

			
		

	



                

              
                



	

		

			

				
					
BIO、NIO、AIO理解

				
			

			

				

					qq_56919740的博客
				

				

					04-05
					
					5413
					
				

			

		

		

			
				
一些对BIO、NIO、AIO通信模型的总结

			
		

	



                


  
              

                


	

		

			

				
					
NIO深入剖析

				
			

			

				

					weixin_46633487的博客
				

				

					02-28
					
					1463
					
				

			

		

		

			
				
第四章 JAVA NIO深入剖析
在讲解利用NIO实现通信架构之前，我们需要先来了解一下NIO的基本特点和使用。
4.1 Java NIO 基本介绍

Java NIO（New IO）也有人称之为 java non-blocking IO是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。NIO可以理解为非阻塞IO,传

			
		

	





	

		

			

				
					
BIO与NIO、AIO的区别

				
			

			

				

					IT界的一只菜鸟
				

				

					09-29
					
					1660
					
				

			

		

		

			
				
IO的方式通常分为几种，同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO。
一、BIO
在JDK1.4出来之前，我们建立网络连接的时候采用BIO模式，需要先在服务端启动一个ServerSocket，然后在客户端启动Socket来对服务端进行通信，默认情况下服务端需要对每个请求建立一堆线程等待请求，而客户端发送请求后，先咨询服务端是否有线程相应，如果没有则会一直等待或者遭到拒绝请求，如果有的...

			
		

	



		

			
		



	

		

			

				
					
搞懂BIO  NIO  AIO的原理区别

				
			

			

				

					kfyong的专栏
				

				

					02-01
					
					1315
					
				

			

		

		

			
				
BIO（blocking io）和NIO(non-blocking io) 从同（异）步和阻塞两个维度来区分

同步和异步针对的是，关心的是事件通知的方式。

比如， 你关注某个明星， 想知道他最近的行程。

同步：你自己一直去盯着看他有没有什么行程发布，此时会出现 阻塞和非阻塞的区分： 如果你盯着他的行程发布的事情，

做不了其他事情，那就是阻塞的，你还能去喝水，就是非阻塞的

异步...

			
		

	





	

		

			

				
					
BIO、NIO、AIO详解

				
			

			

				

					一位打工仔的博客
				

				

					06-28
					
					607
					
				

			

		

		

			
				
BIO（Blocking I/O）就是传统的Java IO编程，其相关的类和接口在java.io包下。BIO是同步阻塞的，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善（实现多个客户连接服务器）。服务器端启动一个，注册端口，调用accpet方法监听客户端的Socket连接客户端启动Socket对服务器进行通信，默认情况下服务器端需要对每个客户建立一个线程与之通讯。

			
		

	





	

		

			

				
					
基于java的BIO、NIO、AIO通讯模型代码实现

				
			

			

				

					03-24
				

			

		

		

			
				
Java作为一门广泛使用的开发语言，提供了多种I/O...建议从简单的BIO开始，逐步过渡到更复杂的NIO和AIO，理解其工作原理和异同。同时，注意在实际项目中结合多线程、线程池等技术，以提高整体系统的性能和稳定性。

			
		

	





	

		

			

				
					
Java中BIO、NIO、AIO的理解

				
			

			

				

					08-28
				

			

		

		

			
				
"Java中BIO、NIO、AIO的理解"  Java中BIO、NIO、AIO的理解是Java高性能IO体系设计中三个重要的概念。它们都是Java中IO操作的实现方式，但它们之间有着很大的区别。  首先，我们需要了解什么是同步和异步，什么是阻塞...

			
		

	





	

		

			

				
					
bio nio aio demo

				
			

			

				

					04-11
				

			

		

		

			
				
为了处理与外部世界的交互，Java提供了三种不同的I/O模型：BIO（ Blocking I/O）、NIO（Non-blocking I/O）和AIO（Asynchronous I/O）。这些模型各有优缺点，适用于不同场景。下面我们将深入探讨这三种I/O模型，并...

			
		

	





	

		

			

				
					
一站式学习Java网络编程 全面理解BIO:NIO:AIO1

				
			

			

				

					08-08
				

			

		

		

			
				
全面理解 Java 网络编程 - BIO、NIO、AIO  本课程旨在帮助学生全面理解 Java 网络编程中的 BIO、NIO、AIO 三剑客，掌握 RPC 编程的基础知识，并结合实战项目巩固所学。  一、网络编程三剑客 - BIO、NIO、AIO  BIO...

			
		

	





	

		

			

				
					
以Java的视角来聊聊BIO、NIO与AIO的区别

				
			

			

				

					Java仗剑走天涯
				

				

					08-09
					
					671
					
				

			

		

		

			
				
以Java的视角来聊聊BIO、NIO与AIO的区别

			
		

	





	

		

			

				
					
从理论到实践：深度解读BIO、NIO、AIO的优缺点及使用场景

					
最新发布

				
			

			

				

					weixin_45131680的博客
				

				

					04-18
					
					1038
					
				

			

		

		

			
				
BIO适合连接数目较少且固定的架构，NIO适合连接数目多，但是并发读写操作相对较少的场景，AIO则适合连接数目多，且并发读写操作也多的场景。可以发现，AIO和NIO的使用方式基本一致，数据都是从Channel读入Buffer，或者从Buffer写入Channel中，不同的是AIO是实现了异步非阻塞。）， 通过上面代码和运行结果可以发现，在服务端和客户端进行通信时，我们并没有新建线程类进行通信，这也是NIO和BIO最大的区别之一。NIO适合一些复杂的、高频的、长连接的通信场景，例如聊天室、网络游戏等。

			
		

	





	

		

			

				
					
nio的优势_BIO、NIO、AIO 介绍和适用场景分析

				
			

			

				

					weixin_39640203的博客
				

				

					12-23
					
					198
					
				

			

		

		

			
				
IO的方式通常分为几种，同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO。一、同步阻塞的BIO在JDK1.4之前，我们建立网络连接的时候采用BIO模式，需要先在服务端启动一个serverSocket，然后在客户端启动socket来对服务端进行通信，默认情况下服务端需要对每个请求建立一堆线程等待请求，而客户端发送请求后，先咨询服务端是否有线程相应，如果没有则会一直等待或者遭到拒绝请求，如果有...

			
		

	





	

		

			

				
					
BIO、NIO、AIO区别

				
			

			

				

					libaowenBlog的博客
				

				

					06-26
					
					2248
					
				

			

		

		

			
				
1、BIO的特点就是每次一个客户端接入，都要在服务端创建一个线程来服务于这个客户端，所以如果有很多个客户端，就会对应成千上万个服务端线程，这会导致服务端负载过高，甚至卡死。2、NIO是同步非阻塞io,客户端和服务器端通过channel(通道)通讯，实现了多路复用 3、AIO是NIO的升级，实现了异步非阻塞，异步IO的操作基于事件和回调机制 buffer实际上是一个容器，内部通过一个连续的字节数组存储I/O上的数据，在nio中，channel在文件、网络上对数据的读取或是写入都必须通过bufferselect

			
		

	





	

		

			

				
					
简答的BIO,NIO，AIO理解

				
			

			

				

					sdp1103285470的博客
				

				

					08-06
					
					138
					
				

			

		

		

			
				
在网上看了很多关于Java IO机制的讲解，其实很难得到一个标准得答案，而且不那么容易吸收，所以，我总结了一些自己关于BIO,NIO,AIO得理解，如有不妥，还望指教。





首先，我们需要理解什么是阻塞，什么是非阻塞：


阻塞：在访问资源的时候，如果资源准备好了就直接访问，如果资源没有准备好，就阻塞在读取资源的方法上或者别的地方，等待资源准备完成，期间不能做任何别的事情。

非阻塞：在...

			
		

	





	

		

			

				
					
BIO，NIO，AIO的区别

					
热门推荐

				
			

			

				

					qxy_1218的博客
				

				

					04-03
					
					1万+
					
				

			

		

		

			
				
BIO，NIO和AIO是Java网络编程的三种模型

BIO：同步并阻塞，服务实现模式为一个连接对应一个线程，即客户端发送一个连接，服务端要有一个线程来处理。如果连接多了，线程数量不够，就只能等待，即会发生阻塞。

NIO：同步非阻塞，服务实现模式是一个线程可以处理多个连接，即客户端发送的连接都会注册到多路复用器上，然后进行轮询连接，有I/O请求就处理

AIO：异步非阻塞，引入了异步通道，采用的是proactor模式，特点是：有效的请求才启动线程，先有操作系统完成在通知服务端



应用场景：

BIO：

			
		

	





	

		

			

				
					
java aio事件模型_Java三种IO模型原理实例详解

				
			

			

				

					weixin_30794381的博客
				

				

					02-13
					
					1228
					
				

			

		

		

			
				
Java中IO的模型分为三种，同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO。BIO【同步阻塞】在JDK1.4出来之前，我们建立网络连接的时候采用BIO模式，需要先在服务端启动一个ServerSocket，然后在客户端启动Socket来对服务端进行通信，默认情况下服务端需要对每个请求建立一堆线程等待请求，而客户端发送请求后，先咨询服务端是否有线程相应，如果没有则会一直等待或者遭到拒绝请求...

			
		

	





	

		

			

				
					
JAVA NIO 简介

				
			

			

				

					阿里巴巴B2B诚信开发部
				

				

					12-06
					
					329
					
				

			

		

		

			
				
1.
  基本





概念





IO

是主存和外部设备
(

硬盘、终端和网络等
)

拷贝数据的过程。
IO

是操作系统的底层功能实现，底层通过
I/O

指令进行完成。


所有语言运行时系统提供执行
I/O

较高级别的工具。
(c

的
printf scanf,java

的面向对象封装
)
...

			
		

	





	

		

			

				
					
Java中的NIO，BIO，AIO定义

				
			

			

				

					yanghaitao的博客
				

				

					06-27
					
					698
					
				

			

		

		

			
				
BIO 
同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。 
BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解。
NIO  
同步非阻塞，服务器实现模式为一个请求一个线程，即客户

			
		

	





	

		

			

				
					
java nio bio aio

				
			

			

				

					05-23
				

			

		

		

			
				
Java NIO、BIO 和 AIO 是 Java 中的三种不同的 I/O 编程模型。  BIO (Blocking IO) 是传统的 I/O 模型，它是同步阻塞的，也就是说，在进行 I/O 操作时，线程会一直阻塞直到数据准备好并返回。这种模型的缺点是效率...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值