Programa Java para demostrar la inicialización no perezosa segura para subprocesos

Java es uno de los lenguajes de programación orientados a objetos más populares ofrecidos por Oracle, que tiene una amplia gama de aplicaciones en el desarrollo de sitios web y aplicaciones exploradas por los desarrolladores. Java junto con algunos marcos conocidos y robustos como Spring, Spring-Boot, etc. facilitan la vida del desarrollador mientras desarrollan/codifican software. Java ofrece 2 formas de creación de instancias de objetos (creación de instancias de objetos), a saber, Eager y Lazy. Este artículo se centra en la instanciación no perezosa (que significa instanciación ansiosa).

Los subprocesos en Java son pequeñas unidades de codificación individuales que pueden ejecutarse por separado (en forma paralela en múltiples núcleos de CPU) para mejorar la velocidad de procesamiento, etc. la lógica de la ejecución del programa permanece como se espera o se desea. Para un ejemplo simple como Singleton (solo 1 instancia debe estar presente durante la ejecución del código y se permite instanciar instancias nuevas/diferentes de esta clase excepto la creación de la primera) clase en Java 

Por lo tanto, este artículo trata de arrojar luz sobre la creación de instancias no perezosas en el entorno Thread-Safe y ayuda a explicarlo con una ilustración práctica del ejemplo de estudio de caso del fabricante de automóviles.

Implementación:

El siguiente sería el enfoque a demostrar para explicar la creación de instancias de objetos no perezosas tomando un CarMaker.java (secuencia de comandos a continuación) como ejemplo.

1. Tenemos una clase Java Car (que actúa como una clase Singleton), por lo que solo se debe crear y proporcionar un objeto en todo el flujo del programa.
2. Tenemos una clase CarMaker (clase Runner que tiene el método main() ), que intenta tomar la instancia base de Car y realiza operaciones como diseñar, pintar y mejorar con ella (en nuestro caso exacto, estas son declaraciones de impresión simples con mensajes)
3. Estamos creando subprocesos separados para todas las operaciones mencionadas anteriormente para demostrar un comportamiento seguro para subprocesos (en nuestro caso, esto significa que no importa si los subprocesos simultáneos alcanzan el método getCarIntance() , solo una instancia circulará por el programa)
4. El orden de ejecución del subproceso puede cambiar, pero el resultado de la creación de un solo objeto (será visible con el mismo ID de objeto impreso en el terminal) mediante la creación de instancias no diferidas se cumplirá aquí.

Ejemplo

// Java Program to illustrate Implementation of non
// Lazy-Instantiation (Eager Instantiation)
// which is Thread-Safe
 
// Importing required libraries
import java.io.*;
import java.util.*;
import java.util.concurrent.*;
 
// 'CarMaker' class is trying to Manufacture a Car
// So the Base vehicle 'Car' should remain same and
// operations like paintCar,designCar,enhanceCar etc.
// will execute with the same Car (Object Instance here.)
 
// Class 1
// Helper class
// Refers to a Singleton Class in General
class Car {
 
    // Creating eager instance variable for Car
    // Thread-Safe as marked final
    private static final Car car = new Car();
 
    // Only executes when new Car Instance is created
    // So Ideally this should be executed only once as
    // we are working with same Car
 
    // Constructor of Car class
    private Car()
    {
 
        // Print and display message
        // should be displayed only once on terminal.
        System.out.println("New Car is Created");
    }
 
    // Method of Car class
    static Car getCarInstance()
    {
 
        // Returns the Car Instance
        return car;
    }
}
 
// Class 2
// Main class
class CarMaker {
 
    // Main driver method
    public static void main(String args[])
    {
 
        // We make threads dynamically for
        // each operation specified above
 
        // Thread 1
        // Thread for designing the Car
        Thread designCar = new Thread(new Runnable() {
            // run() method for thread
            public void run()
            {
 
                // Creating and getting the Car instance
                Car car = Car.getCarInstance();
 
                // Print and display the ID
                System.out.println(
                    "Designing Car with id : " + car);
            }
        });
 
        // Thread 2
        // Thread for Painting the Car
        Thread paintCar = new Thread(new Runnable() {
            // run() method for thread
            public void run()
            {
 
                // Creating and getting Car instance by
                // calling the Car class method
                Car car = Car.getCarInstance();
 
                // Print and display the ID
                System.out.println("Painting Car with id : "
                                   + car);
            }
        });
 
        // Thread 3
        // Thread for Enhancing the Car
        Thread enhanceCar = new Thread(new Runnable() {
            // run() method for the thread
            public void run()
            {
 
                // Creating and getting Car instance by
                // calling the Car class method
                Car car = Car.getCarInstance();
 
                // Print and display the ID
                System.out.println("Enhancing Car with id : "
                                   + car);
            }
        });
 
        // Note: Second object of Car class can not be
        // created Cannot create new Instance as Constructor
        // is not Visible
 
        // Below object is not created
        // in first compile and run
        // It is cleared here in second go
        // during compile and run
 
        // Car car2 = new Car();
 
        // Running the above 3 threads as created above
        designCar.start();
        paintCar.start();
        enhanceCar.start();
    }
}

Producción: 

Aquí hemos compilado el programa dos veces, en la segunda vez hemos creado a la fuerza el segundo objeto de clase ‘Car’. Tenga en cuenta que no podemos crear una segunda instancia de la clase ‘Car’ ya que el constructor por segunda vez no está visible. Lanzará un error como se muestra a continuación en la salida pictórica codificada en la sección subrayada que se lanza en la terminal a medida que compilamos y ejecutamos nuevamente creando otro objeto. 

Explicación de salida:

Aquí, para explicar la creación de instancias no perezosas de los objetos de la clase Java, tomamos un caso de estudio simple de tener un Marcador de automóviles que fabrica automóviles. Toma el vehículo base ‘Automóvil’ y realiza operaciones como Pintar un automóvil, Diseñar un automóvil y Mejorar el automóvil. Para que el procesamiento sea lo más simple posible, tenemos declaraciones de impresión simples en cada operación junto con la visualización del Id. de objeto del automóvil para asegurarnos de que estén trabajando en el mismo automóvil.

Como podemos ver en el resultado, el orden de ejecución de las operaciones (Subprocesos en este caso) puede diferir, pero el Id. del objeto del automóvil sigue siendo el mismo durante la ejecución del programa para ilustrar cada operación (pintar, diseñar y mejorar) que se realiza en el mismo auto Como se explica en el comentario del código, la palabra clave » final» en la creación de la instancia singleton (Car) hace que la ejecución sea segura para subprocesos y, por lo tanto, obtenemos el resultado deseado de tener el mismo Objeto Car en todo momento.

Conclusión: consulte para descubrir cómo » final» hace que el código sea seguro para subprocesos sin tener sincronización. Por lo tanto, el artículo anterior explica la creación de instancias no perezosas (instancias ansiosas) de clases Java (clases Singleton) con la ayuda del ejemplo de estudio de caso de Car Maker.