Una array es una colección de elementos almacenados en ubicaciones de memoria contiguas. La idea es almacenar varios artículos del mismo tipo juntos. Esto facilita el cálculo de la posición de cada elemento simplemente agregando un desplazamiento a un valor base, es decir, la ubicación de memoria del primer elemento de la array (generalmente indicado por el nombre de la array). Las arrays se utilizan para almacenar datos homogéneos. La forma convencional de almacenar los elementos en una array y leer los elementos de una array lleva mucho tiempo si hay numerosos elementos.
Escribir y leer elementos en una array es un pequeño problema en el que cada elemento se agrega primero a la array y luego la array completa se lee elemento por elemento y se imprime en la consola. Pero cuando la cantidad de elementos es demasiado grande, puede llevar mucho tiempo. Pero esto podría solucionarse dividiendo las tareas de escritura y lectura en partes.
Esto podría hacerse mediante el uso de subprocesos múltiples donde se usa cada núcleo del procesador. En este caso, se utilizan dos subprocesos, donde un subproceso es responsable de escribir en la array y el otro subproceso es responsable de leer la array. De esta forma, se puede mejorar el rendimiento de un programa y se pueden utilizar los núcleos del procesador. Es mejor usar un hilo para cada núcleo. Aunque uno puede crear tantos subprocesos como sea necesario para una mejor comprensión de subprocesos múltiples.
Este artículo se enfoca en escribir y leer los elementos de la array utilizando el concepto de subprocesos múltiples.
Enfoque: esta sección establece el algoritmo que se sigue para diseñar un programa para escribir y leer elementos de una array utilizando subprocesos múltiples:
- En el primer paso, se crearán dos hilos.
- Uno para la operación de escritura y otro para la operación de lectura.
- Aquí, la palabra clave sincronizada se usa con la array para que solo un subproceso pueda acceder a la array a la vez.
- Primero, la operación de escritura se realizará en la array.
- Luego, la operación de lectura se realiza en la array.
A continuación se muestra el programa Java para implementar el enfoque anterior:
Java
// Java program for the above approach
import java.io.*;
import java.util.*;
class GFG {
public static void main(String[] args)
{
// Array created for 5 elements
int a[] = new int[5];
// Thread created for write operation
Thread t1 = new Thread(new Runnable() {
public void run()
{
// Here the array is being
// synchronized
synchronized (a)
{
Scanner s = new Scanner(System.in);
System.out.println(
"Enter the elements : ");
for (int i = 0; i < 5; i++) {
a[i] = s.nextInt();
}
System.out.println(
"Writing done Successfully");
}
}
});
// Thread created for read operation
Thread t2 = new Thread(new Runnable() {
public void run()
{
// Here the array is being
// synchronized
synchronized (a)
{
System.out.println(
"The elements are : ");
for (int i = 0; i < 5; i++) {
System.out.println(a[i]);
}
System.out.println(
"Reading done successfully");
}
}
});
// Write thread is started
t1.start();
// Read thread is started
t2.start();
}
}
Producción:
Explicación: aquí, en primer lugar, se inicia el subproceso de escritura y, en ese momento, el subproceso de lectura no interferirá mientras se sincroniza la array. Del mismo modo, durante la lectura, el hilo de escritura no interferirá.