Java NIO stands for Non-Blocking Input-output, it is
enhanced version of IO package, by using this library you can develop high-performance
IO applications.
NIO packages is available from JDK 1.4 (or) higher platforms.
JAVA NIO2 (It is an extension of IO and NIO. It offers
native file access, Watcher service to watch directory for CRUD events,
directory structure exploration API etc.,) is introduced in JDK 1.7. In this
tutorial series, you are going to learn Java NIO and NIO2.
What is input stream?
Input stream is something that is used to read data from
an entity like a file, socket, url etc.,
What is output
stream?
output stream is something that is used to write data to
a file, socket etc.,
Nio vs IO
a. Major difference between NIO and IO is, IO is blocking, whereas NIO is
non-blocking.
b. All the operations in IO are synchronous. Whereas NIO support
asynchronous operations.
c.
NIO uses Buffer I/O (bulk access to raw
bytes), whereas standard IO package uses stream I/O.
In Stream oriented
I/O, applications deal with one byte at a time. Input stream produces one byte
of data and output stream consumes one byte of data. Since data is read from or
written to stream, you can’t move forth and back in the stream.
In Buffer oriented
I/O, applications deal with a block of data. You can assume a block of is a
collection of bytes of data. Data is read into a buffer and can be available
for later processing.
d.
Streams are basic building blocks in IO.
Where as Channels are basic building blocks in NIO. Channels are
bi-directional, whereas streams are in one-direction. You can open a channel
for reading, writing (or) for both.
e.
IOStreams like BufferedInputStream,
BufferedOutputStream consumes java heap memory (which may leads to HeapOverflow
erros, if you are dealing with file processing applications), whereas NIO
support non-heap memory allocation.
f.
All the standard character sets are supported
by NIO.
What is Blocked IO?
In standard IO, whenever a thread invokes read() or
write() method on a stream, the thread gets blocked until there is some data to
be read or the data is written to. Thread gets unblocked after the read() or
write() operation finishes.
In case of Non-blocking IO, thread requests for data to
be written to a channel and can-do other work meantime (until data is written
to channel). With this approach, a single thread can able to handle multiple
channels of input and output.
Channels and Buffers
Channels and Buffers are the basic building blocks of
Java NIO.
Buffer is a container that holds some data.
Channels are analogous to the streams in IO. All the data
should go via channels. If you send any data to channel, the data is placed in
a buffer. Any data that is read from a channel is read into a buffer.
Channels vs Streams
Channels are bi-directional, whereas streams are in
one-direction. You can open a channel for reading, writing (or) for both.
You are going to learn.
- Introduction to Java NIO and NIO2
- NIO:Buffers, Channels and Selectors
- Exploring Channel
- FileChannel: Reading data from a file
- FileChannel: Write to a file
- FileChannel: Read and write together
- What will happen when application request I/O operation?
Introduction to NIO and NIO2
- Working with Buffers
- Buffer capacity, size, position, flip and clear methods
- Writing data to buffers
- Reading data from buffers
- Buffer: Marking and resetting
- Nio: Buffer: clear() : set the current position back to 0
- When will you get InvalidMarkException?
- Nio: Buffer: flip(): Flip the stream
- Buffer: rewind(): rewind the buffer
- nio: Buffer: read only buffers
- When will you get ‘ReadOnlyBufferException’?
- nio: Buffer apis chaining
- Get the buffer capacity
- Get the current position of the buffe
- Set the current position of the buffer
- Set and get the buffer limit
- Get the remaining element in the buffer
- Check remaining elements exist or not
- check whether the buffer is read only or not
- Check whether buffer is backed by array or not
- Get the buffer contents as an array
- wrap existing array into a buffer
- Buffer slicing
- FileChannel.open method
- Exploring OpenOption
- Direct and indirect buffers
- Reading and writing to Multiple Buffers
- MappedByteBuffer
- Convert string to ByteBuffer
- Convert ByteBuffer to a string
- Convert ByteBuffer to CharBuffer
- Convert CharBuffer to ByteBuffer
- Convert ByteBuffer to IntBuffer
- Selectors: Asynchronous Operations with NIO
- How to read contents of file asynchronously?
- Write to a file asynchronously in Java
Working with buffers and selectors
- NIO2 Introduction
- Introducing FileSystemProvider class
- How to change default file system provider?
- FileSystemProvider: getScheme: Get the scheme that identifies this provider
- Get all the installed file system providers
- Get FileSystem from the File system provider
- Get default file system
- getFileSystem: Get FileSystem for given scheme
- Working with FileStore object
- getFileSystem: Get FileSystem for given scheme
- Working with FileStore object
- WatcherService: Watching a directory for changes in Java
No comments:
Post a Comment