Java NIO详解：提升Java代码效率的关键技术

java

需积分: 10 96 浏览量更新于2024-07-26 收藏 2.93MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

"Java NIO 是Java平台中的非阻塞I/O模型，它在Java 1.4版本中被引入，极大地提升了Java程序处理I/O的效率。此PDF文档详细阐述了Java NIO的特性、优点，并通过实例帮助读者理解和应用这些特性。尽管文档为英文版，但它对Java程序员面临的I/O挑战提供了深入的解决方案，探讨了如何利用NIO提升响应性、可扩展性和可靠性。此外，由于NIO API是对1.3版本I/O功能的补充，而非替代，文档还指导读者在何时应使用新API，何时旧的1.3 I/O API更适合特定的应用场景。" Java NIO（New Input/Output）是一个重要的Java编程概念，它的出现使得Java开发者能够以更高效的方式处理I/O操作。传统的Java I/O基于流(Stream)且是阻塞的，这意味着在读写数据时，线程会被阻塞，直到操作完成。而NIO则引入了通道(Channel)和缓冲区(Buffer)的概念，允许进行非阻塞I/O操作，从而提高了多路复用和并发性能。 1.1 I/O Versus CPU Time：在传统I/O模型中，CPU经常处于空闲状态，等待I/O操作完成。NIO通过非阻塞I/O解决了这个问题，使得CPU可以在等待I/O时执行其他任务，提高整体程序效率。 1.2 No Longer CPU Bound：NIO使Java程序不再受限于CPU，因为它们可以同时处理多个I/O请求，而无需等待每个请求的完成。 1.3 Getting to the Good Stuff：Java NIO的核心组件包括选择器(Selector)、通道(Channel)和缓冲区(Buffer)。选择器允许单个线程监控多个通道的事件，如读写就绪，从而实现高效的多路复用。通道提供了与不同类型的I/O源（如文件、套接字等）交互的能力，而缓冲区则用于存储数据，提供了一种更有效的方式来管理数据读写。 1.4 I/O Concepts：文档会详细讲解缓冲区的使用方法，如何创建、填充、清空和读取缓冲区，以及通道的打开、关闭和读写操作。还会介绍选择器的使用，如何注册通道并监听感兴趣的事件，以及如何处理这些事件。 Java NIO是Java开发高性能服务器和网络应用程序的关键技术，对于任何希望提升Java应用I/O性能的开发者来说，这份文档都是宝贵的参考资料。通过学习NIO，开发者可以编写出更加高效、并发能力更强的代码，特别是在处理大量并发连接或大数据传输时。

资源详情

资源推荐

Java NIO

1.3 Getting to the Good Stuff

Most of the development effort that goes into operating systems is targeted at improving I/O

performance. Lots of very smart people toil very long hours perfecting techniques for

schlepping data back and forth. Operating-system vendors expend vast amounts of time and

money seeking a competitive advantage by beating the other guys in this or that published

benchmark.

Today's operating systems are modern marvels of software engineering (OK, some are more

marvelous than others), but how can the Java programmer take advantage of all this wizardry

and still remain platform-independent? Ah, yet another example of the TANSTAAFL

principle.

The JVM is a double-edged sword. It provides a uniform operating environment that shelters

the Java programmer from most of the annoying differences between operating-system

environments. This makes it faster and easier to write code because platform-specific

idiosyncrasies are mostly hidden. But cloaking the specifics of the operating system means

that the jazzy, wiz-bang stuff is invisible too.

What to do? If you're a developer, you could write some native code using the Java Native

Interface (JNI) to access the operating-system features directly. Doing so ties you to a specific

operating system (and maybe a specific version of that operating system) and exposes the

JVM to corruption or crashes if your native code is not 100% bug free. If you're an operating-

system vendor, you could write native code and ship it with your JVM implementation to

provide these features as a Java API. But doing so might violate the license you signed to

provide a conforming JVM. Sun took Microsoft to court about this over the JDirect package

which, of course, worked only on Microsoft systems. Or, as a last resort, you could turn to

another language to implement performance-critical applications.

The

java.nio

package provides new abstractions to address this problem. The Channel and

Selector classes in particular provide generic APIs to I/O services that were not reachable

prior to JDK 1.4. The TANSTAAFL principle still applies: you won't be able to access every

feature of every operating system, but these new classes provide a powerful new framework

that encompasses the high-performance I/O features commonly available on commercial

operating systems today. Additionally, a new Service Provider Interface (SPI) is provided in

java.nio.channels.spi

that allows you to plug in new types of channels and selectors

without violating compliance with the specifications.

With the addition of NIO, Java is ready for serious business, entertainment, scientific and

academic applications in which high-performance I/O is essential.

The JDK 1.4 release contains many other significant improvements in addition to NIO. As of

1.4, the Java platform has reached a high level of maturity, and there are few application areas

remaining that Java cannot tackle. A great guide to the full spectrum of JDK features in 1.4 is

Java In A Nutshell, Fourth Edition by David Flanagan (O'Reilly).

There Ain't No Such Thing As A Free Lunch.

Java NIO

1.4 I/O Concepts

The Java platform provides a rich set of I/O metaphors. Some of these metaphors are more

abstract than others. With all abstractions, the further you get from hard, cold reality,

the tougher it becomes to connect cause and effect. The NIO packages of JDK 1.4 introduce

a new set of abstractions for doing I/O. Unlike previous packages, these are focused on

shortening the distance between abstraction and reality. The NIO abstractions have very real

and direct interactions with real-world entities. Understanding these new abstractions and, just

as importantly, the I/O services they interact with, is key to making the most of I/O-intensive

Java applications.

This book assumes that you are familiar with basic I/O concepts. This section provides

a whirlwind review of some basic ideas just to lay the groundwork for the discussion of how

the new NIO classes operate. These classes model I/O functions, so it's necessary to grasp

how things work at the operating-system level to understand the new I/O paradigms.

In the main body of this book, it's important to understand the following topics:

•

Buffer handling

• Kernel versus user space

• Virtual memory

• Paging

• File-oriented versus stream I/O

•

Multiplexed I/O (readiness selection)

1.4.1 Buffer Handling

Buffers, and how buffers are handled, are the basis of all I/O. The very term "input/output"

means nothing more than moving data in and out of buffers.

Processes perform I/O by requesting of the operating system that data be drained from

a buffer (write) or that a buffer be filled with data (read). That's really all it boils down to. All

data moves in or out of a process by this mechanism. The machinery inside the operating

system that performs these transfers can be incredibly complex, but conceptually, it's very

straightforward.

Figure 1-1 shows a simplified logical diagram of how block data moves from an external

source, such as a disk, to a memory area inside a running process. The process requests that

its buffer be filled by making the read( ) system call. This results in the kernel issuing

a command to the disk controller hardware to fetch the data from disk. The disk controller

writes the data directly into a kernel memory buffer by DMA without further assistance from

the main CPU. Once the disk controller finishes filling the buffer, the kernel copies the data

from the temporary buffer in kernel space to the buffer specified by the process when it

requested the read( ) operation.

Java NIO

Figure 1-1. Simplified I/O buffer handling

This obviously glosses over a lot of details, but it shows the basic steps involved.

Note the concepts of user space and kernel space in Figure 1-1. User space is where regular

processes live. The JVM is a regular process and dwells in user space. User space is

a nonprivileged area: code executing there cannot directly access hardware devices, for

example. Kernel space is where the operating system lives. Kernel code has special privileges:

it can communicate with device controllers, manipulate the state of processes in user space,

etc. Most importantly, all I/O flows through kernel space, either directly (as decsribed here) or

indirectly (see Section 1.4.2).

When a process requests an I/O operation, it performs a system call, sometimes known as

a trap, which transfers control into the kernel. The low-level open( ), read( ), write( ), and

close( ) functions so familiar to C/C++ coders do nothing more than set up and perform the

appropriate system calls. When the kernel is called in this way, it takes whatever steps are

necessary to find the data the process is requesting and transfer it into the specified buffer in

user space. The kernel tries to cache and/or prefetch data, so the data being requested by the

process may already be available in kernel space. If so, the data requested by the process is

copied out. If the data isn't available, the process is suspended while the kernel goes about

bringing the data into memory.

Looking at Figure 1-1, it's probably occurred to you that copying from kernel space to the

final user buffer seems like extra work. Why not tell the disk controller to send it directly to

the buffer in user space? There are a couple of problems with this. First, hardware is usually

not able to access user space directly.

Second, block-oriented hardware devices such as disk

controllers operate on fixed-size data blocks. The user process may be requesting an oddly

sized or misaligned chunk of data. The kernel plays the role of intermediary, breaking down

and reassembling data as it moves between user space and storage devices.

1.4.1.1 Scatter/gather

Many operating systems can make the assembly/disassembly process even more efficient. The

notion of scatter/gather allows a process to pass a list of buffer addresses to the operating

system in one system call. The kernel can then fill or drain the multiple buffers in sequence,

scattering the data to multiple user space buffers on a read, or gathering from several buffers

on a write (Figure 1-2).

There are many reasons for this, all of which are beyond the scope of this book. Hardware devices usually cannot directly use virtual memory

addresses.

Java NIO

Figure 1-4. Memory pages

1.4.3 Memory Paging

To support the second attribute of virtual memory (having an addressable space larger than

physical memory), it's necessary to do virtual memory paging (often referred to as swapping,

though true swapping is done at the process level, not the page level). This is a scheme

whereby the pages of a virtual memory space can be persisted to external disk storage to make

room in physical memory for other virtual pages. Essentially, physical memory acts as a

cache for a paging area, which is the space on disk where the content of memory pages is

stored when forced out of physical memory.

Figure 1-5 shows virtual pages belonging to four processes, each with its own virtual memory

space. Two of the five pages for Process A are loaded into memory; the others are stored on

disk.

Figure 1-5. Physical memory as a paging-area cache

Aligning memory page sizes as multiples of the disk block size allows the kernel to issue

direct commands to the disk controller hardware to write memory pages to disk or reload

them when needed. It turns out that all disk I/O is done at the page level. This is the only way

data ever moves between disk and physical memory in modern, paged operating systems.

Modern CPUs contain a subsystem known as the Memory Management Unit (MMU). This

device logically sits between the CPU and physical memory. It contains the mapping

information needed to translate virtual addresses to physical memory addresses. When

the CPU references a memory location, the MMU determines which page the location resides

in (usually by shifting or masking the bits of the address value) and translates that virtual page

number to a physical page number (this is done in hardware and is extremely fast). If there is

no mapping currently in effect between that virtual page and a physical memory page, the

MMU raises a page fault to the CPU.

A page fault results in a trap, similar to a system call, which vectors control into the kernel

along with information about which virtual address caused the fault. The kernel then takes

steps to validate the page. The kernel will schedule a pagein operation to read the content of

the missing page back into physical memory. This often results in another page being stolen

to make room for the incoming page. In such a case, if the stolen page is dirty (changed since

剩余253页未读，继续阅读

Njdezhang

粉丝: 2
资源: 6

Java NIO详解：提升Java代码效率的关键技术

JavaNIO.pdf

java nio.pdf

Java 7 NIO.2 深入解析

深入理解Java 7 NIO.2：核心特性与实战

深入理解Java 7 NIO.2：核心路径与文件操作

精通Java I/O、NIO与NIO.2：高效数据访问指南

java nio pdf教程下载

java.nio.file.DirectoryNotEmptyException: D:\opt\upFiles\pdf\2023-07-26

java html转pdf

jdk8 获取pdf页数

itext7通过html生成pdf怎么写

java ofd转PDF

java ofd转pdf

javahtml转pdf

加载pdf_Java 插入附件到PDF文档

java html动态模板替换生成pdf

java ofd的base64字符串转pdf的base64字符串

java pdf转byte[]

FileInputStream下载文件

java pdf 转html 还原其格式

最新资源