Scatter/Gather or Vectored I/O

In Java NIO the channel provides an important capability known as scatter/gather or vectored I/O. It is a simple yet powerful technique through which the bytes can be written from a set of buffers to a stream using a single write() function and bytes can be read from a stream into a set of buffers using a single read() function.

Java NIO has inbuilt scatter/gather support. It can be used in reading from channels and writing to channels.

Scattering Reads

The 'scattering read' is used for reading the data from a single channel into multiple buffers.

Let's see the illustration of the Scatter principle:

Let's see the code example that performs a scattering read operation:

public interface ScatteringByteChannel extends ReadableByteChannel
{
	public long read (ByteBuffer [] argv) throws IOException;
	public long read (ByteBuffer [] argv, int length, int offset) throws IOException;
}

Gathering Writes

The 'gathering write' is used for writing the data from a multiple buffers into a single channel.

Let's see the simple illustration of the Gather principle:

Let's see the code example that performs a gathering write operation:

public interface GatheringByteChannel extends WritableByteChannel
{
	public long write(ByteBuffer[] argv) throws IOException;
	public long write(ByteBuffer[] argv, int length, int offset) throws IOException;
}

Basic Scatter/Gather Example

Let's see the simple example of two buffers. The first buffer holds a random number and second buffer holds the data we want to write using scatter/gather mechanism:

package com.javatpoint;
import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.ScatteringByteChannel;
import java.nio.channels.GatheringByteChannel;
public class Index
{
public static void main(String params[]) 
    {
        String data = "Scattering and Gathering example shown in javatpoint.com";
         gatherBytes(data);
        scatterBytes();
    }
     /* gatherBytes() is used for reading the bytes from the buffers and write it to a file channel.
     */
    public static void gatherBytes(String data) 
    {
        //The First Buffer is used for holding a random number
        ByteBuffer buffer1 = ByteBuffer.allocate(8);
        //The Second Buffer is used for holding a data that we want to write
        ByteBuffer buffer2 = ByteBuffer.allocate(400);
        buffer1.asIntBuffer().put(420);
        buffer2.asCharBuffer().put(data);
        GatheringByteChannel gatherer = createChannelInstance("D:\\testout.txt", true);
        //Write the data into file
        try
        { gatherer.write(new ByteBuffer[] { buffer1, buffer2 });
        } 
        catch (Exception e) 
        { e.printStackTrace();
        }
    }
    /* scatterBytes() is used for reading the bytes from a file channel into a set of buffers.
     */
    public static void scatterBytes() 
    {
        //The First Buffer is used for holding a random number
        ByteBuffer buffer1 = ByteBuffer.allocate(8);
         //The Second Buffer is used for holding a data that we want to write
        ByteBuffer buffer2 = ByteBuffer.allocate(400);
        ScatteringByteChannel scatter = createChannelInstance("D:\\testout.txt", false);
      //Reading a data from the channel
        try
        { scatter.read(new ByteBuffer[] { buffer1, buffer2 });
        } 
        catch (Exception e) 
        { e.printStackTrace();
        }
       //Read the two buffers seperately
        buffer1.rewind();
        buffer2.rewind();
 
        int bufferOne = buffer1.asIntBuffer().get();
        String bufferTwo = buffer2.asCharBuffer().toString();
        //Verification of content
        System.out.println(bufferOne);
        System.out.println(bufferTwo);
    }
     public static FileChannel createChannelInstance(String file, boolean isOutput) 
    {
        FileChannel FChannel = null;
        try
        {
            if (isOutput) {
                FChannel = new FileOutputStream(file).getChannel();
            } else {
                FChannel = new FileInputStream(file).getChannel();
            }
        } 
        catch (Exception e) {
            e.printStackTrace();
        }
        return FChannel;
    }
}

Output:

In above program, first buffer print the random output on a console and second buffer print the "Scattering and Gathering example shown in javatpoint.com" on a console.

It also replaces the content of testout.txt file with "Scattering and Gathering example shown in javatpoint.com".

Next TopicData Transfer between Channels

← prev next →