Sincronización en Java | Explicado

Cuando comenzamos dos o más hilos en el mismo programa, existe la posibilidad de que los múltiples hilos intenten acceder al mismo recurso y, en consecuencia, se producirán resultados inconsistentes. Y para proporcionar una comunicación confiable entre los hilos múltiples, el concepto de sincronización se utiliza en Java. La palabra clave sincronizada en Java sincroniza las acciones de múltiples hilos y se asegura de que solo un hilo pueda acceder a un recurso específico en un momento particular.

Este artículo explorará los diversos aspectos de la sincronización en Java y en este sentido, este artículo cubrirá los siguientes conceptos:

• ¿Qué es la sincronización en Java??
• ¿Por qué se usa la sincronización??
• Por qué se usa la palabra clave sincronizada en Java
• Cómo usar la sincronización en Java

Entonces, vamos a conseguir

¿Qué es la sincronización en Java??

Es un proceso que controla el acceso de más de un hilo a cualquier recurso compartido y, por lo tanto, evita resultados inconsistentes.

¿Por qué se usa la sincronización??

En Java, el objetivo principal de usar la sincronización es evitar el comportamiento inconsistente de los hilos y evitar la interferencia de los hilos.

Por qué se usa la palabra clave sincronizada en Java

Sincronizado es un modificador que se puede aplicar solo en los métodos y bloqueos y no se puede aplicar en variables y clases. Para entender este concepto

Cómo usar la sincronización en Java

Consideraremos algunos ejemplos para una comprensión profunda. Inicialmente, crearemos un programa Java muy simple para incrementar el valor del mostrador. A continuación, extenderemos este ejemplo al escenario multiproceso. Poco a poco, nos dirigiremos hacia la sincronización donde aprenderemos por qué la palabra clave sincronizada se usa en Java?

Ejemplo
En este ejemplo, crearemos un programa simple que tenga una variable encimera y una función definida por el usuario incrementValue ().

CONTROLLAS DE CLASE
int contador;
public void incremementValue ()
contador ++;


Syncronization de clase pública EXample
public static void main (string [] args)
Condado de contrarclass = new Counterclass ();
contar.incrementValue ();
Sistema.afuera.println ("contador:" + recuento.encimera);

Cada vez que invocamos el incrementValue () incrementará el valor de encimera por 1:

El valor del mostrador se incrementa con éxito a 1, lo que muestra la idoneidad de nuestro programa. Si llamamos al incrementValue () método dos veces, entonces el valor del contador 2. Del mismo modo, mostrará el valor del contador como 3 si llamamos al incrementValue () Método tres veces como se muestra en el siguiente fragmento:

En el fragmento de código anterior, invocamos el incrementValue () Método cuatro veces, por lo que muestra el valor del contador como 4.

Ejemplo
Ahora, ampliemos un poco el ejemplo anterior donde crearemos un hilo que llame a IncremementValue () diez veces:

CONTROLLAS DE CLASE
int contador;
public void incremementValue ()
contador ++;


Syncronization de clase pública EXample
public static void main (string [] args) lanza la excepción
Condado de contrarclass = new Counterclass ();
Thread th1 = new Thread (new Runnable ()
public void run ()
para (int i = 1; i <= 10; i++)
contar.incrementValue ();


);
TH1.comenzar();
TH1.unirse();
Sistema.afuera.println ("contador:" + recuento.encimera);

En el método de código de código de código anterior () se usa con la clase de objeto de subproceso para que un hilo espere hasta que el otro hilo complete la ejecución. El código de Snippet anterior produce la siguiente salida:

Desde la salida está claro que el subproceso llama al incrementValue () diez veces y, por lo tanto, el valor del contador es igual a diez.

Hasta ahora todo bien, ahora consideremos un entorno múltiple y creemos un hilo más para ver qué sucederá cuando dos hilos llamen el mismo recurso (i.mi. incrementValue () método) al mismo tiempo.

Ejemplo

En este ejemplo, tenemos dos hilos, ambos llamarán al método IncrementValue () quinientas veces:

CONTROLLAS DE CLASE
int contador;
public void incremementValue ()
contador ++;


Syncronization de clase pública EXample
public static void main (string [] args) lanza la excepción
Condado de contrarclass = new Counterclass ();
Thread th1 = new Thread (new Runnable ()
public void run ()
para (int i = 1; i <= 500; i++)
contar.incrementValue ();


);
Thread th2 = new Thread (new Runnable ()
public void run ()
para (int i = 1; i <= 500; i++)
contar.incrementValue ();


);
TH1.comenzar();
TH1.unirse();
TH2.comenzar();
TH2.unirse();
Sistema.afuera.println ("contador:" + recuento.encimera);

Como los dos hilos llaman al contravalor () quinientas veces, por lo tanto, el valor del incremento debe ser de mil. Consideremos el siguiente fragmento para ver qué dice la salida:

En lugar de "1000", obtenemos "753", ahora qué significa eso? ¿Por qué no obtuvimos el valor del mostrador como 1000??

Bueno, se debe a que la multitud de lectura múltiple admite el procesamiento paralelo y, por lo tanto, siempre existe la posibilidad de que ambos hilos obtengan el valor del mostrador al mismo tiempo y, por lo tanto, ambos obtengan el mismo valor de contador, por lo que, en tal caso, en lugar de incrementar el valor del mostrador dos veces, se incrementa solo una vez.

Entonces, cómo evitar tal escenario? Bien! En tales casos, se utilizará la palabra clave sincronizada.

Ejemplo
Usaremos la palabra clave sincronizada con el "incrementValue ()"Método como resultado solo un hilo accederá al"incrementValue ()"Método a la vez. Todo el código seguirá siendo el mismo que en el ejemplo anterior, solo se agregará la palabra clave sincronizada con el método incrementValue () como se muestra en el fragmento:

Public sincronizado void incremementValue ()
contador ++;

Ahora si el hilo 1 está trabajando con el incrementValue () método luego el hilo 2 esperará y viceversa. Esta vez obtendremos la siguiente salida:

El fragmento dados anteriormente muestra la efectividad de la palabra clave "sincronizada".

Conclusión

La sincronización es un proceso que controla el acceso de más de un hilo y se asegura/verifica que solo un hilo pueda acceder al recurso en un momento particular. Para lograr la sincronización, se usa la palabra clave/modificador sincronizada, y se puede aplicar a los métodos y bloques, pero no se puede aplicar a variables y clases. En Java, el objetivo principal de usar la sincronización es evitar el comportamiento inconsistente de los hilos y evitar la interferencia de los hilos.