logo

TechCodeview

Synkronisering i Java

Synkronisering i Java är möjligheten att kontrollera åtkomsten av flera trådar till valfri delad resurs.

Java-synkronisering är ett bättre alternativ där vi vill tillåta endast en tråd att komma åt den delade resursen.

Varför använda Synkronisering?

Synkroniseringen används främst för att

  1. För att förhindra trådstörningar.
  2. För att förhindra konsistensproblem.

Typer av synkronisering

Det finns två typer av synkronisering

  1. Processsynkronisering
  2. Trådsynkronisering

Här kommer vi bara att diskutera trådsynkronisering.

Trådsynkronisering

Det finns två typer av trådsynkronisering, ömsesidig exklusiv och inter-trådskommunikation.

  1. Ömsesidigt exklusivt
    1. Synkroniserad metod.
    2. Synkroniserat block.
    3. Statisk synkronisering.
  2. Samarbete (kommunikation mellan trådar i java)

Ömsesidigt exklusivt

Mutual Exclusive hjälper till att förhindra att trådar stör varandra medan de delar data. Det kan uppnås genom att använda följande tre sätt:

  1. Genom att använda synkroniserad metod
  2. Genom att använda Synchronized Block
  3. Genom att använda statisk synkronisering

Begreppet lås i Java

Synkronisering är uppbyggd kring en intern enhet som kallas låset eller monitorn. Varje objekt har ett lås kopplat till sig. Enligt konvention måste en tråd som behöver konsekvent åtkomst till ett objekts fält skaffa objektets lås innan den kommer åt dem, och sedan släppa låset när det är klart med dem.

Från Java 5 innehåller paketet java.util.concurrent.locks flera låsimplementationer.

Förstå problemet utan synkronisering

I det här exemplet finns det ingen synkronisering, så utdata är inkonsekvent. Låt oss se exemplet:

TestSynchronization1.java 

 class Table{ void printTable(int n){//method not synchronized for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } class mythread1 extends thread{ table t; mythread1(table t){ this.t="t;" public void run(){ t.printtable(5); mythread2 mythread2(table t.printtable(100); testsynchronization1{ static main(string args[]){ obj="new" table(); only one object t1="new" mythread1(obj); t2="new" mythread2(obj); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 100 10 200 15 300 20 400 25 500 </pre> <h3>Java Synchronized Method</h3> <p>If you declare any method as synchronized, it is known as synchronized method.</p> <p>Synchronized method is used to lock an object for any shared resource.</p> <p>When a thread invokes a synchronized method, it automatically acquires the lock for that object and releases it when the thread completes its task.</p> <p> <strong>TestSynchronization2.java</strong> </p> <pre> //example of java synchronized method class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } class mythread1 extends thread{ table t; mythread1(table t){ this.t="t;" public void run(){ t.printtable(5); mythread2 mythread2(table t.printtable(100); testsynchronization2{ static main(string args[]){ obj="new" table(); only one object t1="new" mythread1(obj); t2="new" mythread2(obj); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <h3>Example of synchronized method by using annonymous class</h3> <p>In this program, we have created the two threads by using the anonymous class, so less coding is required.</p> <p> <strong>TestSynchronization3.java</strong> </p> <pre> //Program of synchronized method by using annonymous class class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } public class testsynchronization3{ static void main(string args[]){ final table obj="new" table(); only one object thread t1="new" thread(){ run(){ obj.printtable(5); }; t2="new" obj.printtable(100); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <hr></=5;i++){></pre></=5;i++){></pre></=5;i++){>

Java Synchronized Method

Om du deklarerar någon metod som synkroniserad kallas den för synkroniserad metod.

Synkroniserad metod används för att låsa ett objekt för alla delade resurser.

När en tråd anropar en synkroniserad metod, hämtar den automatiskt låset för det objektet och släpper det när tråden slutför sin uppgift.

TestSynchronization2.java 

 //example of java synchronized method class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } class mythread1 extends thread{ table t; mythread1(table t){ this.t="t;" public void run(){ t.printtable(5); mythread2 mythread2(table t.printtable(100); testsynchronization2{ static main(string args[]){ obj="new" table(); only one object t1="new" mythread1(obj); t2="new" mythread2(obj); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <h3>Example of synchronized method by using annonymous class</h3> <p>In this program, we have created the two threads by using the anonymous class, so less coding is required.</p> <p> <strong>TestSynchronization3.java</strong> </p> <pre> //Program of synchronized method by using annonymous class class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } public class testsynchronization3{ static void main(string args[]){ final table obj="new" table(); only one object thread t1="new" thread(){ run(){ obj.printtable(5); }; t2="new" obj.printtable(100); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <hr></=5;i++){></pre></=5;i++){>

Exempel på synkroniserad metod med användning av anonym klass

I det här programmet har vi skapat de två trådarna genom att använda den anonyma klassen, så det krävs mindre kodning.

TestSynchronization3.java 

 //Program of synchronized method by using annonymous class class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } public class testsynchronization3{ static void main(string args[]){ final table obj="new" table(); only one object thread t1="new" thread(){ run(){ obj.printtable(5); }; t2="new" obj.printtable(100); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <hr></=5;i++){>