logo

TechCodeview

Szinkronizálás Java nyelven

A Java szinkronizálása lehetővé teszi több szál hozzáférésének szabályozását bármely megosztott erőforráshoz.

A Java szinkronizálás jobb megoldás, ha csak egy szálat szeretnénk engedélyezni a megosztott erőforráshoz való hozzáféréshez.

Miért használja a szinkronizálást?

A szinkronizálást főleg arra használják

  1. A szál interferencia elkerülése érdekében.
  2. A konzisztencia problémájának megelőzése érdekében.

A szinkronizálás típusai

A szinkronizálásnak két típusa van

  1. Folyamat szinkronizálás
  2. Szálszinkronizálás

Itt csak a szál szinkronizálását tárgyaljuk.

Szálszinkronizálás

A szálszinkronizálásnak két típusa létezik, kölcsönösen kizáró és szálak közötti kommunikáció.

  1. Kölcsönös exkluzív
    1. Szinkronizált módszer.
    2. Szinkronizált blokk.
    3. Statikus szinkronizálás.
  2. Együttműködés (szálak közötti kommunikáció java-ban)

Kölcsönös exkluzív

A Mutual Exclusive segít abban, hogy a szálak ne zavarják egymást adatmegosztás közben. Ezt a következő három módszerrel lehet elérni:

  1. Szinkronizált módszer használatával
  2. Szinkronizált blokk használatával
  3. Statikus szinkronizálás használatával

A zár fogalma a Java nyelven

A szinkronizálás a zárnak vagy monitornak nevezett belső entitás köré épül. Minden objektumhoz tartozik egy zár. Megállapodás szerint egy olyan szálnak, amelynek állandó hozzáférésre van szüksége egy objektum mezőihez, meg kell szereznie az objektum zárolását, mielőtt hozzáférne, majd fel kell oldania a zárolást, ha végzett velük.

A Java 5-től kezdve a java.util.concurrent.locks csomag számos zármegvalósítást tartalmaz.

A probléma megértése szinkronizálás nélkül

Ebben a példában nincs szinkronizálás, így a kimenet inkonzisztens. Lássuk a példát:

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 szinkronizált módszer

Ha bármely metódust szinkronizáltnak deklarál, azt szinkronizált módszernek nevezzük.

A szinkronizált módszerrel zárolható egy objektum bármely megosztott erőforráshoz.

Amikor egy szál meghív egy szinkronizált metódust, automatikusan megszerzi az objektum zárolását, és feloldja, amikor a szál befejezi a feladatát.

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

Példa szinkronizált metódusra névtelen osztály használatával

Ebben a programban a két szálat az anonim osztály használatával hoztuk létre, így kevesebb kódolásra van szükség.

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