Procesamiento paralelo en Java

1. Diferencia entre el procesamiento paralelo y secuencial
2. Procesamiento paralelo en Java usando parallelStream()
3. Procesamiento paralelo en Java usando parallel()
4. Procesamiento paralelo en Java usando CompletableFuture

El procesamiento paralelo es una nueva tendencia en la programación moderna. Este procesamiento nos permite ejecutar múltiples tareas simultáneamente, disminuyendo el tiempo de procesamiento, pero las tareas deben ser independientes.

En este artículo, veremos el procesamiento paralelo en Java, junto con los ejemplos y explicaciones necesarios para facilitar el tema.

Diferencia entre el procesamiento paralelo y secuencial

En el procesamiento secuencial, todos los procesos independientes de una tarea se ejecutan uno por uno, y cuando un proceso está funcionando, otro proceso debe esperar.

Por otro lado, en el procesamiento paralelo, se pueden ejecutar varios procesos a la vez y no es necesario esperar a que finalice un proceso. El procesamiento en paralelo es esencial para la multitarea.

Procesamiento paralelo en Java usando parallelStream()

Este ejemplo ilustrará cómo podemos realizar un procesamiento paralelo en Java. Echemos un vistazo a nuestro siguiente ejemplo:

// importing necessary packages
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class JavaParallal {
  public static void main(String[] args) {
    // Creating an integer array
    Integer[] IntArray = {1, 2, 3, 4, 5, 6, 7, 8};
    // Creating a list from the integer array
    List<Integer> NumList = new ArrayList<>(Arrays.asList(IntArray));

    System.out.println("The list elements using Serial Stream:");
    NumList.stream().forEach(num -> System.out.print(num + " ")); // Sequencial processing here
    System.out.println("");

    System.out.println("The list elements using Parallel Stream:");
    NumList.parallelStream().forEach(
        num -> System.out.print(num + " ")); // Parallal processing here
    System.out.println("");
  }
}

Ya comandamos los propósitos de cada línea. Cuando ejecute este código, debería obtener un resultado como el siguiente en su consola:

The list elements using Serial Stream:
1 2 3 4 5 6 7 8
The list elements using Parallel Stream:
6 5 8 3 7 4 2 1

Procesamiento paralelo en Java usando parallel()

En nuestro ejemplo a continuación, ilustramos cómo podríamos realizar un procesamiento paralelo utilizando el método parallel().

Supongamos que tenemos un archivo de texto con el siguiente contenido:

This is line 1
This is line 2
This is line 3
This is line 4
This is line 5
This is line 6
This is line 7
This is line 8

Observe el código de ejemplo a continuación:

// importing necessary packages
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.stream.Stream;

public class JavaParallal {
  public static void main(String[] args) throws IOException {
    // Locating the file
    File MyFile = new File("G:\\Java Projects\\SimpleJavaCodes\\src\\SampleTexts.txt");

    Stream<String> FileContent = Files.lines(MyFile.toPath()); // Reading the file

    FileContent.parallel().forEach(System.out::println); // Parallal

    FileContent.close();
  }
}

Ya comandamos los propósitos de cada línea. Cuando ejecute este código, obtendrá una salida como la siguiente en su consola:

This is line 6
This is line 5
This is line 2
This is line 1
This is line 4
This is line 7
This is line 8
This is line 3

Procesamiento paralelo en Java usando CompletableFuture

En nuestro ejemplo a continuación, demostramos cómo podemos realizar un procesamiento paralelo utilizando el método CompletableFuture. Eche un vistazo al siguiente código de ejemplo:

// importing necessary packages

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;

public class JavaCompleteTableFuture {
  public static void main(String[] args) {
    try {
      List<Integer> MyList = Arrays.asList(2, 3, 5); // Declaring a list element
      MyList.stream()
          .map(Number -> CompletableFuture.supplyAsync(() -> GetNumber(Number)))
          .map(CompletableFuture -> CompletableFuture.thenApply(N -> N * N))
          .map(T -> T.join())
          .forEach(S -> System.out.println(S + " "));

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  private static int GetNumber(int a) {
    return a + a;
  }
}

En nuestro ejemplo anterior,

1. supplyAsync(): este método completa un trabajo de forma asíncrona. Por defecto, el método ForkJoinPool.commonPool() ejecuta la tarea desde el proveedor.
2. thenApply(): este método acepta una función como argumento y devuelve un nuevo CompletableStage después de que la etapa actual se complete normalmente.
3. join(): este método devuelve el resultado una vez que se ha completado.

Cuando ejecute el comando anterior, obtendrá un resultado como el siguiente en su consola:

16
36
100

Tenga en cuenta que los códigos de ejemplo compartidos aquí están en Java y debe instalar Java en su entorno si su sistema no lo tiene.