Java NIO (New Input/Output) is a new I/O operation method provided by Java. Compared with the traditional Java I/O API, it can handle a large number of concurrent connections more efficiently. This article will introduce in detail the core components of Java NIO, including Channel, Buffer and Selector, as well as other auxiliary classes and interfaces.
1. Channel
Channel is one of the core components in Java NIO. It is similar to a traditional IO stream and is responsible for reading and writing data. The difference is that Channel can perform read and write operations at the same time, while traditional IO streams can only read or write in one direction. Channel provides a variety of implementation classes, commonly used ones include FileChannel (file channel), SocketChannel (network socket channel), ServerSocketChannel (network listening socket channel), etc.
1. FileChannel
FileChannel is a channel used for file operations and can read and write files. Its common methods include read(), write(), position(), etc. For example, the contents of a file can be read through a FileChannel:
ByteBuffer buffer = ByteBuffer.allocate(1024);
FileChannel channel = new FileInputStream("file.txt").getChannel();
while (channel.read(buffer) != -1) {<!-- -->
buffer.flip();
// Process the read data
buffer.clear();
}
channel.close();
2. SocketChannel and ServerSocketChannel
SocketChannel and ServerSocketChannel are channels used for network operations. SocketChannel is responsible for communicating with a single client, while ServerSocketChannel is used to listen for client connection requests.
Commonly used methods of SocketChannel include connect(), read(), write(), etc. For example, you can connect to the server via SocketChannel and send data:
SocketChannel channel = SocketChannel.open();
channel.connect(new InetSocketAddress("localhost", 8080));
String message = "Hello Server!";
ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
channel.write(buffer);
channel.close();
Commonly used methods of ServerSocketChannel include bind(), accept(), etc. For example, you can listen to client connection requests through ServerSocketChannel:
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8080));
while (true) {<!-- -->
SocketChannel channel = serverChannel.accept();
// Handle the client's connection request
}
serverChannel.close();
2. Buffer
Buffer is used to store data and is another core component in Java NIO. Buffer is actually an array, and data can be read and written through Buffer. Java NIO provides multiple types of Buffers, commonly used ones are ByteBuffer, CharBuffer, IntBuffer, etc.
Buffer has three important attributes: capacity, position and limit. Capacity is the total size of the Buffer, position represents the index of the next element to be read or written, and limit represents the number of elements that can be read or written.
Commonly used methods of Buffer include put(), get(), flip(), clear(), etc. For example, you can read and write data through Buffer:
ByteBuffer buffer = ByteBuffer.allocate(1024);
buffer.put("Hello".getBytes());
buffer.flip();
while (buffer.hasRemaining()) {<!-- -->
System.out.print((char) buffer.get());
}
buffer.clear();
3. Selector
Selector is another core component in Java NIO and is used to handle multiple Channels efficiently. The Selector will continuously poll the Channels registered on it, and the Selector will return only when at least one Channel is ready for read and write operations.
Through Selector, a single thread can be used to process multiple Channels, which improves the concurrency capability of the system. Commonly used methods of Selector include register(), select(), etc. For example, you can use Selector to handle read and write operations on multiple Channels:
Selector selector = Selector.open();
channel1.register(selector, SelectionKey.OP_READ);
channel2.register(selector, SelectionKey.OP_WRITE);
while (true) {<!-- -->
selector.select();
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectedKeys.iterator();
while (iterator.hasNext()) {<!-- -->
SelectionKey key = iterator.next();
if (key.isReadable()) {<!-- -->
// Handle readable events
} else if (key.isWritable()) {<!-- -->
// Handle writable events
}
iterator.remove();
}
}
selector.close();
4. Auxiliary classes and interfaces
In addition to core components, Java NIO also provides other auxiliary classes and interfaces, such as FileChannel (for file operations), Charset (for character encoding), Pipe (for one-way pipe communication between two threads), etc.
FileChannel is used for read and write operations on files. For example, the contents of a file can be read through FileChannel:
ByteBuffer buffer = ByteBuffer.allocate(1024);
FileChannel channel = new FileInputStream("file.txt").getChannel();
while (channel.read(buffer) != -1) {<!-- -->
buffer.flip();
// Process the read data
buffer.clear();
}
channel.close();
Charset is used for character encoding and decoding. For example, you can use Charset to convert a string into a byte array:
Charset charset = Charset.forName("UTF-8");
ByteBuffer buffer = charset.encode("Hello");
while (buffer.hasRemaining()) {<!-- -->
System.out.print((char) buffer.get());
}
Pipe is used for one-way pipe communication between two threads. For example, the producer-consumer model can be implemented through Pipe:
Pipe pipe = Pipe.open();
Pipe.SinkChannel sinkChannel = pipe.sink();
new Thread(() -> {<!-- -->
String message = "Hello World!";
ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
try {<!-- -->
sinkChannel.write(buffer);
} catch (IOException e) {<!-- -->
e.printStackTrace();
}
}).start();
Pipe.SourceChannel sourceChannel = pipe.source();
ByteBuffer buffer = ByteBuffer.allocate(1024);
sourceChannel.read(buffer);
buffer.flip();
System.out.println(new String(buffer.array()));
5. Advantages of Java NIO
Java NIO has the following advantages compared to traditional Java I/O API:
-
Higher performance: Java NIO’s non-blocking mode can better handle a large number of concurrent connections, improving system throughput.
-
Less thread overhead: Through Selector, you can use a single thread to process multiple Channels, reducing the overhead of thread creation and context switching.
-
More flexible operation mode: The combination of Channel and Buffer can achieve more flexible read and write operations, providing more functions and options.
Case
The following provides you with three cases showing how to use Java NIO for file operations, network communication and multiplexing.
Case 1: File copy
public class FileCopyExample {<!-- -->
public static void main(String[] args) throws IOException {<!-- -->
FileChannel sourceChannel = new FileInputStream("source.txt").getChannel();
FileChannel destinationChannel = new FileOutputStream("destination.txt").getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (sourceChannel.read(buffer) != -1) {<!-- -->
buffer.flip();
destinationChannel.write(buffer);
buffer.clear();
}
sourceChannel.close();
destinationChannel.close();
}
}
This case shows how to use FileChannel to copy a file. First, create a source file channel sourceChannel and a destination file channel destinationChannel. Then, use ByteBuffer to read the data of the source file and write it to the target file.
Case 2: Socket communication
public class SocketCommunicationExample {<!-- -->
public static void main(String[] args) throws IOException {<!-- -->
SocketChannel channel = SocketChannel.open();
channel.connect(new InetSocketAddress("localhost", 8080));
String message = "Hello Server!";
ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
channel.write(buffer);
buffer.clear();
channel.read(buffer);
buffer.flip();
String response = new String(buffer.array());
System.out.println("Server response: " + response);
channel.close();
}
}
This case shows how to use SocketChannel for network communication. First, create a SocketChannel and connect to the server. The message is then written to the buffer and sent to the server via SocketChannel. Next, read the server’s response from the SocketChannel and print it out.
Case 3: Multiplexing
public class SelectorExample {<!-- -->
public static void main(String[] args) throws IOException {<!-- -->
Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.configureBlocking(false);
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {<!-- -->
int readyChannels = selector.select();
if (readyChannels == 0) {<!-- -->
continue;
}
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectedKeys.iterator();
while (iterator.hasNext()) {<!-- -->
SelectionKey key = iterator.next();
if (key.isAcceptable()) {<!-- -->
ServerSocketChannel server = (ServerSocketChannel) key.channel();
SocketChannel client = server.accept();
client.configureBlocking(false);
client.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {<!-- -->
SocketChannel client = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = client.read(buffer);
if (bytesRead == -1) {<!-- -->
client.close();
continue;
}
buffer.flip();
String message = new String(buffer.array());
System.out.println("Received message: " + message);
}
iterator.remove();
}
}
}
}
This case shows how to use Selector for multiplexing. First, create a Selector and open a ServerSocketChannel. Then, register the ServerSocketChannel to the Selector and specify the event of interest as OP_ACCEPT. In the loop, wait for ready channels by calling selector.select() and use an iterator to process each ready channel. If it is an OP_ACCEPT event, accept the client connection and register the SocketChannel to the Selector. The event of interest is OP_READ. If it is an OP_READ event, read the data sent by the client and print it out.
These cases demonstrate the application of Java NIO in file operations, network communication, and multiplexing. By using Java NIO, you can improve the performance and scalability of your system and better handle concurrent connections and I/O operations.
Summary:
This article introduces in detail the core components of Java NIO, Channel, Buffer and Selector, as well as some other auxiliary classes and interfaces. By using Java NIO, efficient I/O operations can be achieved and the system’s concurrency capability can be improved. Although Java NIO may be more complex than the traditional Java I/O API, once you master its use, it can unleash greater potential and improve system performance and scalability.