Menú

Java sincronitzat: què és la sincronització de fils a Java

  • Principal
  • Altres
  • Java sincronitzat: què és la sincronització de fils a Java

java synchronized what is thread synchronization java

Proveu El Nostre Instrument Per Eliminar Problemes

Aquest tutorial explica la sincronització de fils a Java juntament amb conceptes relacionats com ara Java Lock, Race Condition, Mutex, Java Volatile i Deadlock a Java:

En un entorn multithreading on hi ha diversos fils, és probable que hi hagi enfrontaments quan més d'un fil intenta obtenir el mateix recurs alhora. Aquests enfrontaments donen lloc a una 'condició de carrera' i, per tant, el programa produeix resultats inesperats.

Per exemple, un únic fitxer s'està actualitzant per dos fils. Si un fil T1 està en procés d’actualització d’aquest fitxer, digueu alguna variable. Ara bé, encara que aquesta actualització de T1 encara està en curs, suposem que el segon fil T2 també actualitza la mateixa variable. D'aquesta manera, la variable donarà resultats equivocats.

=> Mireu aquí la sèrie d'entrenament completa de Java.

Sincronització de fils a Java

Quan hi hagi diversos fils, hauríem de gestionar aquests fils de manera que un recurs pugui accedir a un recurs alhora. A l'exemple anterior, el fitxer al qual accedeixen tots dos fils s'ha de gestionar de manera que T2 no pugui accedir al fitxer fins que T1 no hi accedeixi.

Això es fa a Java mitjançant “ Sincronització de fils '.

Què aprendreu:

Sincronització de fils a Java

Com que Java és un llenguatge multi-threaded, la sincronització de fils té molta importància a Java, ja que diversos fils s’executen en paral·lel en una aplicació.

Utilitzem paraules clau 'Sincronitzat' i 'Volàtil' per aconseguir la sincronització a Java

Necessitem sincronització quan l’objecte o recurs compartit és mutable. Si el recurs és immutable, els fils només llegiran el recurs de manera simultània o individual.

En aquest cas, no necessitem sincronitzar el recurs. En aquest cas, JVM ho assegura El codi sincronitzat Java s’executa d’un fil a la vegada .

La majoria de les vegades, l'accés simultani a recursos compartits a Java pot introduir errors com 'Inconsistència de memòria' i 'interferència de fils'. Per evitar aquests errors, hem d’optar per la sincronització de recursos compartits de manera que l’accés a aquests recursos s’exclogui mútuament.

Utilitzem un concepte anomenat Monitors per implementar la sincronització. Només es pot accedir a un monitor mitjançant un fil alhora. Quan un fil obté el bloqueig, podem dir que el fil ha entrat al monitor.

Quan un fil determinat accedeix a un monitor, el monitor es bloqueja i tots els altres fils que intenten entrar al monitor es suspendran fins que el fil d'accés acabi i deixi anar el bloqueig.

En el futur, en aquest tutorial parlarem detalladament de la sincronització a Java. Ara, anem a discutir alguns conceptes bàsics relacionats amb la sincronització a Java.

Condició de cursa a Java

En un entorn multithreaded, quan més d’un fil intenta accedir a un recurs compartit per escriure simultàniament, diversos fils s’encarreguen entre ells per acabar d’accedir al recurs. Això dóna lloc a la 'condició de carrera'.

Una cosa a tenir en compte és que no hi ha cap problema si diversos fils intenten accedir a un recurs compartit només per llegir. El problema sorgeix quan diversos fils accedeixen al mateix recurs alhora.

Les condicions de la cursa es produeixen a causa de la manca de sincronització adequada dels fils al programa. Quan sincronitzem correctament els fils de manera que, alhora, només un fil accedirà al recurs i la condició de cursa deixi d’existir.

Llavors, com podem detectar l’estat de la cursa?

La millor manera de detectar l’estat de la cursa és mitjançant la revisió del codi. Com a programador, hauríem de revisar el codi a fons per comprovar si hi ha condicions de cursa potencials que es puguin produir.

Panys / monitors a Java

Ja hem esmentat que utilitzem monitors o panys per implementar la sincronització. El monitor o bloqueig és una entitat interna i està associat a tots els objectes. Per tant, sempre que un fil necessiti accedir a l’objecte, primer ha d’adquirir el bloqueig o el monitor del seu objecte, treballar sobre l’objecte i després deixar-lo anar.

Els bloquejos a Java es veuran com es mostra a continuació:

public class Lock { private boolean isLocked = false; public synchronized void lock() throws InterruptedException { while(isLocked) { wait(); } isLocked = true; } public synchronized void unlock(){ isLocked = false; notify(); } }

Com es mostra més amunt, tenim un mètode lock () que bloqueja la instància. Tots els fils que criden al mètode lock () es bloquejaran fins que els conjunts de mètodes unblock () es bloquegin com a falsos i notifiquin tots els fils en espera.

Alguns consells que cal recordar sobre els panys:

  1. A Java, cada objecte té un pany o un monitor. Es pot accedir a aquest pany mitjançant un fil.
  2. Al mateix temps, només un fil pot adquirir aquest monitor o bloqueig.
  3. El llenguatge de programació Java proporciona una paraula clau Sincronitzat ’que ens permet sincronitzar els fils fent un bloc o mètode com a Sincronitzat.
  4. Els recursos compartits als quals han d’accedir els fils s’emmagatzemen sota aquest mètode / bloc sincronitzat.

Mutexes a Java

Ja hem comentat que en un entorn multithread, es poden produir condicions de cursa quan més d'un fil intenta accedir als recursos compartits simultàniament i les condicions de cursa produeixen una sortida inesperada.

La part del programa que intenta accedir al recurs compartit s'anomena 'Secció crítica' . Per evitar l’aparició de condicions de cursa, cal sincronitzar l’accés a la secció crítica. Sincronitzant aquesta secció crítica, ens assegurem que només un fil pugui accedir a la secció crítica alhora.

El tipus més senzill de sincronitzador és el 'mutex'. Mutex assegura que en una instància determinada, només un fil pot executar la secció crítica.

El mutex és similar al concepte de monitors o panys que hem comentat anteriorment. Si un fil ha d’accedir a una secció crítica, ha d’adquirir el mutex. Un cop adquirit el mutex, el fil accedirà al codi de la secció crítica i, quan acabi, alliberarà el mutex.

La resta de fils que esperen per accedir a la secció crítica es bloquejaran mentrestant. Tan bon punt el fil que manté mutex el deixi anar, un altre fil entrarà a la secció crítica.

la millor eina de gestió de casos de prova per a jira

Hi ha diverses maneres en què podem implementar un mutex a Java.

  1. Ús de paraula clau sincronitzada
  2. Utilitzant el semafor
  3. Utilitzant ReentrantLock

En aquest tutorial, parlarem del primer enfocament, és a dir, de la sincronització. Els altres dos enfocaments, Semaphore i ReentrantLock, es tractaran en el següent tutorial, en el qual parlarem del paquet java concurrent.

Paraula clau sincronitzada

Java proporciona una paraula clau 'Sincronitzada' que es pot utilitzar en un programa per marcar una secció Crítica. La secció crítica pot ser un bloc de codi o un mètode complet. Per tant, només un fil pot accedir a la secció crítica marcada per la paraula clau sincronitzada.

Podem escriure les parts simultànies (parts que s’executen simultàniament) per a una aplicació mitjançant la paraula clau sincronitzada. També ens desferem de les condicions de la cursa fent un bloc de codi o un mètode sincronitzat.

Quan marquem un bloc o un mètode sincronitzat, protegim els recursos compartits dins d’aquestes entitats de l’accés simultani i, per tant, de la corrupció.

Tipus de sincronització

Hi ha 2 tipus de sincronització, tal com s’explica a continuació:

# 1) Sincronització de processos

La sincronització de processos implica múltiples processos o fils que s’executen simultàniament. En última instància, arriben a un estat en què aquests processos o fils comprometen una seqüència específica d’accions.

# 2) Sincronització de fils

A Sincronització de fils, més d’un fil intenta accedir a un espai compartit. Els fils se sincronitzen de manera que només hi accedeix un espai cada cop a l'espai compartit.

La sincronització de processos està fora de l’abast d’aquest tutorial. Per tant, aquí només discutirem la sincronització de fils.

A Java, podem utilitzar la paraula clau sincronitzada amb:

  • Un bloc de codi
  • Un mètode

Els tipus anteriors són els tipus de sincronització de fils mútuament excloents. L’exclusió mútua impedeix que els fils que accedeixen a les dades compartides interfereixin entre ells.

L'altre tipus de sincronització de fils és la 'comunicació InterThread' que es basa en la cooperació entre fils. La comunicació entre fils no surt de l’abast d’aquest tutorial.

Abans de continuar amb la sincronització de blocs i mètodes, implementem un programa Java per demostrar el comportament dels fils quan no hi ha sincronització.

Multi-threading sense sincronització

El següent programa Java té diversos fils que no estan sincronitzats.

class PrintCount { //method to print the thread counter public void printcounter() { try { for(int i = 5; i > 0; i--) { System.out.println('Counter ==> ' + i ); } } catch (Exception e) { System.out.println('Thread interrupted.'); } } } //thread class class ThreadCounter extends Thread { private Thread t; private String threadName; PrintCount PD; //class constructor for initialization ThreadCounter( String name, PrintCount pd) { threadName = name; PD = pd; } //run method for thread public void run() { PD.printcounter(); System.out.println('Thread ' + threadName + ' exiting.'); } //start method for thread public void start () { System.out.println('Starting ' + threadName ); if (t == null) { t = new Thread (this, threadName); t.start (); } } } public class Main { public static void main(String args()) { PrintCount PD = new PrintCount(); //create two instances of thread class ThreadCounter T1 = new ThreadCounter( 'ThreadCounter_1 ', PD ); ThreadCounter T2 = new ThreadCounter( 'ThreadCounter_2 ', PD ); //start both the threads T1.start(); T2.start(); // wait for threads to end try { T1.join(); T2.join(); } catch ( Exception e) { System.out.println('Interrupted'); } } }

Sortida

Multi-threading sense sincronització

Des de la sortida, podem veure que, com que els fils no estan sincronitzats, la sortida és inconsistent. Els dos fils comencen i mostren el comptador un darrere l’altre. Tots dos fils surten al final.

Des del programa donat, el primer fil hauria d’haver sortit després de mostrar els valors del comptador i, després, el segon fil hauria d’haver començat a mostrar els valors del comptador.

Ara anem a la sincronització i comencem per la sincronització de blocs de codi.

Bloc de codi sincronitzat

Un bloc sincronitzat s’utilitza per sincronitzar un bloc de codi. Aquest bloc sol estar format per algunes línies. S'utilitza un bloc sincronitzat quan no volem que es sincronitzi un mètode complet.

Per exemple, tenim un mètode amb 75 línies de codi. D'aquest, només cal que executin 10 línies de codi per un fil a la vegada. En aquest cas, si fem tot el mètode sincronitzat, aleshores suposarà una càrrega per al sistema. En aquestes situacions, apostem pels blocs sincronitzats.

L’abast del mètode sincronitzat sempre és més petit que el d’un mètode sincronitzat. Un mètode sincronitzat bloqueja un objecte d'un recurs compartit que ha de ser utilitzat per diversos fils.

La sintaxi general d’un bloc sincronitzat és la següent:

synchronized (lock_object){ //synchronized code statements }

Aquí, 'lock_object' és una expressió de referència d'objecte en la qual s'ha d'obtenir el bloqueig. Per tant, sempre que un fil vulgui accedir a les sentències sincronitzades dins del bloc per executar-lo, ha d’adquirir el bloqueig al monitor ‘lock_object’.

Com ja s'ha comentat, la paraula clau sincronitzada garanteix que només un fil pugui adquirir un bloqueig alhora i que tots els altres fils hagin d'esperar fins que el fil que conté el bloqueig s'acabi i el deixi anar.

Nota

  • Es genera una 'NullPointerException' si el lock_object utilitzat és Null.
  • Si un fil dorm mentre es manté el pany, el pany no es deixa anar. Els altres fils no podran accedir a l'objecte compartit durant aquest temps de repòs.

Ara presentarem l'exemple anterior que ja es va implementar amb lleugers canvis. Al programa anterior, no vam sincronitzar el codi. Ara utilitzarem el bloc sincronitzat i compararem la sortida.

Multi-threading amb sincronització

Al programa Java següent, fem servir un bloc sincronitzat. Al mètode d'execució, sincronitzem el codi de línies que imprimeixen el comptador de cada fil.

class PrintCount { //print thread counter public void printCounter() { try { for(int i = 5; i > 0; i--) { System.out.println('Counter ==> ' + i ); } } catch (Exception e) { System.out.println('Thread interrupted.'); } } } //thread class class ThreadCounter extends Thread { private Thread t; private String threadName; PrintCount PD; //class constructor for initialization ThreadCounter( String name, PrintCount pd) { threadName = name; PD = pd; } //run () method for thread with synchronized block public void run() { synchronized(PD) { PD.printCounter(); } System.out.println('Thread ' + threadName + ' exiting.'); } //start () method for thread public void start () { System.out.println('Starting ' + threadName ); if (t == null) { t = new Thread (this, threadName); t.start (); } } } public class Main { public static void main(String args()) { PrintCount PD = new PrintCount(); //create thread instances ThreadCounter T1 = new ThreadCounter( 'Thread_1 ', PD ); ThreadCounter T2 = new ThreadCounter( 'Thread_2 ', PD ); //start both the threads T1.start(); T2.start(); // wait for threads to end try { T1.join(); T2.join(); } catch ( Exception e) { System.out.println('Interrupted'); } } }

Sortida

Multi-threading amb sincronització

Ara la sortida d’aquest programa que utilitza blocs sincronitzats és bastant consistent. Com era d’esperar, tots dos fils comencen a executar-se. El primer fil ha acabat de mostrar els valors i sortides del comptador. A continuació, el segon fil mostra els valors del comptador i surt.

Mètode sincronitzat

Analitzem el mètode sincronitzat en aquesta secció. Abans hem vist que podem declarar un bloc petit format per menys línies de codi com a bloc sincronitzat. Si volem que es sincronitzi tota la funció, podem declarar un mètode com a sincronitzat.

Quan un mètode es sincronitza, només un fil podrà fer una trucada de mètode alhora.

La sintaxi general per escriure un mètode sincronitzat és:

synchronized method_name (parameters){ //synchronized code }

Igual que un bloc sincronitzat, en el cas d’un mètode sincronitzat, necessitem un lock_object que serà utilitzat pels fils que accedeixin al mètode sincronitzat.

Per al mètode sincronitzat, l'objecte de bloqueig pot ser un dels següents:

  • Si el mètode sincronitzat és estàtic, l’objecte de bloqueig ve donat per l’objecte ‘.class’.
  • Per a un mètode no estàtic, l'objecte de bloqueig ve donat per l'objecte actual, és a dir, aquest objecte.

Una característica peculiar de la paraula clau sincronitzada és que torna a entrar. Això significa que un mètode sincronitzat pot trucar a un altre mètode sincronitzat amb el mateix bloqueig. Així, un fil que manté el pany pot accedir a un altre mètode sincronitzat sense haver d’adquirir un pany diferent.

El mètode sincronitzat es demostra mitjançant l'exemple següent.

class NumberClass { //synchronized method to print squares of numbers synchronized void printSquares(int n) throws InterruptedException { //iterate from 1 to given number and print the squares at each iteration for (int i = 1; i <= n; i++) { System.out.println(Thread.currentThread().getName() + ' :: '+ i*i); Thread.sleep(500); } } } public class Main { public static void main(String args()) { final NumberClass number = new NumberClass(); //create thread Runnable thread = new Runnable() { public void run() { try { number.printSquares(3); } catch (InterruptedException e) { e.printStackTrace(); } } }; //start thread instance new Thread(thread, 'Thread One').start(); new Thread(thread, 'Thread Two').start(); } }

Sortida

mètode sincronitzat

Al programa anterior, hem utilitzat un mètode sincronitzat per imprimir els quadrats d’un número. El límit superior del nombre es passa al mètode com a argument. A continuació, a partir de l’1, s’imprimeixen els quadrats de cada número fins que s’assoleix el límit superior.

A la funció principal, es crea la instància del fil. A cada instància de fil se li passa un número per imprimir quadrats.

Com s'ha esmentat anteriorment, quan un mètode a sincronitzar és estàtic, l'objecte de bloqueig participa a la classe i no a l'objecte. Això significa que bloquejarem la classe i no l'objecte. Això s’anomena sincronització estàtica.

A continuació es dóna un altre exemple.

quin és el millor correu electrònic per utilitzar
class Table{ //synchronized static method to print squares of numbers synchronized static void printTable(int n){ for(int i=1;i<=10;i++){ System.out.print(n*i + ' '); try{ Thread.sleep(400); }catch(Exception e){} } System.out.println(); } } //thread class Thread_One class Thread_One extends Thread{ public void run(){ Table.printTable(2); } } //thread class Thread_Two class Thread_Two extends Thread{ public void run(){ Table.printTable(5); } } public class Main{ public static void main(String t()){ //create instances of Thread_One and Thread_Two Thread_One t1=new Thread_One (); Thread_Two t2=new Thread_Two (); //start each thread instance t1.start(); t2.start(); } }

Sortida

sortida de sincronització de mètodes estàtics

Al programa anterior, imprimim taules de multiplicació de nombres. Cada número la taula de la qual s'ha d'imprimir és una instància de fil de classe de fil diferent. Així, imprimim taules de multiplicar de 2 i 5, de manera que tenim dues classes thread_one i thread_two per imprimir les taules 2 i 5 respectivament.

Per resumir, la paraula clau sincronitzada Java realitza les funcions següents:

  1. La paraula clau sincronitzada a Java garanteix un accés mutuament exclusiu als recursos compartits proporcionant un mecanisme de bloqueig. El bloqueig també evita les condicions de la cursa.
  2. Mitjançant la paraula clau sincronitzada, evitem errors de programació simultanis al codi.
  3. Quan un mètode o bloc es declara sincronitzat, un fil necessita un bloqueig exclusiu per introduir el mètode o bloc sincronitzat. Després de realitzar les accions necessàries, el fil allibera el bloqueig i esborra l'operació d'escriptura. D'aquesta manera, eliminarà els errors de memòria relacionats amb la inconsistència.

Volàtil a Java

Una paraula clau volàtil a Java s'utilitza per fer que les classes siguin segures per a fils. També fem servir la paraula clau volàtil per modificar el valor de la variable per diferents fils. Es pot utilitzar una paraula clau volàtil per declarar una variable amb tipus primitius i objectes.

En alguns casos, s’utilitza una paraula clau volàtil com a alternativa per a la paraula clau sincronitzada, però tingueu en compte que no és un substitut de la paraula clau sincronitzada.

Quan una variable es declara volàtil, el seu valor mai es guarda a la memòria cau, però sempre es llegeix des de la memòria principal. Una variable volàtil garanteix l'ordre i la visibilitat. Tot i que es pot declarar una variable com a volàtil, no podem declarar classes o mètodes com a volàtils.

Penseu en el següent bloc de codi:

class ABC{ static volatile int myvar =10; }

Al codi anterior, la variable myvar és estàtica i volàtil. Una variable estàtica es comparteix entre tots els objectes de la classe. La variable volàtil sempre resideix a la memòria principal i mai es guarda a la memòria cau.

Per tant, només hi haurà una còpia de myvar a la memòria principal i totes les accions de lectura / escriptura es faran en aquesta variable des de la memòria principal. Si myvar no es declarés volàtil, llavors cada objecte de fil tindria una còpia diferent que donaria lloc a incoherències.

A continuació es detallen algunes de les diferències entre les paraules clau volàtils i les sincronitzades.

Paraula clau volàtilParaula clau sincronitzada
La paraula clau volàtil només s’utilitza amb variables.La paraula clau sincronitzada s’utilitza amb mètodes i blocs de codi.
Una paraula clau volàtil no pot bloquejar el fil per esperar.La paraula clau sincronitzada pot bloquejar el fil per esperar.
El rendiment del fil es millora amb Volatile.El rendiment del fil es degrada una mica amb el sincronitzat.
Les variables volàtils resideixen a la memòria principal.Les construccions sincronitzades no resideixen a la memòria principal.
Volatile sincronitza una variable entre la memòria de fil i la memòria principal alhora.La paraula clau sincronitzada sincronitza totes les variables alhora.

Impasse a Java

Hem vist que podem sincronitzar diversos fils mitjançant paraules clau sincronitzades i fer que els programes siguin segurs de fils. Sincronitzant els fils, ens assegurem que els múltiples fils s’executin simultàniament en un entorn de diversos fils.

Tanmateix, de vegades es produeix una situació en què els fils ja no poden funcionar simultàniament. En el seu lloc, esperen sense parar. Això es produeix quan un fil espera en un recurs i aquest segon el bloqueja.

El segon fil, en canvi, espera el recurs que està bloquejat pel primer fil. Aquesta situació dóna lloc a un 'punt mort' a Java.

El punt mort a Java es representa mitjançant la imatge següent.

Impàs a Java

Com podem veure al diagrama anterior, el fil A ha bloquejat el recurs r1 i està esperant el recurs r2. El fil B, en canvi, ha bloquejat el recurs r2 i està esperant a r1.

Així, cap dels fils no pot acabar l'execució tret que aconsegueixin els recursos pendents. Aquesta situació s'ha traduït en un punt mort on tots dos fils esperen sense parar els recursos.

A continuació es mostra un exemple de bloquejos a Java.

public class Main { public static void main(String() args) { //define shared resources final String shared_res1 = 'Java tutorials'; final String shared_res2 = 'Multithreading'; // thread_one => locks shared_res1 then shared_res2 Thread thread_one = new Thread() { public void run() { synchronized (shared_res1) { System.out.println('Thread one: locked shared resource 1'); try { Thread.sleep(100);} catch (Exception e) {} synchronized (shared_res2) { System.out.println('Thread one: locked shared resource 2'); } } } }; // thread_two=> locks shared_res2 then shared_res1 Thread thread_two = new Thread() { public void run() { synchronized (shared_res2) { System.out.println('Thread two: locked shared resource 2'); try { Thread.sleep(100);} catch (Exception e) {} synchronized (shared_res1) { System.out.println('Thread two: locked shared resource 1'); } } } }; //start both the threads thread_one.start(); thread_two.start(); } }

Sortida

Punts morts a Java: sortida

Al programa anterior, tenim dos recursos compartits i dos fils. Tots dos fils intenten accedir als recursos compartits un per un. La sortida mostra ambdós fils bloquejant un recurs cadascun mentre espera els altres. D’aquesta manera es crea una situació d’impàs.

Tot i que no podem evitar que les situacions d’impasse es produeixin completament, certament podem evitar-les prenent alguns passos.

A continuació es detallen els mitjans amb els quals podem evitar bloquejos a Java.

# 1) Evitant panys imbricats

Tenir panys imbricats és el motiu més important per tenir punts morts. Els panys imbricats són els panys que es donen a diversos fils. Per tant, hem d’evitar donar panys a més d’un fil.

# 2) Utilitzeu unió de fil

Hauríem d’utilitzar Thread.join amb el temps màxim perquè els fils puguin utilitzar el temps màxim per a l’execució. Això evitarà el bloqueig que es produeix principalment mentre un fil espera contínuament altres.

# 3) Eviteu el bloqueig innecessari

Hem de bloquejar només el codi necessari. Tenir bloquejos innecessaris per al codi pot provocar bloquejos al programa. Com que els bloquejos poden trencar el codi i dificultar el flux del programa, hauríem d'estar inclinats a evitar bloquejos als nostres programes.

Preguntes freqüents

P # 1) Què és la sincronització i per què és important?

Resposta: La sincronització és el procés de controlar l'accés d'un recurs compartit a diversos fils. Sense sincronització, diversos fils poden actualitzar o canviar el recurs compartit al mateix temps, resultant en inconsistències.

Per tant, hem d’assegurar-nos que, en un entorn multi-threaded, els fils se sincronitzin de manera que la manera d’accedir als recursos compartits sigui mútuament excloent i coherent.

Q # 2) Què és la sincronització i la no sincronització a Java?

Resposta: La sincronització significa que una construcció és segura per a fils. Això significa que diversos fils no poden accedir a la construcció (bloc de codi, mètode, etc.) alhora.

Les construccions no sincronitzades no són segures per a fils. Diversos fils poden accedir als mètodes o blocs no sincronitzats en qualsevol moment. Una classe popular no sincronitzada a Java és StringBuilder.

P # 3) Per què és necessària la sincronització?

Resposta: Quan els processos s’han d’executar simultàniament, necessitem la sincronització. Això es deu al fet que necessitem recursos que es puguin compartir entre molts processos.

Per tal d’evitar enfrontaments entre processos o fils per accedir a recursos compartits, hem de sincronitzar aquests recursos perquè tots els fils puguin accedir als recursos i l’aplicació també funcioni sense problemes.

Q # 4) Com s'obté una llista de matrius sincronitzada?

Resposta: Podem utilitzar el mètode Collections.synchronized list amb ArrayList com a argument per convertir ArrayList a una llista sincronitzada.

P # 5) HashMap està sincronitzat?

quina és la fase d'implementació al sdlc?

Resposta: No, HashMap no està sincronitzat, però HashTable està sincronitzat.

Conclusió

En aquest tutorial, hem parlat detalladament de la sincronització de fils. Juntament amb ell, també vam aprendre sobre les paraules clau i els punts morts inestables a Java. La sincronització consisteix en la sincronització de processos i fils.

En un entorn multithreading, ens preocupa més la sincronització de fils. Aquí hem vist l'enfocament de les paraules clau sincronitzades de la sincronització de fils aquí.

El punt mort és una situació en què diversos fils esperen recursos sense fi. Hem vist l'exemple de bloquejos a Java juntament amb els mètodes per evitar bloquejos a Java.

=> Visiteu aquí per aprendre Java des de zero.

Lectura recomanada

^