java synchronized what is thread synchronization java
Denne opplæringen forklarer trådsynkronisering i Java sammen med relaterte konsepter som Java Lock, Race Condition, Mutex, Java Volatile & Deadlock i Java:
I et flertrådingsmiljø der flere tråder er involvert, vil det sikkert komme sammenstøt når mer enn en tråd prøver å få til samme ressurs samtidig. Disse sammenstøtene resulterer i 'løpetilstand' og dermed gir programmet uventede resultater.
For eksempel, en enkelt fil oppdateres av to tråder. Hvis en tråd T1 er i ferd med å oppdatere denne filen, si noen variabler. Nå mens denne oppdateringen av T1 fremdeles pågår, la oss si at den andre tråden T2 også oppdaterer den samme variabelen. På denne måten vil variabelen gi feil resultater.
=> Se opp hele Java Training Series her.
Når flere tråder er involvert, bør vi administrere disse trådene på en slik måte at en ressurs kan nås av en enkelt tråd om gangen. I eksemplet ovenfor skal filen som begge trådene får tilgang til, administreres på en slik måte at T2 ikke får tilgang til filen før T1 er ferdig med å få tilgang til den.
Dette gjøres i Java ved hjelp av “ Trådesynkronisering ”.
Hva du vil lære:
- Trådesynkronisering i Java
- Multitrading uten synkronisering
- Multitrading med synkronisering
- Konklusjon
Trådesynkronisering i Java
Siden Java er et språk med flere tråder, har trådsynkronisering mye betydning i Java ettersom flere tråder utføres parallelt i et program.
Vi bruker nøkkelord “Synkronisert” og 'flyktige' for å oppnå synkronisering i Java
Vi trenger synkronisering når det delte objektet eller ressursen er muterbar. Hvis ressursen er uforanderlig, vil trådene bare lese ressursen enten samtidig eller hver for seg.
I dette tilfellet trenger vi ikke å synkronisere ressursen. I dette tilfellet sørger JVM for det Java-synkronisert kode kjøres av en tråd om gangen .
Som regel kan samtidig tilgang til delte ressurser i Java introdusere feil som 'Memory inconsistency' og 'thread interference'. For å unngå disse feilene må vi gå til synkronisering av delte ressurser slik at tilgangen til disse ressursene er gjensidig utelukkende.
Vi bruker et konsept som heter Overvåker for å implementere synkronisering. En skjerm kan nås med bare en tråd om gangen. Når en tråd får låsen, kan vi si at tråden har kommet inn i skjermen.
Når du får tilgang til en skjerm med en bestemt tråd, blir skjermen låst og alle de andre trådene som prøver å komme inn i skjermen, er suspendert til tilgangstråden er ferdig og frigjør låsen.
Fremover vil vi diskutere synkronisering i Java i detalj i denne opplæringen. La oss nå diskutere noen grunnleggende konsepter knyttet til synkronisering i Java.
Race Condition I Java
I et flertrådet miljø, når flere enn en tråd prøver å få tilgang til en delt ressurs for skriving samtidig, vil flere tråder løpe hverandre for å få tilgang til ressursen. Dette gir opphav til ‘race condition’.
En ting å vurdere er at det ikke er noe problem hvis flere tråder prøver å få tilgang til en delt ressurs bare for lesing. Problemet oppstår når flere tråder får tilgang til samme ressurs samtidig.
Løpsforhold oppstår på grunn av mangel på riktig synkronisering av tråder i programmet. Når vi riktig synkroniserer trådene slik at bare en tråd om gangen får tilgang til ressursen, og løpetilstanden opphører å eksistere.
Så hvordan oppdager vi løpetilstanden?
Den beste måten å oppdage løpstilstand på er gjennomgang av kode. Som programmerer bør vi gjennomgå koden grundig for å se etter potensielle løpsforhold som kan oppstå.
Låser / skjermer i Java
Vi har allerede nevnt at vi bruker skjermer eller låser for å implementere synkronisering. Skjermen eller låsen er en intern enhet og er knyttet til alle objekter. Så når en tråd trenger tilgang til objektet, må den først skaffe seg lås eller monitor for objektet, jobbe med objektet og deretter slippe låsen.
Låser i Java vil se ut 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 () som låser forekomsten. Alle trådene som kaller lock () -metoden vil bli blokkert til unblock () -metodesettene er låst flagg til false og varsler alle ventende tråder.
Noen tips å huske på låser:
- I Java har hvert objekt en lås eller en skjerm. Denne låsen kan nås med en tråd.
- Om gangen kan bare en tråd skaffe seg denne skjermen eller låse.
- Java-programmeringsspråk gir et nøkkelord Synkronisert ’som lar oss synkronisere trådene ved å lage en blokk eller metode som Synkronisert.
- De delte ressursene som trådene trenger for tilgang, holdes under denne synkroniserte blokken / metoden.
Mutexes I Java
Vi har allerede diskutert at i et flertrådet miljø kan løpsforhold oppstå når mer enn en tråd prøver å få tilgang til de delte ressursene samtidig, og løpsforholdene resulterer i uventet produksjon.
Den delen av programmet som prøver å få tilgang til den delte ressursen kalles “Kritisk seksjon” . For å unngå løpsforhold er det behov for å synkronisere tilgangen til den kritiske delen. Ved å synkronisere denne kritiske delen, sørger vi for at bare en tråd kan få tilgang til den kritiske delen om gangen.
Den enkleste typen synkronisering er “mutex”. Mutex sørger for at bare en tråd kan utføre den kritiske delen i en hvilken som helst tilfelle.
Mutex ligner begrepet skjermer eller låser vi diskuterte ovenfor. Hvis en tråd trenger tilgang til en kritisk del, må den anskaffe mutex. Når mutex er anskaffet, vil tråden få tilgang til den kritiske seksjonskoden, og når du er ferdig, vil den frigjøre mutex.
De andre trådene som venter på å få tilgang til den kritiske delen, blir blokkert i mellomtiden. Så snart tråden som holder mutex slipper den, vil en annen tråd komme inn i den kritiske delen.
beste gratis PC renere programvare for Windows 10
Det er flere måter vi kan implementere en mutex på Java.
- Ved hjelp av synkronisert nøkkelord
- Bruke Semaphore
- Bruke ReentrantLock
I denne opplæringen vil vi diskutere den første tilnærmingen, dvs. synkronisering. De to andre tilnærmingene - Semaphore og ReentrantLock vil bli diskutert i neste opplæring hvor vi vil diskutere java samtidig pakke.
Synkronisert nøkkelord
Java gir nøkkelordet 'Synkronisert' som kan brukes i et program for å markere en kritisk seksjon. Den kritiske delen kan være en blokk med kode eller en komplett metode. Dermed kan bare en tråd få tilgang til den kritiske delen som er merket med det synkroniserte nøkkelordet.
Vi kan skrive samtidige deler (deler som kjøres samtidig) for et program ved hjelp av det synkroniserte nøkkelordet. Vi blir også kvitt løpsforholdene ved å lage en blokk med kode eller en metode synkronisert.
Når vi merker en blokk eller metode som er synkronisert, beskytter vi de delte ressursene i disse enhetene mot samtidig tilgang og derved korrupsjon.
Typer synkronisering
Det er to typer synkronisering som forklart nedenfor:
# 1) Prosesssynkronisering
Prosesssynkronisering innebærer flere prosesser eller tråder som kjøres samtidig. De når til slutt en tilstand der disse prosessene eller trådene forplikter seg til en bestemt sekvens av handlinger.
# 2) Trådsynkronisering
I trådsynkronisering prøver mer enn en tråd å få tilgang til et delt område. Trådene synkroniseres på en slik måte at det delte rommet kun er tilgjengelig av en tråd om gangen.
Prosessynkroniseringen er utenfor omfanget av denne opplæringen. Derfor vil vi bare diskutere trådsynkronisering her.
I Java kan vi bruke det synkroniserte nøkkelordet med:
- En blokk med kode
- En metode
Ovennevnte typer er gjensidig utelukkende typer trådsynkronisering. Gjensidig utelukkelse hindrer trådene som får tilgang til delte data fra å forstyrre hverandre.
Den andre typen trådsynkronisering er 'InterThread-kommunikasjon' som er basert på samarbeid mellom tråder. Interthread-kommunikasjon er utenfor omfanget av denne opplæringen.
Før vi fortsetter med synkronisering av blokker og metoder, la oss implementere et Java-program for å demonstrere oppførselen til tråder når det ikke er synkronisering.
Multitrading uten synkronisering
Følgende Java-program har flere tråder som ikke er synkronisert.
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'); } } }Produksjon
Fra utgangen kan vi se at ettersom trådene ikke synkroniseres, er utgangen inkonsekvent. Begge trådene starter, og så viser de telleren etter hverandre. Begge trådene går ut på slutten.
Fra det gitte programmet burde den første tråden ha gått ut etter å ha vist tellerverdiene, og deretter skulle den andre tråden ha begynt å vise tellerverdiene.
La oss nå gå til synkronisering og begynne med kodeblokk-synkronisering.
Synkronisert kodeblokk
En synkronisert blokk brukes til å synkronisere en kodeblokk. Denne blokken består vanligvis av noen få linjer. En synkronisert blokk brukes når vi ikke vil at en hel metode skal synkroniseres.
For eksempel, vi har en metode med si 75 linjer med kode. Ut av dette er det bare 10 linjer med kode som skal utføres av en tråd om gangen. I dette tilfellet, hvis vi lager hele metoden som synkronisert, vil det være en belastning for systemet. I slike situasjoner går vi for synkroniserte blokker.
Omfanget av den synkroniserte metoden er alltid mindre enn for en synkronisert metode. En synkronisert metode låser et objekt fra en delt ressurs som skal brukes av flere tråder.
Den generelle syntaksen til en synkronisert blokk er som vist nedenfor:
synchronized (lock_object){ //synchronized code statements }Her er 'lock_object' et objektreferanseuttrykk som låsen skal oppnås på. Så når en tråd vil ha tilgang til de synkroniserte utsagnene inne i blokken for utføring, må den skaffe seg låsen på 'lock_object' skjermen.
Som allerede diskutert, sørger det synkroniserte nøkkelordet for at bare en tråd kan få en lås om gangen, og alle de andre trådene må vente til tråden som holder låsen er ferdig og frigjør låsen.
Merk
- En 'NullPointerException' kastes hvis lock_object brukes er Null.
- Hvis en tråd sover mens du fortsatt holder låsen, løsnes ikke låsen. De andre trådene vil ikke kunne få tilgang til det delte objektet i løpet av denne hviletiden.
Nå vil vi presentere eksemplet ovenfor som allerede ble implementert med små endringer. I det tidligere programmet synkroniserte vi ikke koden. Nå skal vi bruke den synkroniserte blokken og sammenligne utdataene.
Multitrading med synkronisering
I Java-programmet nedenfor bruker vi en synkronisert blokk. I kjøremetoden synkroniserer vi koden til linjer som skriver ut telleren 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'); } } }Produksjon
Nå er utdataene fra dette programmet ved hjelp av synkronisert blokk ganske konsistente. Som forventet begynner begge trådene å kjøres. Den første tråden avsluttet visningen av tellerverdiene og utgangene. Deretter viser den andre tråden tellerverdiene og avslutter.
Synkronisert metode
La oss diskutere den synkroniserte metoden i denne delen. Tidligere har vi sett at vi kan erklære en liten blokk som består av færre kodelinjer som en synkronisert blokk. Hvis vi vil at hele funksjonen skal synkroniseres, kan vi erklære en metode som synkronisert.
Når en metode blir synkronisert, vil bare en tråd kunne ringe en metode om gangen.
Den generelle syntaksen for å skrive en synkronisert metode er:
synchronized method_name (parameters){ //synchronized code } Akkurat som en synkronisert blokk, i tilfelle en synkronisert metode, trenger vi en lock_object som vil bli brukt av tråder som får tilgang til den synkroniserte metoden.
For den synkroniserte metoden kan låseobjektet være ett av følgende:
- Hvis den synkroniserte metoden er statisk, blir låseobjektet gitt av .class-objektet.
- For en ikke-statisk metode er låsegjenstanden gitt av det gjeldende objektet, dvs. 'dette' objektet.
Et særegent trekk ved det synkroniserte nøkkelordet er at det kommer inn på nytt. Dette betyr at en synkronisert metode kan ringe til en annen synkronisert metode med samme lås. Så en tråd som holder låsen kan få tilgang til en annen synkronisert metode uten å måtte anskaffe en annen lås.
hva er operativsystemet i datamaskinen
Den synkroniserte metoden demonstreres ved hjelp av eksemplet nedenfor.
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(); } } Produksjon
I programmet ovenfor har vi brukt en synkronisert metode for å skrive ut kvadratene til et tall. Den øvre grensen for tallet blir overført til metoden som et argument. Fra og med 1 skrives rutene for hvert nummer ut til den øvre grensen er nådd.
I hovedfunksjonen opprettes trådforekomsten. Hver trådforekomst sendes et tall for å skrive ut firkanter.
Som nevnt ovenfor, når en metode som skal synkroniseres er statisk, er låseobjektet involvert i klassen og ikke objektet. Dette betyr at vi vil låse på klassen og ikke på objektet. Dette kalles statisk synkronisering.
Et annet eksempel er gitt 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(); } } Produksjon
I programmet ovenfor skriver vi ut multiplikasjonstabeller med tall. Hvert tall hvis tabell skal skrives ut, er en trådforekomst av forskjellig trådklasse. Dermed skriver vi ut multiplikasjonstabeller på 2 og 5, så vi har to klasser ’thread_one og thread_two til å skrive ut henholdsvis tabellene 2 og 5.
For å oppsummere utfører det Java-synkroniserte nøkkelordet følgende funksjoner:
- Det synkroniserte nøkkelordet i Java garanterer gjensidig eksklusiv tilgang til delte ressurser ved å tilby en låsemekanisme. Låsing forhindrer også løpsforhold.
- Ved å bruke det synkroniserte nøkkelordet forhindrer vi samtidig programmeringsfeil i kode.
- Når en metode eller blokk er erklært som synkronisert, trenger en tråd en eksklusiv lås for å komme inn i den synkroniserte metoden eller blokken. Etter å ha utført de nødvendige handlingene, frigjør tråden låsen og vil skylle skriveoperasjonen. På denne måten vil det eliminere minnefeil relatert til inkonsekvens.
Flyktig i Java
Et ustabilt nøkkelord i Java brukes til å gjøre klasser trådsikre. Vi bruker også det flyktige nøkkelordet for å endre variabelverdien etter forskjellige tråder. Et ustabilt nøkkelord kan brukes til å erklære en variabel med primitive typer så vel som objekter.
I visse tilfeller brukes et flyktig nøkkelord som et alternativ for det synkroniserte nøkkelordet, men merk at det ikke er en erstatning for det synkroniserte nøkkelordet.
Når en variabel erklæres ustabil, blir verdien aldri lagret i hurtigbuffer, men blir alltid lest fra hovedminnet. En flyktig variabel garanterer bestilling og synlighet. Selv om en variabel kan erklæres som flyktig, kan vi ikke erklære klasser eller metoder som flyktige.
Vurder følgende blokk med kode:
class ABC{ static volatile int myvar =10; }I koden ovenfor er variabelen myvar statisk og ustabil. En statisk variabel deles mellom alle klasseobjektene. Den flyktige variabelen ligger alltid i hovedminnet og lagres aldri.
Derfor vil det bare være en kopi av myvar i hovedminnet, og alle lese / skrive handlinger vil bli gjort på denne variabelen fra hovedminnet. Hvis myvar ikke ble erklært som flyktig, ville hvert trådobjekt ha en annen kopi som ville resultere i inkonsekvenser.
Noen av forskjellene mellom flyktige og synkroniserte søkeord er oppført nedenfor.
| Flyktige nøkkelord | Synkronisert nøkkelord |
|---|---|
| Det flyktige nøkkelordet brukes bare med variabler. | Det synkroniserte nøkkelordet brukes med kodeblokker og metoder. |
| Et ustabilt nøkkelord kan ikke blokkere tråden for å vente. | Det synkroniserte nøkkelordet kan blokkere tråden for å vente. |
| Trådytelsen forbedres med Volatile. | Trådytelsen forringes noe med synkronisert. |
| Flyktige variabler ligger i hovedminnet. | Synkroniserte konstruksjoner ligger ikke i hovedminnet. |
| Flyktig synkroniserer en variabel mellom trådminne og hovedminne om gangen. | Synkronisert nøkkelord synkroniserer alle variablene samtidig. |
Dødlås i Java
Vi har sett at vi kan synkronisere flere tråder ved hjelp av synkronisert nøkkelord og gjøre programmer trådsikre. Ved å synkronisere trådene, sørger vi for at flere tråder kjøres samtidig i et miljø med flere tråder.
Noen ganger oppstår det imidlertid en situasjon der tråder ikke lenger kan fungere samtidig. I stedet venter de uendelig. Dette skjer når en tråd venter på en ressurs, og den ressursen er blokkert av den andre tråden.
Den andre tråden venter derimot på ressursen som er blokkert av den første tråden. En slik situasjon gir 'fastlåst' i Java.
Dødlås i Java er avbildet ved hjelp av bildet nedenfor.
Som vi kan se fra diagrammet ovenfor, har tråd A låst ressursen r1 og venter på ressursen R2. Tråd B, derimot, har blokkert ressurs R2 og venter på R1.
Dermed kan ingen av trådene fullføre utførelsen med mindre de får tak i de ventende ressursene. Denne situasjonen har resultert i fastlåst tilstand hvor begge trådene venter uendelig på ressursene.
Nedenfor er et eksempel på blokkeringer 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(); } }Produksjon
I programmet ovenfor har vi to delte ressurser og to tråder. Begge trådene prøver å få tilgang til de delte ressursene en etter en. Utgangen viser at begge trådene låser en ressurs hver mens de venter på de andre. Dermed skaper en fastlåst situasjon.
Selv om vi ikke kan forhindre at fastlåste situasjoner oppstår helt, kan vi absolutt unngå dem ved å ta noen skritt.
Oppført nedenfor er virkemidlene vi kan unngå fastlåsning i Java.
# 1) Ved å unngå nestede låser
Å ha nestede låser er den viktigste årsaken til å ha fastlåste. Nestede låser er låser som er gitt til flere tråder. Dermed bør vi unngå å gi låser til mer enn en tråd.
# 2) Bruk tråd Bli med
Vi bør bruke Thread.join med maksimal tid, slik at trådene kan bruke maksimal tid for utføring. Dette vil forhindre låsing som for det meste oppstår når en tråd kontinuerlig venter på andre.
# 3) Unngå unødvendig lås
Vi bør bare låse den nødvendige koden. Å ha unødvendige låser for koden kan føre til fastlåsning i programmet. Ettersom fastlåsinger kan bryte koden og hindre strømmen av programmet, bør vi være tilbøyelige til å unngå fastlåsning i programmene våre.
ofte stilte spørsmål
Q # 1) Hva er synkronisering og hvorfor er det viktig?
Svar: Synkronisering er prosessen med å kontrollere tilgangen til en delt ressurs til flere tråder. Uten synkronisering kan flere tråder oppdatere eller endre den delte ressursen samtidig, noe som resulterer i inkonsekvenser.
Dermed bør vi sikre at trådene synkroniseres i et miljø med flere tråder, slik at måten de får tilgang til de delte ressursene på, er gjensidig utelukkende og konsekvent.
Q # 2) Hva er synkronisering og ikke-synkronisering i Java?
Svar: Synkronisering betyr at en konstruksjon er en trådsikker. Dette betyr at flere tråder ikke får tilgang til konstruksjonen (kodeblokk, metode osv.) Samtidig.
Ikke-synkroniserte konstruksjoner er ikke trådsikre. Flere tråder har tilgang til ikke-synkroniserte metoder eller blokkeringer når som helst. En populær ikke-synkronisert klasse i Java er StringBuilder.
Spørsmål 3) Hvorfor er synkronisering nødvendig?
Svar: Når prosesser må utføres samtidig, trenger vi synkronisering. Dette er fordi vi trenger ressurser som kan deles mellom mange prosesser.
For å unngå sammenstøt mellom prosesser eller tråder for å få tilgang til delte ressurser, må vi synkronisere disse ressursene slik at alle trådene får tilgang til ressurser og applikasjonen også går greit.
Sp # 4) Hvordan får du en synkronisert ArrayList?
Svar: Vi kan bruke Collections.synchronized list method med ArrayList som et argument for å konvertere ArrayList til en synkronisert liste.
Q # 5) Er HashMap synkronisert?
c ++ spørsmål og svar
Svar: Nei, HashMap er ikke synkronisert, men HashTable er synkronisert.
Konklusjon
I denne opplæringen har vi diskutert synkronisering av tråder i detalj. Sammen med det lærte vi også om det ustabile søkeordet og fastlåsning i Java. Synkronisering består av prosess- og trådsynkronisering.
I et flertrådingsmiljø er vi mer opptatt av trådsynkronisering. Vi har sett den synkroniserte søkeordtilnærmingen til trådsynkronisering her.
Dødlås er en situasjon der flere tråder uendelig venter på ressurser. Vi har sett eksemplet på fastlåsning i Java sammen med metodene for å unngå fastlåsning i Java.
=> Besøk her for å lære Java fra bunnen av.
Anbefalt lesing
- Thread.Sleep () - Thread Sleep () Metode i Java med eksempler
- Java-tråder med metoder og livssyklus
- Java Basics: Java Syntax, Java Class og Core Java Concepts
- Multithreading In Java - Opplæring med eksempler
- Multitrading i C ++ med eksempler
- JAVA-opplæring for nybegynnere: 100+ praktiske Java-videoveiledninger
- Java-komponenter: Java-plattform, JDK, JRE og Java Virtual Machine
- Java String Tutorial | Java strengmetoder med eksempler