Synkronisering i Java | Forklart

Når vi begynner to eller flere tråder i det samme programmet, er det en mulighet for at flere trådene prøver å få tilgang til samme ressurs, og følgelig vil inkonsekvente resultater bli produsert. Og for å gi pålitelig kommunikasjon mellom de flere trådene, brukes synkroniseringsbegrepet i Java. Det synkroniserte nøkkelordet i Java synkroniserer handlingene til flere tråder og sørger for at bare en tråd kan få tilgang til en bestemt ressurs på et bestemt tidspunkt.

Denne oppskrivningen vil utforske de forskjellige aspektene ved synkronisering i Java, og i denne forbindelse vil denne artikkelen dekke følgende konsepter:

• Hva er synkronisering i Java?
• Hvorfor brukes synkronisering?
• Hvorfor synkronisert nøkkelord brukes i Java
• Hvordan bruke synkronisering i Java

Så la oss få

Hva er synkronisering i Java?

Det er en prosess som kontrollerer tilgangen til mer enn en tråd til en hvilken som helst delt ressurs, og unngår derfor inkonsekvente resultater.

Hvorfor brukes synkronisering?

I Java er hovedformålet med å bruke synkronisering å unngå inkonsekvent oppførsel av tråder og å forhindre interferens for tråder.

Hvorfor synkronisert nøkkelord brukes i Java

Synkronisert er en modifiserer som bare kan brukes på metodene og blokker og kan ikke brukes på variabler og klasser. For å forstå dette konseptet

Hvordan bruke synkronisering i Java

Vi vil vurdere noen eksempler for en dyp forståelse. Til å begynne med vil vi lage et veldig enkelt Java -program for å øke verdien av telleren. Deretter vil vi utvide dette eksemplet til det multithreaded -scenariet. Etter hvert vil vi ta turen mot synkroniseringen der vi vil lære hvorfor det synkroniserte nøkkelordet brukes i Java?

Eksempel
I dette eksemplet vil vi lage et enkelt program som har en variabel disk og en brukerdefinert funksjon inkrementValue ().

klasse motklasse
int teller;
public void incrementValue ()
teller ++;


offentlig klasse synkroniseringseksempel
public static void main (String [] args)
Motklassetall = ny motklasse ();
telle.inkrementValue ();
System.ute.Println ("Counter:" + Count.disk);

Hver gang vi påkaller inkrementValue () det vil øke verdien av disk av 1:

Verdien av telleren økes vellykket til 1 som viser hensiktsmessigheten av programmet vårt. Hvis vi kaller inkrementValue () metode to ganger, da vil verdien av telleren 2. Tilsvarende vil det vise verdien av teller som 3 hvis vi kaller inkrementValue () Metode tre ganger som vist i utdraget nedenfor:

I ovennevnte kodebit påkalte vi inkrementValue () metode fire ganger, så den viser verdien av teller som 4.

Eksempel
La oss nå utvide eksemplet ovenfor litt der vi lager en tråd som vil kalle inkrementValue () ti ganger:

klasse motklasse
int teller;
public void incrementValue ()
teller ++;


offentlig klasse synkroniseringseksempel
public static void main (String [] args) kaster unntak
Motklassetall = ny motklasse ();
Tråd Th1 = ny tråd (ny løpbar ()
public void run ()
for (int i = 1; i <= 10; i++)
telle.inkrementValue ();


);
Th1.start();
Th1.bli med();
System.ute.Println ("Counter:" + Count.disk);

I ovennevnte kodesnippet-sammenføyning () brukes metoden med gjenstand for trådklasse slik at den ene tråden skal vente til den andre tråden fullfører utførelsen. Ovennevnte kode-snippet produserer følgende utdata:

Fra utgangen er det klart at tråden kaller inkrementValue () ti ganger og dermed er verdien av telleren lik ti.

Så langt så bra, la oss nå vurdere et flertrådet miljø og lage en tråd til for å se hva som vil skje når to tråder krever samme ressurs (i.e. inkrementValue () metode) samtidig.

Eksempel

I dette eksemplet har vi to tråder som begge vil kalle inkrementValue () -metoden fem hundre ganger:

klasse motklasse
int teller;
public void incrementValue ()
teller ++;


offentlig klasse synkroniseringseksempel
public static void main (String [] args) kaster unntak
Motklassetall = ny motklasse ();
Tråd Th1 = ny tråd (ny løpbar ()
public void run ()
for (int i = 1; i <= 500; i++)
telle.inkrementValue ();


);
Tråd Th2 = ny tråd (ny løpbar ()
public void run ()
for (int i = 1; i <= 500; i++)
telle.inkrementValue ();


);
Th1.start();
Th1.bli med();
Th2.start();
Th2.bli med();
System.ute.Println ("Counter:" + Count.disk);

Siden begge trådene kaller motverdien () fem hundre ganger, bør teknisk sett verdien av økning være tusen. La oss vurdere utdraget nedenfor for å se hva som sier output:

I stedet for “1000”, får vi “753”, hva betyr det nå? Hvorfor fikk vi ikke tellerens verdi som 1000?

Vel, det er fordi multithreading støtter parallell prosessering, og det er derfor alltid en mulighet for at begge trådene henter verdien av telleren samtidig og at begge får samme verdi av teller, i et slikt tilfelle i stedet for å øke den verdien av teller to ganger, det øker bare en gang.

Så hvordan du kan unngå et slikt scenario? Vi vil! I slike tilfeller vil det synkroniserte søkeordet bli brukt.

Eksempel
Vi vil bruke det synkroniserte nøkkelordet med "inkrementValue ()”Metode som et resultat bare en tråd vil få tilgang til“inkrementValue ()”Metode på en gang. All koden vil forbli den samme som i forrige eksempel bare synkronisert søkeord vil bli lagt til med inkrementValue () -metoden som vist i utdraget:

offentlig synkronisert tomrom inkrementValue ()
teller ++;

Nå hvis tråd 1 jobber med inkrementValue () metode vil tråd 2 vente, og omvendt. Denne gangen får vi følgende utdata:

Ovennevnte utdrag viser effektiviteten til det "synkroniserte" nøkkelordet.

Konklusjon

Synkronisering er en prosess som kontrollerer tilgangen til mer enn en tråd og sørger for/verifiserer at bare en tråd kan få tilgang til ressursen på et bestemt tidspunkt. For å oppnå synkronisering brukes det synkroniserte nøkkelordet/modifikatoren, og det kan brukes på metodene og blokker, men kan ikke brukes på variabler og klasser. I Java er hovedformålet med å bruke synkronisering å unngå inkonsekvent oppførsel av tråder og å forhindre interferens for tråder.