- 浏览: 305845 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (165)
- hadoop (47)
- linux (11)
- nutch (7)
- hbase (7)
- solr (4)
- zookeeper (4)
- J2EE (1)
- jquery (3)
- java (17)
- mysql (14)
- perl (2)
- compass (4)
- suse (2)
- memcache (1)
- as (1)
- roller (1)
- web (7)
- MongoDB (8)
- struts2 (3)
- lucene (2)
- 算法 (4)
- 中文分词 (3)
- hive (17)
- noIT (1)
- 中间件 (2)
- maven (2)
- sd (0)
- php (2)
- asdf (0)
- kerberos 安装 (1)
- git (1)
- osgi (1)
- impala (1)
- book (1)
- python 安装 科学计算包 (1)
最新评论
-
dandongsoft:
你写的不好用啊
solr 同义词搜索 -
黎明lm:
meifangzi 写道楼主真厉害 都分析源码了 用了很久. ...
hadoop 源码分析(二) jobClient 通过RPC 代理提交作业到JobTracker -
meifangzi:
楼主真厉害 都分析源码了
hadoop 源码分析(二) jobClient 通过RPC 代理提交作业到JobTracker -
zhdkn:
顶一个,最近也在学习设计模式,发现一个问题,如果老是看别人的博 ...
Java观察者模式(Observer)详解及应用 -
lvwenwen:
木南飘香 写道
高并发网站的架构
使用Java NIO编写高性能的服务器
从JDK 1.5开始,Java的标准库中就包含了NIO,即所谓的“New IO”。其中最重要的功能就是提供了“非阻塞”的IO,当然包括了Socket。NonBlocking的IO就是对select(Unix平台下)以及 WaitForMultipleObjects(Windows平台)的封装,提供了高性能、易伸缩的服务架构。
说来惭愧,直到JDK1.4才有这种功能,但迟到者不一定没有螃蟹吃,NIO就提供了优秀的面向对象的解决方案,可以很方便地编写高性能的服务器。
话说回来,传统的Server/Client实现是基于Thread per request,即服务器为每个客户端请求建立一个线程处理,单独负责处理一个客户的请求。比如像Tomcat(新版本也会提供NIO方案)、Resin等Web服务器就是这样实现的。当然为了减少瞬间峰值问题,服务器一般都使用线程池,规定了同时并发的最大数量,避免了线程的无限增长。
但这样有一个问题:如果线程池的大小为100,当有100个用户同时通过HTTP现在一个大文件时,服务器的线程池会用完,因为所有的线程都在传输大文件了,即使第101个请求者仅仅请求一个只有10字节的页面,服务器也无法响应了,只有等到线程池中有空闲的线程出现。
另外,线程的开销也是很大的,特别是达到了一个临界值后,性能会显著下降,这也限制了传统的Socket方案无法应对并发量大的场合,而“非阻塞”的IO就能轻松解决这个问题。
下面只是一个简单的例子:服务器提供了下载大型文件的功能,客户端连接上服务器的12345端口后,就可以读取服务器发送的文件内容信息了。注意这里的服务器只有一个主线程,没有其他任何派生线程,让我们看看NIO是如何用一个线程处理N个请求的。
NIO服务器最核心的一点就是反应器模式:当有感兴趣的事件发生的,就通知对应的事件处理器去处理这个事件,如果没有,则不处理。所以使用一个线程做轮询就可以了。当然这里这是个例子,如果要获得更高性能,可以使用少量的线程,一个负责接收请求,其他的负责处理请求,特别是对于多CPU时效率会更高。
关于使用NIO过程中出现的问题,最为普遍的就是为什么没有请求时CPU的占用率为100%?出现这种问题的主要原因是注册了不感兴趣的事件,比如如果没有数据要发到客户端,而又注册了写事件(OP_WRITE),则在 Selector.select()上就会始终有事件出现,CPU就一直处理了,而此时select()应该是阻塞的。
另外一个值得注意的问题是:由于只使用了一个线程(多个线程也如此)处理用户请求,所以要避免线程被阻塞,解决方法是事件的处理者必须要即刻返回,不能陷入循环中,否则会影响其他用户的请求速度。
具体到本例子中,由于文件比较大,如果一次性发送整个文件(这里的一次性不是指send整个文件内容,而是通过while循环不间断的发送分组包),则主线程就会阻塞,其他用户就不能响应了。这里的解决方法是当有WRITE事件时,仅仅是发送一个块(比如4K字节)。发完后,继续等待WRITE事件出现,依次处理,直到整个文件发送完毕,这样就不会阻塞其他用户了。
服务器的例子:
package nio.file;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.util.Iterator;
/**
* 测试文件下载的NIOServer
*
* @author tenyears.cn
*/
public class NIOServer {
static int BLOCK = 4096;
// 处理与客户端的交互
public class HandleClient {
protected FileChannel channel;
protected ByteBuffer buffer;
public HandleClient() throws IOException {
this.channel = new FileInputStream(filename).getChannel();
this.buffer = ByteBuffer.allocate(BLOCK);
}
public ByteBuffer readBlock() {
try {
buffer.clear();
int count = channel.read(buffer);
buffer.flip();
if (count <= 0)
return null;
} catch (IOException e) {
e.printStackTrace();
}
return buffer;
}
public void close() {
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
protected Selector selector;
protected String filename = "d:\\bigfile.dat"; // a big file
protected ByteBuffer clientBuffer = ByteBuffer.allocate(BLOCK);
protected CharsetDecoder decoder;
public NIOServer(int port) throws IOException {
selector = this.getSelector(port);
Charset charset = Charset.forName("GB2312");
decoder = charset.newDecoder();
}
// 获取Selector
protected Selector getSelector(int port) throws IOException {
ServerSocketChannel server = ServerSocketChannel.open();
Selector sel = Selector.open();
server.socket().bind(new InetSocketAddress(port));
server.configureBlocking(false);
server.register(sel, SelectionKey.OP_ACCEPT);
return sel;
}
// 监听端口
public void listen() {
try {
for (;;) {
selector.select();
Iterator<selectionkey></selectionkey> iter = selector.selectedKeys()
.iterator();
while (iter.hasNext()) {
SelectionKey key = iter.next();
iter.remove();
handleKey(key);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
// 处理事件
protected void handleKey(SelectionKey key) throws IOException {
if (key.isAcceptable()) { // 接收请求
ServerSocketChannel server = (ServerSocketChannel) key.channel();
SocketChannel channel = server.accept();
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) { // 读信息
SocketChannel channel = (SocketChannel) key.channel();
int count = channel.read(clientBuffer);
if (count > 0) {
clientBuffer.flip();
CharBuffer charBuffer = decoder.decode(clientBuffer);
System.out.println("Client >>" + charBuffer.toString());
SelectionKey wKey = channel.register(selector,
SelectionKey.OP_WRITE);
wKey.attach(new HandleClient());
} else
channel.close();
clientBuffer.clear();
} else if (key.isWritable()) { // 写事件
SocketChannel channel = (SocketChannel) key.channel();
HandleClient handle = (HandleClient) key.attachment();
ByteBuffer block = handle.readBlock();
if (block != null)
channel.write(block);
else {
handle.close();
channel.close();
}
}
}
public static void main(String[] args) {
int port = 12345;
try {
NIOServer server = new NIOServer(port);
System.out.println("Listernint on " + port);
while (true) {
server.listen();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
该代码中,通过一个HandleClient来获取文件的一块数据,每一个客户都会分配一个HandleClient的实例。
下面是客户端请求的代码,也比较简单,模拟100个用户同时下载文件。
package nio.file;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.util.Iterator;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 文件下载客户端
* @author tenyears.cn
*/
public class NIOClient {
static int SIZE = 100;
static InetSocketAddress ip = new InetSocketAddress("localhost",12345);
static CharsetEncoder encoder = Charset.forName("GB2312").newEncoder();
static class Download implements Runnable {
protected int index;
public Download(int index) {
this.index = index;
}
public void run() {
try {
long start = System.currentTimeMillis();
SocketChannel client = SocketChannel.open();
client.configureBlocking(false);
Selector selector = Selector.open();
client.register(selector, SelectionKey.OP_CONNECT);
client.connect(ip);
ByteBuffer buffer = ByteBuffer.allocate(8 * 1024);
int total = 0;
FOR: for (;;) {
selector.select();
Iterator<selectionkey></selectionkey> iter = selector.selectedKeys()
.iterator();
while (iter.hasNext()) {
SelectionKey key = iter.next();
iter.remove();
if (key.isConnectable()) {
SocketChannel channel = (SocketChannel) key
.channel();
if (channel.isConnectionPending())
channel.finishConnect();
channel.write(encoder.encode(CharBuffer
.wrap("Hello from " + index)));
channel.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {
SocketChannel channel = (SocketChannel) key
.channel();
int count = channel.read(buffer);
if (count > 0) {
total += count;
buffer.clear();
} else {
client.close();
break FOR;
}
}
}
}
double last = (System.currentTimeMillis() - start) * 1.0 / 1000;
System.out.println("Thread " + index + " downloaded " + total
+ "bytes in " + last + "s.");
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws IOException {
ExecutorService exec = Executors.newFixedThreadPool(SIZE);
for (int index = 0; index < SIZE; index++) {
exec.execute(new Download(index));
}
exec.shutdown();
}
}
从JDK 1.5开始,Java的标准库中就包含了NIO,即所谓的“New IO”。其中最重要的功能就是提供了“非阻塞”的IO,当然包括了Socket。NonBlocking的IO就是对select(Unix平台下)以及 WaitForMultipleObjects(Windows平台)的封装,提供了高性能、易伸缩的服务架构。
说来惭愧,直到JDK1.4才有这种功能,但迟到者不一定没有螃蟹吃,NIO就提供了优秀的面向对象的解决方案,可以很方便地编写高性能的服务器。
话说回来,传统的Server/Client实现是基于Thread per request,即服务器为每个客户端请求建立一个线程处理,单独负责处理一个客户的请求。比如像Tomcat(新版本也会提供NIO方案)、Resin等Web服务器就是这样实现的。当然为了减少瞬间峰值问题,服务器一般都使用线程池,规定了同时并发的最大数量,避免了线程的无限增长。
但这样有一个问题:如果线程池的大小为100,当有100个用户同时通过HTTP现在一个大文件时,服务器的线程池会用完,因为所有的线程都在传输大文件了,即使第101个请求者仅仅请求一个只有10字节的页面,服务器也无法响应了,只有等到线程池中有空闲的线程出现。
另外,线程的开销也是很大的,特别是达到了一个临界值后,性能会显著下降,这也限制了传统的Socket方案无法应对并发量大的场合,而“非阻塞”的IO就能轻松解决这个问题。
下面只是一个简单的例子:服务器提供了下载大型文件的功能,客户端连接上服务器的12345端口后,就可以读取服务器发送的文件内容信息了。注意这里的服务器只有一个主线程,没有其他任何派生线程,让我们看看NIO是如何用一个线程处理N个请求的。
NIO服务器最核心的一点就是反应器模式:当有感兴趣的事件发生的,就通知对应的事件处理器去处理这个事件,如果没有,则不处理。所以使用一个线程做轮询就可以了。当然这里这是个例子,如果要获得更高性能,可以使用少量的线程,一个负责接收请求,其他的负责处理请求,特别是对于多CPU时效率会更高。
关于使用NIO过程中出现的问题,最为普遍的就是为什么没有请求时CPU的占用率为100%?出现这种问题的主要原因是注册了不感兴趣的事件,比如如果没有数据要发到客户端,而又注册了写事件(OP_WRITE),则在 Selector.select()上就会始终有事件出现,CPU就一直处理了,而此时select()应该是阻塞的。
另外一个值得注意的问题是:由于只使用了一个线程(多个线程也如此)处理用户请求,所以要避免线程被阻塞,解决方法是事件的处理者必须要即刻返回,不能陷入循环中,否则会影响其他用户的请求速度。
具体到本例子中,由于文件比较大,如果一次性发送整个文件(这里的一次性不是指send整个文件内容,而是通过while循环不间断的发送分组包),则主线程就会阻塞,其他用户就不能响应了。这里的解决方法是当有WRITE事件时,仅仅是发送一个块(比如4K字节)。发完后,继续等待WRITE事件出现,依次处理,直到整个文件发送完毕,这样就不会阻塞其他用户了。
服务器的例子:
package nio.file;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.util.Iterator;
/**
* 测试文件下载的NIOServer
*
* @author tenyears.cn
*/
public class NIOServer {
static int BLOCK = 4096;
// 处理与客户端的交互
public class HandleClient {
protected FileChannel channel;
protected ByteBuffer buffer;
public HandleClient() throws IOException {
this.channel = new FileInputStream(filename).getChannel();
this.buffer = ByteBuffer.allocate(BLOCK);
}
public ByteBuffer readBlock() {
try {
buffer.clear();
int count = channel.read(buffer);
buffer.flip();
if (count <= 0)
return null;
} catch (IOException e) {
e.printStackTrace();
}
return buffer;
}
public void close() {
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
protected Selector selector;
protected String filename = "d:\\bigfile.dat"; // a big file
protected ByteBuffer clientBuffer = ByteBuffer.allocate(BLOCK);
protected CharsetDecoder decoder;
public NIOServer(int port) throws IOException {
selector = this.getSelector(port);
Charset charset = Charset.forName("GB2312");
decoder = charset.newDecoder();
}
// 获取Selector
protected Selector getSelector(int port) throws IOException {
ServerSocketChannel server = ServerSocketChannel.open();
Selector sel = Selector.open();
server.socket().bind(new InetSocketAddress(port));
server.configureBlocking(false);
server.register(sel, SelectionKey.OP_ACCEPT);
return sel;
}
// 监听端口
public void listen() {
try {
for (;;) {
selector.select();
Iterator<selectionkey></selectionkey> iter = selector.selectedKeys()
.iterator();
while (iter.hasNext()) {
SelectionKey key = iter.next();
iter.remove();
handleKey(key);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
// 处理事件
protected void handleKey(SelectionKey key) throws IOException {
if (key.isAcceptable()) { // 接收请求
ServerSocketChannel server = (ServerSocketChannel) key.channel();
SocketChannel channel = server.accept();
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) { // 读信息
SocketChannel channel = (SocketChannel) key.channel();
int count = channel.read(clientBuffer);
if (count > 0) {
clientBuffer.flip();
CharBuffer charBuffer = decoder.decode(clientBuffer);
System.out.println("Client >>" + charBuffer.toString());
SelectionKey wKey = channel.register(selector,
SelectionKey.OP_WRITE);
wKey.attach(new HandleClient());
} else
channel.close();
clientBuffer.clear();
} else if (key.isWritable()) { // 写事件
SocketChannel channel = (SocketChannel) key.channel();
HandleClient handle = (HandleClient) key.attachment();
ByteBuffer block = handle.readBlock();
if (block != null)
channel.write(block);
else {
handle.close();
channel.close();
}
}
}
public static void main(String[] args) {
int port = 12345;
try {
NIOServer server = new NIOServer(port);
System.out.println("Listernint on " + port);
while (true) {
server.listen();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
该代码中,通过一个HandleClient来获取文件的一块数据,每一个客户都会分配一个HandleClient的实例。
下面是客户端请求的代码,也比较简单,模拟100个用户同时下载文件。
package nio.file;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.util.Iterator;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 文件下载客户端
* @author tenyears.cn
*/
public class NIOClient {
static int SIZE = 100;
static InetSocketAddress ip = new InetSocketAddress("localhost",12345);
static CharsetEncoder encoder = Charset.forName("GB2312").newEncoder();
static class Download implements Runnable {
protected int index;
public Download(int index) {
this.index = index;
}
public void run() {
try {
long start = System.currentTimeMillis();
SocketChannel client = SocketChannel.open();
client.configureBlocking(false);
Selector selector = Selector.open();
client.register(selector, SelectionKey.OP_CONNECT);
client.connect(ip);
ByteBuffer buffer = ByteBuffer.allocate(8 * 1024);
int total = 0;
FOR: for (;;) {
selector.select();
Iterator<selectionkey></selectionkey> iter = selector.selectedKeys()
.iterator();
while (iter.hasNext()) {
SelectionKey key = iter.next();
iter.remove();
if (key.isConnectable()) {
SocketChannel channel = (SocketChannel) key
.channel();
if (channel.isConnectionPending())
channel.finishConnect();
channel.write(encoder.encode(CharBuffer
.wrap("Hello from " + index)));
channel.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {
SocketChannel channel = (SocketChannel) key
.channel();
int count = channel.read(buffer);
if (count > 0) {
total += count;
buffer.clear();
} else {
client.close();
break FOR;
}
}
}
}
double last = (System.currentTimeMillis() - start) * 1.0 / 1000;
System.out.println("Thread " + index + " downloaded " + total
+ "bytes in " + last + "s.");
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws IOException {
ExecutorService exec = Executors.newFixedThreadPool(SIZE);
for (int index = 0; index < SIZE; index++) {
exec.execute(new Download(index));
}
exec.shutdown();
}
}
发表评论
-
博客地址变更
2013-08-16 10:29 1218all the guys of visiting the bl ... -
java 中object 方法
2012-11-02 07:39 1588Java中Object的方法 构造方法摘要 Object() ... -
java 容易引起内存泄漏的几大原因
2012-02-14 16:01 1776容易引起内存泄漏的几 ... -
jvm 调优2
2012-02-09 17:37 55B-树 是一种多路搜索树(并不是二叉的): 1 ... -
java 反射机制
2012-02-09 11:24 1085JAVA反射机制的学习 JAVA语言中的反射机制: ... -
java nio 编程
2012-02-06 14:13 1093转自:http://yangguangfu.iteye.com ... -
JVM学习笔记-方法区示例与常量池解析
2012-01-30 09:36 1472JVM学习笔记-方法区示例与常量池解析(Method Area ... -
JVM调优 (2)
2012-01-13 14:00 870JVM调优 1. Heap设定与垃圾回收 J ... -
jvm 启动参数
2012-01-13 13:58 973转载自:http://www.blogjava ... -
Java虚拟机(JVM)参数简介
2012-01-13 13:14 1290Java虚拟机(JVM)参数简介 在Java、J2EE大型 ... -
Java 哈夫曼编码反编码的实现
2011-12-23 09:52 1317Java 哈夫曼编码反编码 ... -
离线并发与锁机制
2011-12-15 15:47 908离线并发与锁机制 离线并发的来源 在W ... -
Java观察者模式(Observer)详解及应用
2011-12-14 11:19 4840Java观察者模式(Observer)详解及应用 由于网站 ... -
解决zookeeper linux下无法启动的问题
2011-12-05 14:20 4765在linux下安装zookeeper时,出现了如下的错误: ... -
jvm 参数设置
2011-10-18 16:01 1132jvm 参数设置 /usr/local/jdk/bin/ja ... -
eclipse 成功发布工程 但访问不到项目
2011-09-29 17:48 1363前提: 将其他的 工程 copy 一份修改了名字 在eclip ... -
java 生成 静态html
2011-09-15 15:43 1580java 生成html 网上的大部分资料都是 用 ##tit ...
相关推荐
### 使用Java NIO编写高性能服务器的关键知识点 #### 一、NIO概述 - **NIO简介**:NIO(New IO)自JDK 1.4引入以来,为Java提供了非阻塞IO的支持,这对于提高服务端应用的性能至关重要。NIO的核心特性包括缓冲区...
在高性能服务器开发中,Java NIO扮演着至关重要的角色。传统的IO模型在高并发场景下,由于每个连接都需要一个线程来处理,当连接数量增加时,线程数量也随之增加,最终可能导致系统资源耗尽。而NIO通过选择器...
服务器使用ServerSocketChannel监听特定端口,SocketChannel代表客户端连接。当有新的连接请求到达时,服务器创建一个ByteBuffer用于读取文件内容,并将其发送给客户端。在处理过程中,服务器需要注意避免阻塞,例如...
NIO在实际开发中常用于构建高性能的网络服务器,如Tomcat、Netty等框架就大量使用了NIO技术。通过合理使用NIO,开发者可以编写出更加高效、可扩展的服务端代码。了解和掌握Java NIO对于提升Java程序员在服务器端编程...
1. **高并发服务器**:NIO在开发高性能、大并发的服务器时非常有用,例如聊天服务器、游戏服务器等。 2. **文件操作**:NIO提供了高效、灵活的文件读写能力,特别是对于大数据处理,如日志分析、文件复制等。 3. *...
10. **案例分析**:书中可能会通过实际的案例来展示如何使用NIO构建高性能的网络服务器,或者优化文件读写操作。 《Java NIO》这本书对于理解和掌握Java NIO技术至关重要,无论你是Java开发者还是系统架构师,都能...
总之,Java NIO流和通道的使用能显著提升Java应用的I/O性能,尤其在处理高并发和大数据量的场景下。通过本教程的学习,开发者不仅可以掌握NIO的基本概念,还能了解其在实际开发中的应用,为编写高效、灵活的Java程序...
Netty框架是一个优秀的NIO库,广泛应用于高性能服务器开发。 "服务器架构"这部分,通常涉及如何设计和组织服务器的各个组件,以确保可扩展性、稳定性和性能。常见的服务器架构有微服务架构、SOA(Service-Oriented ...
Mina是一个完全由Java编写的NIO框架,而Netty则是由JBOSS提供的一个高性能的异步事件驱动的网络应用框架,它们都是基于Java反应器模式设计的,用于处理大量并发连接的场景。 综上所述,基于Java NIO的反应器模式...
通过学习《Java NIO》,开发者可以掌握如何构建高性能、低延迟的网络应用,特别是在处理大数据、分布式系统和高并发场景时,NIO的优势尤为突出。配合Java的并发工具和设计模式,可以编写出更加健壮和高效的服务器端...
Java NIO(New IO)是Java...通过以上介绍的知识点,你可以开始编写基于NIO的应用,例如使用SocketChannel实现一个简单的非阻塞服务器。在实际编码时,参考博文链接中的代码实例,可以帮助你更好地理解和实践Java NIO。
Java NIO(New IO)是Java 1.4版本引入的一个新特性,它为Java提供了新的I/O操作方式,与传统的Java IO相比,NIO具有更高效、更灵活的特性,尤其是在处理大量并发I/O操作时。本篇将详细探讨Java NIO在写文件方面的...
在实际开发中,NIO常被应用于网络编程、文件系统操作以及高性能服务器的设计等领域。例如,使用NIO可以构建一个简单的聊天服务器,或者创建一个处理大量并发HTTP请求的Web服务器。通过深入理解NIO,你可以更好地优化...