Sobes.tech
Interview Help
Resources
Interview Preparation
Resources
Job Search
Resources
Legal
Back to questions
Middle

What features of NIO (New Input/Output) do you know?

sobes.tech AI

Answer from AI

NIO provides non-blocking I/O based on channels and buffers. Key features:

  • Channels: Represent open connections to entities capable of performing I/O operations (file, socket). Unlike streams, channels can perform both read and write.

  • Buffers: Fixed-size blocks of memory used for interacting with data through channels. Data from a channel is written into a buffer and then processed. Or data from a program is written into a buffer and then into a channel. Buffers allow more efficient memory management.

  • Selectors: Allow a single thread to handle I/O operations on multiple channels. This is a key feature for implementing non-blocking I/O, as the thread can wait for multiple channels to be ready for operations (read or write).

  • Non-blocking I/O: A thread performing read or write operation through a channel does not block until the operation completes. Instead, it can perform other tasks while data becomes available or the buffer is ready for writing. Channel readiness is checked via a selector.

  • MappedByteBuffer: A buffer that maps a file directly into the process's memory. This can significantly improve performance for large files by avoiding copying data from kernel space to user space.

  • Scatter/Gather I/O: Allows reading data from one channel into multiple buffers (scatter) or writing data from multiple buffers into one channel (gather) in a single operation.

Example of using Selector:

// Example of registering a channel with a selector for read operation
SocketChannel channel = SocketChannel.open();
channel.configureBlocking(false); // Set channel to non-blocking mode

Selector selector = Selector.open();
channel.register(selector, SelectionKey.OP_READ); // Register channel to monitor readiness for reading

Example of using MappedByteBuffer:

import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

// Opening a file and getting its channel
// RandomAccessFile raf = new RandomAccessFile("large_file.txt", "rw");
// FileChannel fileChannel = raf.getChannel();

// Mapping the file into memory
// MappedByteBuffer buffer = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, fileChannel.size());

// Working with the buffer
// byte b = buffer.get(); // Read a byte
// buffer.put(0, (byte) 65); // Write a byte
PreviousNext