Sincronizarea în Java este capacitatea de a controla accesul mai multor fire de execuție la orice resursă partajată.

Sincronizarea Java este o opțiune mai bună în cazul în care dorim să permitem unui singur fir să acceseze resursa partajată.

De ce să folosiți sincronizarea?

Sincronizarea este folosită în principal pentru

1. Pentru a preveni interferența firului.
2. Pentru a preveni problema de consistență.

Tipuri de sincronizare

Există două tipuri de sincronizare

1. Sincronizarea proceselor
2. Sincronizarea firelor

Aici, vom discuta doar despre sincronizarea firelor.

Sincronizarea firelor

Există două tipuri de sincronizare cu fire de execuție, exclusivă reciprocă și comunicare între fire.

1. Exclusiv reciproc
   1. Metoda sincronizata.
   2. Bloc sincronizat.
   3. Sincronizare statică.
2. Cooperare (comunicare inter-thread în java)

Exclusiv reciproc

Exclusivitatea reciprocă ajută la prevenirea interferențelor firelor între ele în timpul partajării datelor. Se poate realiza folosind următoarele trei moduri:

1. Prin utilizarea metodei sincronizate
2. Prin utilizarea blocului sincronizat
3. Prin utilizarea sincronizării statice

Conceptul de blocare în Java

Sincronizarea este construită în jurul unei entități interne cunoscute sub numele de blocare sau monitor. Fiecare obiect are asociat o lacăt. Prin convenție, un fir care are nevoie de acces consecvent la câmpurile unui obiect trebuie să obțină blocarea obiectului înainte de a le accesa și apoi să elibereze blocarea când a terminat cu ele.

Din Java 5 pachetul java.util.concurrent.locks conține mai multe implementări de blocare.

Înțelegerea problemei fără sincronizare

În acest exemplu, nu există sincronizare, deci ieșirea este inconsecventă. Să vedem exemplul:

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

Metoda sincronizată Java

Dacă declarați orice metodă ca fiind sincronizată, aceasta este cunoscută ca metodă sincronizată.

Metoda sincronizată este folosită pentru a bloca un obiect pentru orice resursă partajată.

Când un fir de execuție invocă o metodă sincronizată, acesta dobândește automat blocarea pentru acel obiect și o eliberează când firul de execuție își finalizează sarcina.

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

Exemplu de metodă sincronizată prin utilizarea clasei anonime

În acest program, am creat cele două fire folosind clasa anonimă, deci este necesară mai puțină codare.

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