New I/O

New I/O, usually called NIO, is a collection of Java programming language APIs that offer features for intensive I/O operations. It was introduced with the J2SE 1.4 release of Java by Sun Microsystems to complement an existing standard I/O. NIO was developed under the Java Community Process as JSR 51. As of 2006, an extension to NIO, called NIO2, is being developed under JSR 203; JSR 203 is scheduled to be included in Java SE 7 ("Dolphin") [cite web |url=http://www.jcp.org/en/jsr/detail?id=203 |title=JSR 203: More New I/O APIs for the JavaTM Platform ("NIO.2") |accessdate=2008-02-25 |work=The Java Community Process(SM) Program - JSRs: Java Specification Requests ] .

Features and organization

The APIs of NIO were designed to provide access to the low-level I/O operations of modern operating systems. Although the APIs are themselves relatively high-level, the intent is to facilitate an implementation that can directly use the most efficient operations of the underlying platform.

The Java NIO APIs are provided in the Javadoc:SE|package=java.nio|java/nio package and its subpackages. The documentation by Sun Microsystems identifies these features.
* Buffers for data of primitive types
* Character set encoders and decoders
* A pattern-matching facility based on Perl-style regular expressions (in package Javadoc:SE|package=java.util.regex|java/util/regex)
* Channels, a new primitive I/O abstraction
* A file interface that supports locks and memory mapping (see memory-mapped file) of files up to Integer.MAX_SIZE bytes (2 GB)
* A multiplexed, non-blocking I/O facility for writing scalable servers

NIO buffers

NIO data transfer is based on buffers (Javadoc:SE|package=java.nio|java/nio|Buffer and related classes). These classes represent a contiguous extent of memory, together with a small number of data transfer operations. Although theoretically these are general-purpose data structures, the implementation may select memory for alignment or paging characteristics, which are not otherwise accessible in Java. Typically, this would be used to allow the buffer contents to occupy the same physical memory used by the underlying operating system for its native I/O operations, thus allowing the most direct transfer mechanism, and eliminating the need for any additional copying. In most operating systems, provided the particular area of memory has the right properties, transfer can take place without using the CPU at all. The NIO buffer is intentionally limited in features in order to support these goals.

There are buffer classes for all of Java's primitive types except boolean, which can share memory with byte buffers and allow arbitrary interpretation of the underlying bytes.

Some Usage Information for NIO Buffers

NIO buffers maintain several pointers that dictate the function of its accessor methods. The NIO buffer implementation contains a rich set of methods for modifying these pointers:

* The flip() method, rather than performing a "flip" or paging function in the canonical sense, moves the "position" pointer to the origin of the underlying array (if any) and the "limit" pointer to the former position of the "position" pointer.
* Three get() methods are supplied for transferring data out of a NIO buffer. The bulk implementation, rather than performing a "get" in the traditional sense, "puts" the data into a specified array. The "offset" argument supplied to this method refers not to the offset from within the buffer from which to read, nor an offset from the "position" pointer, but rather the offset from 0 within the target array.
* Unless using the absolute get() and put() methods, any get() or put() is conducted from the "position" pointer. Should one need to read from a different position within the underlying array, whilst not adjusting the "writing" position, the mark() and reset() methods have been supplied.
* The mark() method effectively stores the position of the "position" pointer by setting the "mark" pointer to the position of the "position" pointer. The reset() method causes the "position" pointer to move to the "mark" pointer's position.
* It should be noted that the clear() method and the flip() method both return the "mark" pointer to 0.
* It should be noted that the clear() method does not ensure zero-ing of the buffer, but does return the "limit" pointer to the upper boundary of the underlying array, and the "position" pointer to the index.
* put() and get() operations for NIO buffers are not thread safe.
* If a bulk get() operation is executed for a NIO buffer that would cause the "position" pointer to pass the "limit" pointer, the executing thread will block until the "limit" pointer adjusts outward to accommodate the "position" pointer.
* If a get() operation is executed into the underlying array of a readonly NIO buffer, the executing thread will block indefinitely.
* You can only map() a Javadoc:SE|package=java.nio|java/nio|MappedByteBuffer from a Javadoc:SE|package=java.nio.channels|java/nio/channels|FileChannel up to Integer.MAX_VALUE in size (2GB); regions beyond this limit can be accessed using an offset greater than zero.

Channels

Channels (classes implementing the interface Javadoc:SE|package=java.nio.channels|java/nio/channels|Channel) are designed to provide for bulk data transfers to and from NIO buffers. This is a low-level data transfer mechanism that exists in parallel with the classes of the higher-level I/O library (packages Javadoc:SE|package=java.io|java/io and Javadoc:SE|package=java.net|java/net). A channel implementation can be obtained from a high-level data transfer class such as Javadoc:SE|package=java.io|java/io|File, Javadoc:SE|package=java.net|java/net|ServerSocket, or Javadoc:SE|package=java.net|java/net|Socket, and vice versa.

File channels (Javadoc:SE|package=java.nio.channels|java/nio/channels|FileChannel) can use arbitrary buffers but can also establish a buffer directly mapped to file contents using memory-mapped I/O. They can also interact with file system locks. Similarly, socket channels (Javadoc:SE|package=java.nio.channels|java/nio/channels|SocketChannel and Javadoc:SE|package=java.nio.channels|java/nio/channels|ServerSocketChannel) allow for data transfer between sockets and NIO buffers.

FileChannel can be used to do a file copy, which is potentially far more efficient than using old read/write with a byte array. The typical code for this is: // Getting file channels FileChannel in = new FileInputStream(source).getChannel(); FileChannel out = new FileOutputStream(target).getChannel(); // JavaVM does its best to do this as native I/O operations. in.transferTo (0, in.size(), out); // Closing file channels will close corresponding stream objects as well. out.close(); in.close();

Selectors

A selector (Javadoc:SE|package=java.nio.channels|java/nio/channels|Selector and subclasses) provides a mechanism for waiting on channels and recognizing when one or more become available for data transfer. When a number of channels are registered with the selector, it enables blocking of the program flow until at least one channel is ready for use, or until an interruption condition occurs.

Although this multiplexing behavior could be implemented with Java threads, the selector can provide a significantly more efficient implementation using native platform threads or, more likely, even lower-level operating system constructs. A POSIX-compliant operating system, for example, would have direct representations of these concepts, select(). A notable application of this design would be the common paradigm in server software which involves simultaneously waiting for responses on a number of sessions.

Character sets

In Java, a character set is a mapping between Unicode characters (or a subset of them) and bytes.The Javadoc:SE|package=java.nio.charset|java/nio/charset package of NIO provides facilities for identifying character sets and providing encoding and decoding algorithms for new mappings.

Regular expressions

The regular expression library in the java.util.regex package provides a powerful search facility for character data based on regular expression matching.

The following example was adopted from the [http://java.sun.com/j2se/1.4.2/docs/guide/nio/example/index.html NIO API guide examples] , where there are more examples. import java.io.*; import java.nio.*; import java.nio.channels.*; import java.nio.charset.*; import java.util.regex.*; public class Grep { // Charset and decoder for ISO-8859-15 private static Charset charset = Charset.forName("ISO-8859-15"); private static CharsetDecoder decoder = charset.newDecoder(); // Pattern used to parse lines private static Pattern linePattern = Pattern.compile(".* ? "); // The input pattern that we're looking for private static Pattern pattern; // Compile the pattern from the command line private static void compile(String pat) { try { pattern = Pattern.compile(pat); } catch (PatternSyntaxException x) { System.err.println(x.getMessage()); System.exit(1); } } // Use the linePattern to break the given CharBuffer into lines, applying // the input pattern to each line to see if we have a match private static void grep(File f, CharBuffer cb) { Matcher lm = linePattern.matcher(cb); // Line matcher Matcher pm = null; // Pattern matcher int lines = 0; while (lm.find()) { lines++; CharSequence cs = lm.group(); // The current line if (pm = null) pm = pattern.matcher(cs); else pm.reset(cs); if (pm.find()) System.out.print(f + ":" + lines + ":" + cs); if (lm.end() = cb.limit()) break; } } // Search for occurrences of the input pattern in the given file private static void grep(File f) throws IOException { // Open the file and then get a channel from the stream FileInputStream fis = new FileInputStream(f); FileChannel fc = fis.getChannel(); // Get the file's size and then map it into memory int sz = (int)fc.size(); MappedByteBuffer bb = fc.map(FileChannel.MapMode.READ_ONLY, 0, sz); // Decode the file into a char buffer CharBuffer cb = decoder.decode(bb); // Perform the search grep(f, cb); // Close the channel and the stream fc.close(); } public static void main(String [] args) { if (args.length < 2) { System.err.println("Usage: java Grep pattern file..."); return; } compile(args [0] ); for (int i = 1; i < args.length; i++) { File f = new File(args [i] ); try { grep(f); } catch (IOException x) { System.err.println(f + ": " + x); } } } }

Notes

External links

*
* [http://java.sun.com/j2se/1.5.0/docs/guide/nio/index.html JDK 5.0 New I/O-related APIs & Developer Guides] - description of New I/O by Sun Microsystems
* [http://www.jcp.org/en/jsr/detail?id=51 JSR 51] (NIO)
* [http://www.jcp.org/en/jsr/detail?id=203 JSR 203] (NIO2)
* [http://today.java.net/cs/user/print/a/350 Architecture of a Highly Scalable NIO-Based Server] - discussion on Java NIO and patterns of usage