Canal de archivo asíncrono en Java NIO

El paquete Java.nio se introdujo en la versión java 1.4 edition. Nos permite tratar con diferentes canales al mismo tiempo porque admite la concurrencia y los subprocesos múltiples. La API de canal de archivo asíncrono es responsable del paquete java NIO y se define en el paquete de canales NIO. Para importar la API AsynchronousFileChannel a nuestro programa, siga la siguiente sintaxis de la siguiente manera:

Sintaxis:

import java.nio.channels.AsynchronousFileChannel

Los canales asincrónicos son seguros para que los utilicen varios subprocesos simultáneos porque este canal permite que las operaciones de archivos se ejecuten de forma asincrónica, a diferencia de las operaciones de E/S síncronas, en las que un subproceso entra en acción y espera hasta que se completa la solicitud. Esta es la única diferencia entre el asynchronousFileChannel y el FileChannel de NIO.

Los subprocesos primero pasan la solicitud al núcleo del sistema operativo para que se realice mientras el subproceso continúa con otro trabajo. Una vez que se realiza el trabajo del kernel, envía una señal al subproceso, luego el subproceso reconoce la señal e interrumpe el trabajo actual y procesa el trabajo de E/S según sea necesario en canales asíncronos.

Enfoques:

Hay dos enfoques para lograr la concurrencia y estos se enumeran a continuación. Veremos los dos enfoques anteriores en detalle con los ejemplos.

1. Objeto futuro
2. Controlador de finalización

Enfoque 1: objeto futuro

Devuelve un objeto java.util.concurrent.Future. Hay dos métodos útiles para recuperar información y estos dos métodos son:

1. Método get(): Devuelve el estado de la operación que se maneja de forma asíncrona sobre la base de la cual se podría decidir la ejecución de otras tareas.
2. Método isDone():   este método verificará si la tarea se completó o no.

Ejemplo 

// Java Program to Illustrate AsynchronousFileChannel Class
// Via Future Object Approach
 
// Importing package
package com.java.nio;
// Importing required classes from java.nio package
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
 
// Main class
// FutureObjectExample
public class GFG {
 
    // Method 1
    // Main driver method
    public static void main(String[] args) throws Exception
    {
 
        // Calling the readFile() method that will run first
        readFile();
    }
 
    // Method 2
    // To read the file
    private static void readFile()
        throws IOException, InterruptedException,
               ExecutionException
    {
 
        // Path of the file
        String filePath
            = "C:/users/Sir/Desktop/fileCopy.txt";
 
        // First create the file and then specify its
        // correct path
        printFileContents(filePath);
 
        Path path = Paths.get(filePath);
        AsynchronousFileChannel channel
            = AsynchronousFileChannel.open(
                path, StandardOpenOption.READ);
        ByteBuffer buffer = ByteBuffer.allocate(400);
        Future<Integer> result = channel.read(buffer, 0);
 
        // Checking whether the task is been completed or
        // not
        while (!result.isDone()) {
            System.out.println(
                "The process of reading file is in progress asynchronously.");
        }
 
        // Print and display statements
        System.out.println("Is the reading done? "
                           + result.isDone());
        System.out.println(
            "The number of bytes read from file is "
            + result.get());
 
        buffer.flip();
 
        System.out.print("Buffer contents: ");
 
        while (buffer.hasRemaining()) {
 
            System.out.print((char)buffer.get());
        }
 
        System.out.println(" ");
 
        // Closing the channels using close() method
        buffer.clear();
        channel.close();
    }
 
    // Method 3
    // To print the contents of the file
    private static void printFileContents(String path)
        throws IOException
    {
 
        FileReader fr = new FileReader(path);
        BufferedReader br = new BufferedReader(fr);
 
        String textRead = br.readLine();
 
        System.out.println("Content in the File: ");
 
        while (textRead != null) {
 
            // After reading all the text from the file it
            // print the number of bytes in the file.
            System.out.println("     " + textRead);
            textRead = br.readLine();
        }
 
        // Closing the channels
 
        // Closing the fr object
        fr.close();
        // Closing the br object
        br.close();
    }
}

Producción: 

Enfoque 2: controlador de finalización

Para este enfoque, vamos a utilizar la interfaz CompletionHandler y consta de dos métodos útiles que vamos a anular. En esto, se crea un controlador de finalización para consumir el resultado de una operación de E/S asíncrona, ya que una vez que se completa una tarea, solo el controlador tiene funciones que se ejecutan. 

Estos dos métodos son los siguientes: 

1. Método complete(): este método se invoca cuando la operación de E/S se completa correctamente.
2. método fail(): este método se invoca si fallan las operaciones de E/S.

Ejemplo 

// Java Program to Illustrate AsynchronousFileChannel Class
// Via Completion handler Approach
 
// Importing required classes from respective packages
package com.java.nio;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
 
// Main class
// CompletionHandler
public class GFG {
 
    // Method 1
    // Main driver method
    public static void main(String[] args) throws Exception
    {
 
        // Calling the writefile() method
        writeFile();
    }
 
    // Method 2
    // To write into  a file
    private static void writeFile() throws IOException
    {
 
        // Custom string
        String input = "Content to be written to the file.";
 
        System.out.println("Input string: " + input);
 
        byte[] byteArray = input.getBytes();
 
        ByteBuffer buffer = ByteBuffer.wrap(byteArray);
 
        // Specifying path of File
        Path path = Paths.get(
            "C:/users/Sir/Desktop/fileCopy.txt");
 
        AsynchronousFileChannel channel
            = AsynchronousFileChannel.open(
                path, StandardOpenOption
                          .WRITE); // calling the API
        CompletionHandler handler
            = new CompletionHandler() {
                  // Method 3
                  @Override
                  public void completed(Object result,
                                        Object attachment)
                  {
                      System.out.println(
                          attachment + " completed and "
                          + result + " bytes are written.");
                  }
 
                  // Method 4
                  @Override
                  public void failed(Throwable exc,
                                     Object attachment)
                  {
                      System.out.println(
                          attachment
                          + " failed with exception:");
                      exc.printStackTrace();
                  }
              };
 
        channel.write(buffer, 0, "Async Task", handler);
 
        // Closing the channel object that we created earlier
        // using close() method
        channel.close();
 
        printFileContents(path.toString());
    }
 
    // Method 5
    // To print the file contents
    private static void printFileContents(String path)
        throws IOException
    {
 
        FileReader fr = new FileReader(path);
        BufferedReader br = new BufferedReader(fr);
 
        String textRead = br.readLine();
 
        System.out.println("File contents: ");
 
        // Till there is some content in file
        while (textRead != null) {
            System.out.println("     " + textRead);
            textRead = br.readLine();
        }
 
        // Closing the fr object
        fr.close();
        // Closing the br object
        br.close();
    }
}

Producción: