Synkronisering i Java er evnen til at kontrollere adgangen til flere tråde til enhver delt ressource.

Java-synkronisering er en bedre mulighed, hvor vi kun vil tillade én tråd at få adgang til den delte ressource.

Hvorfor bruge synkronisering?

Synkroniseringen bruges hovedsageligt til

1. For at forhindre trådinterferens.
2. For at forhindre konsistensproblem.

Typer af synkronisering

Der er to typer synkronisering

1. Processynkronisering
2. Trådsynkronisering

Her vil vi kun diskutere trådsynkronisering.

Trådsynkronisering

Der er to typer trådsynkronisering, gensidig eksklusiv og inter-trådskommunikation.

1. Gensidig eksklusiv
   1. Synkroniseret metode.
   2. Synkroniseret blok.
   3. Statisk synkronisering.
2. Samarbejde (Inter-thread kommunikation i java)

Gensidig eksklusiv

Mutual Exclusive hjælper med at forhindre tråde i at forstyrre hinanden, mens de deler data. Det kan opnås ved at bruge følgende tre måder:

1. Ved at bruge synkroniseret metode
2. Ved at bruge Synchronized Block
3. Ved at bruge statisk synkronisering

Begrebet lås i Java

Synkronisering er bygget op omkring en intern enhed kendt som låsen eller skærmen. Hvert objekt har en lås tilknyttet. Ifølge konventionen skal en tråd, der har brug for ensartet adgang til et objekts felter, erhverve objektets lås, før den får adgang til dem, og derefter frigive låsen, når den er færdig med dem.

Fra Java 5 indeholder pakken java.util.concurrent.locks flere låseimplementeringer.

Forstå problemet uden synkronisering

I dette eksempel er der ingen synkronisering, så output er inkonsekvent. Lad os se eksemplet:

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-synkroniseret metode

Hvis du erklærer en metode som synkroniseret, er den kendt som synkroniseret metode.

Synkroniseret metode bruges til at låse et objekt for enhver delt ressource.

Når en tråd påberåber en synkroniseret metode, erhverver den automatisk låsen for det pågældende objekt og frigiver den, når tråden fuldfører sin opgave.

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++){>

Eksempel på synkroniseret metode ved brug af anonym klasse

I dette program har vi oprettet de to tråde ved at bruge den anonyme klasse, så der kræves 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++){>