java synchronized what is thread synchronization java
Denne vejledning forklarer trådsynkronisering i Java sammen med relaterede begreber som Java Lock, Race Condition, Mutex, Java Volatile & Deadlock i Java:
I et multithreading-miljø, hvor flere tråde er involveret, er der sandsynligvis sammenstød, når mere end en tråd forsøger at få den samme ressource på samme tid. Disse sammenstød resulterer i 'løbetilstand', og dermed producerer programmet uventede resultater.
For eksempel, en enkelt fil opdateres af to tråde. Hvis en tråd T1 er i færd med at opdatere denne fil, sig noget variabelt. Nu mens denne opdatering af T1 stadig er i gang, lad os sige, at den anden tråd T2 også opdaterer den samme variabel. På denne måde giver variablen forkerte resultater.
=> Se den komplette Java-træningsserie her.
Når der er involveret flere tråde, skal vi styre disse tråde på en sådan måde, at en ressource kan tilgås af en enkelt tråd ad gangen. I ovenstående eksempel skal den fil, der er adgang til af begge tråde, styres på en sådan måde, at T2 ikke kan få adgang til filen, før T1 er færdig med at få adgang til den.
Dette gøres i Java ved hjælp af “ Trådsynkronisering ”.
Hvad du vil lære:
- Trådsynkronisering i Java
- Multi-threading uden synkronisering
- Multi-threading med synkronisering
- Konklusion
Trådsynkronisering i Java
Da Java er et sprog med flere tråde, har trådsynkronisering stor betydning i Java, da flere tråde udføres parallelt i en applikation.
Vi bruger nøgleord “Synkroniseret” og 'Flygtig' for at opnå synkronisering i Java
Vi har brug for synkronisering, når det delte objekt eller ressource kan ændres. Hvis ressourcen er uforanderlig, læser trådene kun ressourcen enten samtidigt eller individuelt.
I dette tilfælde behøver vi ikke synkronisere ressourcen. I dette tilfælde sikrer JVM det Java-synkroniseret kode udføres af en tråd ad gangen .
Det meste af tiden kan samtidig adgang til delte ressourcer i Java indføre fejl som 'Memory inconsistency' og 'thread interference'. For at undgå disse fejl skal vi gå til synkronisering af delte ressourcer, så adgangen til disse ressourcer er gensidig eksklusiv.
Vi bruger et koncept kaldet Skærme til implementering af synkronisering. En skærm kan kun fås med én tråd ad gangen. Når en tråd får låsen, kan vi sige, at tråden er kommet ind i skærmen.
Når en skærm får adgang til en bestemt tråd, låses skærmen, og alle de andre tråde, der prøver at komme ind i skærmen, er suspenderet, indtil den tråd, der er adgang til, er færdig og frigør låsen.
Fremadrettet vil vi diskutere synkronisering i Java i detaljer i denne vejledning. Lad os nu diskutere nogle grundlæggende begreber relateret til synkronisering i Java.
Race-tilstand i Java
I et multitrådet miljø, når mere end en tråd forsøger at få adgang til en delt ressource til skrivning samtidigt, kæmper flere tråde med hinanden for at få adgang til ressourcen. Dette giver anledning til 'race-tilstand'.
En ting at overveje er, at der ikke er noget problem, hvis flere tråde kun forsøger at få adgang til en delt ressource til læsning. Problemet opstår, når flere tråde får adgang til den samme ressource på samme tid.
Raceforhold opstår på grund af manglende korrekt synkronisering af tråde i programmet. Når vi korrekt synkroniserer trådene således, at kun én tråd ad gangen får adgang til ressourcen, og løbetilstanden ophører med at eksistere.
Så hvordan opdager vi race-tilstanden?
Den bedste måde at opdage race-tilstand på er gennemgang af kode. Som programmør bør vi gennemgå koden grundigt for at kontrollere, om der er potentielle løbsforhold.
Låse / skærme i Java
Vi har allerede nævnt, at vi bruger skærme eller låse til at implementere synkronisering. Skærmen eller låsen er en intern enhed og er knyttet til ethvert objekt. Så når en tråd har brug for at få adgang til objektet, skal den først anskaffe lås eller monitor for objektet, arbejde på objektet og derefter frigøre låsen.
Låse i Java ser ud som vist nedenfor:
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(); } } Som vist ovenfor har vi en låsemetode (), der låser forekomsten. Alle tråde, der kalder metoden lock (), blokeres, indtil unblock () -metodesættene er låst, markeres som falske og underretter alle ventende tråde.
Nogle tip til at huske om låse:
- I Java har hvert objekt en lås eller en skærm. Denne lås kan tilgås med en tråd.
- Ad gangen kan kun en tråd erhverve denne skærm eller låse.
- Java-programmeringssprog giver et nøgleord Synkroniseret ', der giver os mulighed for at synkronisere trådene ved at lave en blok eller metode som synkroniseret.
- De delte ressourcer, som trådene har brug for at få adgang til, opbevares under denne synkroniserede blok / metode.
Mutexes i Java
Vi har allerede diskuteret, at der i et multitrådet miljø kan forekomme løbsbetingelser, når mere end en tråd forsøger at få adgang til de delte ressourcer samtidigt, og løbsbetingelserne resulterer i uventet output.
Den del af programmet, der forsøger at få adgang til den delte ressource, kaldes “Kritisk sektion” . For at undgå forekomsten af race-forhold er der behov for at synkronisere adgangen til det kritiske afsnit. Ved at synkronisere dette kritiske afsnit sørger vi for, at kun en tråd kan få adgang til det kritiske afsnit ad gangen.
Den enkleste type synkronisering er “mutex”. Mutex sikrer, at kun en tråd kan udføre den kritiske sektion i et givet tilfælde.
Mutex ligner konceptet med skærme eller låse, vi diskuterede ovenfor. Hvis en tråd har brug for at få adgang til et kritisk afsnit, skal den erhverve mutex. Når mutex er erhvervet, får tråden adgang til den kritiske sektionskode, og når den er færdig, frigiver den mutex.
De andre tråde, der venter på at få adgang til den kritiske sektion, bliver blokeret i mellemtiden. Så snart den tråd, der holder mutex, frigiver den, kommer en anden tråd ind i det kritiske afsnit.
hvad er den bedste e-mail at have
Der er flere måder, hvorpå vi kan implementere en mutex i Java.
- Brug af synkroniseret nøgleord
- Brug af Semaphore
- Brug af ReentrantLock
I denne vejledning vil vi diskutere den første tilgang, dvs. synkronisering. De to andre tilgange - Semaphore og ReentrantLock vil blive diskuteret i den næste vejledning, hvor vi vil diskutere den samtidige java-pakke.
Synkroniseret nøgleord
Java leverer nøgleordet 'Synkroniseret', der kan bruges i et program til at markere et kritisk afsnit. Det kritiske afsnit kan være en blok kode eller en komplet metode. Således kan kun en tråd få adgang til det kritiske afsnit, der er markeret med det synkroniserede nøgleord.
Vi kan skrive de samtidige dele (dele, der udføres samtidigt) for en applikation ved hjælp af det synkroniserede nøgleord. Vi slipper også løbsvilkårene ved at lave en blok kode eller en metode synkroniseret.
Når vi markerer en blok eller metode synkroniseret, beskytter vi de delte ressourcer inden i disse enheder mod samtidig adgang og derved korruption.
Typer af synkronisering
Der er to typer synkronisering som forklaret nedenfor:
# 1) Processynkronisering
Processynkronisering involverer flere processer eller tråde, der udføres samtidigt. De når i sidste ende en tilstand, hvor disse processer eller tråde forpligter sig til en bestemt rækkefølge af handlinger.
# 2) Trådsynkronisering
I trådsynkronisering forsøger mere end en tråd at få adgang til et delt rum. Trådene synkroniseres på en sådan måde, at der kun er adgang til det fælles rum af en tråd ad gangen.
Processynkroniseringen er uden for omfanget af denne vejledning. Derfor vil vi kun diskutere trådsynkronisering her.
I Java kan vi bruge det synkroniserede nøgleord med:
- En blok kode
- En metode
Ovenstående typer er gensidigt eksklusive typer trådsynkronisering. Gensidig udelukkelse forhindrer trådene i at få adgang til delte data fra at forstyrre hinanden.
Den anden type trådsynkronisering er 'InterThread-kommunikation', der er baseret på samarbejde mellem tråde. Interthread-kommunikation er uden for omfanget af denne vejledning.
Inden vi går videre med synkronisering af blokke og metoder, lad os implementere et Java-program for at demonstrere tråders opførsel, når der ikke er nogen synkronisering.
Multi-threading uden synkronisering
Følgende Java-program har flere tråde, der ikke er synkroniseret.
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'); } } }Produktion
Fra output kan vi se, at da trådene ikke synkroniseres, er output inkonsekvent. Begge tråde starter, og derefter viser de tælleren efter hinanden. Begge tråde går ud i slutningen.
Fra det givne program skulle den første tråd være afsluttet efter visning af tællerværdierne, og derefter skulle den anden tråd være begyndt at vise tællerværdierne.
Lad os nu gå til synkronisering og begynde med kodeblokssynkronisering.
Synkroniseret kodeblok
En synkroniseret blok bruges til at synkronisere en blok med kode. Denne blok består normalt af et par linjer. En synkroniseret blok bruges, når vi ikke ønsker, at en hel metode skal synkroniseres.
For eksempel, vi har en metode med f.eks. 75 linjer kode. Ud af dette kræves kun 10 linjer kode, der skal udføres af en tråd ad gangen. I dette tilfælde, hvis vi laver hele metoden som synkroniseret, vil det være en byrde for systemet. I sådanne situationer går vi efter synkroniserede blokke.
Omfanget af den synkroniserede metode er altid mindre end for en synkroniseret metode. En synkroniseret metode låser et objekt fra en delt ressource, der skal bruges af flere tråde.
Den generelle syntaks for en synkroniseret blok er som vist nedenfor:
synchronized (lock_object){ //synchronized code statements }Her er “lock_object” et objektreferenceudtryk, som låsen skal opnås på. Så når en tråd ønsker at få adgang til de synkroniserede udsagn inde i blokken til udførelse, så skal den erhverve låsen på 'lock_object' monitoren.
Som allerede diskuteret sikrer det synkroniserede nøgleord, at kun en tråd kan erhverve en lås ad gangen, og alle de andre tråde skal vente, indtil tråden, der holder låsen, er færdig og frigør låsen.
Bemærk
- En 'NullPointerException' kastes, hvis det anvendte lås_objekt er Null.
- Hvis en tråd sover, mens den stadig holder låsen, frigøres låsen ikke. De andre tråde vil ikke kunne få adgang til det delte objekt i løbet af denne hviletid.
Nu vil vi præsentere ovenstående eksempel, der allerede blev implementeret med små ændringer. I det tidligere program synkroniserede vi ikke koden. Nu bruger vi den synkroniserede blok og sammenligner output.
Multi-threading med synkronisering
I Java-programmet nedenfor bruger vi en synkroniseret blok. I køremetoden synkroniserer vi koden for linjer, der udskriver tælleren for hver tråd.
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'); } } }Produktion
Nu er output fra dette program ved hjælp af synkroniseret blok ret konsistent. Som forventet begynder begge tråde at blive udført. Den første tråd afsluttede visning af tællerværdier og afslutninger. Derefter viser den anden tråd tællerværdierne og afslutter.
Synkroniseret metode
Lad os diskutere den synkroniserede metode i dette afsnit. Tidligere har vi set, at vi kan erklære en lille blok bestående af færre kodelinjer som en synkroniseret blok. Hvis vi ønsker, at hele funktionen skal synkroniseres, kan vi erklære en metode som synkroniseret.
Når en metode gøres synkroniseret, er det kun en tråd, der kan foretage et metodekald ad gangen.
Den generelle syntaks til at skrive en synkroniseret metode er:
synchronized method_name (parameters){ //synchronized code } Ligesom en synkroniseret blok, i tilfælde af en synkroniseret metode, har vi brug for en lock_object, der vil blive brugt af tråde, der får adgang til den synkroniserede metode.
For den synkroniserede metode kan låseobjektet være et af følgende:
- Hvis den synkroniserede metode er statisk, gives låseobjektet af '.class' objekt.
- For en ikke-statisk metode gives låsegenstanden af det aktuelle objekt, dvs. 'dette' objekt.
Et ejendommeligt træk ved det synkroniserede nøgleord er, at det genindtræder. Dette betyder, at en synkroniseret metode kan kalde en anden synkroniseret metode med samme lås. Så en tråd, der holder låsen, kan få adgang til en anden synkroniseret metode uden at skulle erhverve en anden lås.
Den synkroniserede metode demonstreres ved hjælp af nedenstående eksempel.
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(); } } Produktion
er netværkssikkerhedsnøglen den samme som adgangskoden
I ovenstående program har vi brugt en synkroniseret metode til at udskrive kvadraterne på et tal. Den øvre grænse for nummeret overføres til metoden som et argument. Fra og med 1 udskrives firkanterne for hvert nummer, indtil den øvre grænse er nået.
I hovedfunktionen oprettes trådforekomsten. Hver trådforekomst sendes et nummer til at udskrive firkanter.
Som nævnt ovenfor, når en metode, der skal synkroniseres, er statisk, er låseobjektet involveret i klassen og ikke objektet. Dette betyder, at vi låser på klassen og ikke på objektet. Dette kaldes statisk synkronisering.
Et andet eksempel er givet nedenfor.
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(); } } Produktion
I ovenstående program udskriver vi multiplikationstabeller med tal. Hvert nummer, hvis tabel skal udskrives, er en trådforekomst af forskellige trådklasser. Således udskriver vi multiplikationstabeller på 2 og 5, så vi har to klasser 'thread_one og thread_two til at udskrive henholdsvis tabellerne 2 og 5.
For at opsummere udfører det Java-synkroniserede nøgleord følgende funktioner:
- Det synkroniserede nøgleord i Java garanterer gensidig eksklusiv adgang til delte ressourcer ved at tilvejebringe en låsemekanisme. Låsning forhindrer også race betingelser.
- Ved hjælp af det synkroniserede nøgleord forhindrer vi samtidige programmeringsfejl i kode.
- Når en metode eller blok erklæres som synkroniseret, har en tråd brug for en eksklusiv lås for at komme ind i den synkroniserede metode eller blok. Efter udførelse af de nødvendige handlinger frigør tråden låsen og skyller skriveoperationen. På denne måde vil det fjerne hukommelsesfejl relateret til inkonsekvens.
Flygtige i Java
Et flygtigt nøgleord i Java bruges til at gøre klasser trådsikre. Vi bruger også det flygtige nøgleord til at ændre variabelværdien ved forskellige tråde. Et flygtigt nøgleord kan bruges til at erklære en variabel med primitive typer såvel som objekter.
I visse tilfælde bruges et ustabilt nøgleord som et alternativ til det synkroniserede nøgleord, men bemærk at det ikke er en erstatning for det synkroniserede nøgleord.
Når en variabel erklæres ustabil, caches dens værdi aldrig, men læses altid fra hovedhukommelsen. En flygtig variabel garanterer ordre og synlighed. Selvom en variabel kan erklæres som flygtig, kan vi ikke erklære klasser eller metoder som flygtige.
Overvej følgende blok kode:
class ABC{ static volatile int myvar =10; }I ovenstående kode er variablen myvar statisk og flygtig. En statisk variabel deles mellem alle klasseobjekter. Den flygtige variabel findes altid i hovedhukommelsen og cachelagres aldrig.
Derfor vil der kun være en kopi af myvar i hovedhukommelsen, og alle læse / skrive-handlinger udføres på denne variabel fra hovedhukommelsen. Hvis myvar ikke blev erklæret som flygtig, ville hvert trådobjekt have en anden kopi, der ville resultere i uoverensstemmelser.
Nogle af forskellene mellem flygtige og synkroniserede søgeord er angivet nedenfor.
| Flygtigt nøgleord | Synkroniseret nøgleord |
|---|---|
| Det flygtige nøgleord bruges kun med variabler. | Det synkroniserede nøgleord bruges med kodeblokke og metoder. |
| Et ustabilt nøgleord kan ikke blokere tråden til at vente. | Det synkroniserede nøgleord kan blokere tråden til at vente. |
| Trådens ydeevne forbedres med Volatile. | Trådens ydeevne nedbrydes noget med synkroniseret. |
| Flygtige variabler findes i hovedhukommelsen. | Synkroniserede konstruktioner findes ikke i hovedhukommelsen. |
| Flygtig synkroniserer en variabel mellem trådhukommelse og hovedhukommelse ad gangen. | Synkroniseret nøgleord synkroniserer alle variablerne på én gang. |
Dødlås i Java
Vi har set, at vi kan synkronisere flere tråde ved hjælp af synkroniseret nøgleord og gøre programmer trådsikre. Ved at synkronisere trådene sikrer vi, at de flere tråde udføres samtidigt i et miljø med flere tråde.
Nogle gange opstår der imidlertid en situation, hvor tråde ikke længere kan fungere samtidigt. I stedet venter de uendeligt. Dette sker, når en tråd venter på en ressource, og den ressource er blokeret af den anden tråd.
Den anden tråd venter derimod på den ressource, der er blokeret af den første tråd. En sådan situation giver anledning til 'deadlock' i Java.
Deadlock i Java er afbildet ved hjælp af nedenstående billede.
Som vi kan se fra ovenstående diagram, har tråd A låst ressourcen r1 og venter på ressource R2. Tråd B har derimod blokeret ressource r2 og venter på r1.
Således kan ingen af trådene afslutte deres udførelse, medmindre de får fat i de ventende ressourcer. Denne situation har resulteret i dødvande, hvor begge tråde venter uendeligt på ressourcerne.
Nedenfor er et eksempel på deadlocks i 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(); } }Produktion
I ovenstående program har vi to delte ressourcer og to tråde. Begge tråde forsøger at få adgang til de delte ressourcer en efter en. Outputtet viser begge tråde, der låser en ressource hver, mens de venter på de andre. Dermed skaber en blokeret situation.
Selvom vi ikke kan forhindre blokeringer af dødvande, kan de helt sikkert undgå dem ved at tage nogle skridt.
Nedenfor er de måder, hvorpå vi kan undgå blokeringer i Java.
# 1) Ved at undgå indlejrede låse
At have indlejrede låse er den vigtigste grund til at have blokeringer. Indlejrede låse er de låse, der gives til flere tråde. Derfor bør vi undgå at give låse til mere end en tråd.
# 2) Brug thread Join
Vi skal bruge Thread.join med maksimal tid, så trådene kan bruge den maksimale tid til udførelse. Dette forhindrer blokering, der for det meste opstår, da en tråd kontinuerligt venter på andre.
# 3) Undgå unødvendig lås
Vi skal kun låse den nødvendige kode. At have unødvendige låse til koden kan føre til blokeringer i programmet. Da deadlocks kan bryde koden og hindre strømmen af programmet, bør vi være tilbøjelige til at undgå deadlocks i vores programmer.
Ofte stillede spørgsmål
Q # 1) Hvad er synkronisering, og hvorfor er det vigtigt?
Svar: Synkronisering er processen med at kontrollere adgangen til en delt ressource til flere tråde. Uden synkronisering kan flere tråde opdatere eller ændre den delte ressource på samme tid, hvilket resulterer i uoverensstemmelser.
Derfor skal vi sikre, at trådene i et miljø med flere tråde synkroniseres, så den måde, hvorpå de får adgang til de delte ressourcer, er gensidigt eksklusiv og konsekvent.
Q # 2) Hvad er synkronisering og ikke-synkronisering i Java?
Svar: Synkronisering betyder, at en konstruktion er trådsikker. Dette betyder, at flere tråde ikke kan få adgang til konstruktionen (kodeblok, metode osv.) På én gang.
Ikke-synkroniserede konstruktioner er ikke trådsikre. Flere tråde kan til enhver tid få adgang til ikke-synkroniserede metoder eller blokke. En populær ikke-synkroniseret klasse i Java er StringBuilder.
Q # 3) Hvorfor er synkronisering påkrævet?
Svar: Når processer skal udføres samtidigt, har vi brug for synkronisering. Dette skyldes, at vi har brug for ressourcer, der kan deles mellem mange processer.
For at undgå sammenstød mellem processer eller tråde for at få adgang til delte ressourcer er vi nødt til at synkronisere disse ressourcer, så alle tråde får adgang til ressourcer, og applikationen kører også problemfrit.
Spørgsmål nr. 4) Hvordan får du en synkroniseret ArrayList?
Svar: Vi kan bruge Collections.synchronized list-metoden med ArrayList som et argument for at konvertere ArrayList til en synkroniseret liste.
Q # 5) Er HashMap synkroniseret?
hvordan man vælger alternativknappen i selen webdriver
Svar: Nej, HashMap er ikke synkroniseret, men HashTable er synkroniseret.
Konklusion
I denne vejledning har vi diskuteret synkronisering af tråde i detaljer. Sammen med det lærte vi også om det ustabile nøgleord og deadlocks i Java. Synkronisering består af proces- og trådsynkronisering.
I et multithreading-miljø er vi mere bekymrede over trådsynkronisering. Vi har set den synkroniserede nøgleordstilgang for trådsynkronisering her.
Deadlock er en situation, hvor flere tråde uendeligt venter på ressourcer. Vi har set eksemplet med blokeringer i Java sammen med metoderne til at undgå blokeringer i Java.
=> Besøg her for at lære Java fra bunden.
Anbefalet læsning
- Thread.Sleep () - Tråd Sleep () Metode i Java med eksempler
- Java-tråde med metoder og livscyklus
- Java Basics: Java Syntax, Java Class og Core Java Concepts
- Multithreading i Java - Vejledning med eksempler
- Multithreading i C ++ med eksempler
- JAVA-vejledning til begyndere: 100+ praktiske Java-videovejledninger
- Java-komponenter: Java Platform, JDK, JRE og Java Virtual Machine
- Java String Tutorial | Java strengmetoder med eksempler