Synchronizálás be Java
Mi Synchronizálás be Java?
In Java, a szinkronizálás arra a képességre utal, hogy szabályozni lehet több szál hozzáférését bármely megosztott erőforráshoz. Ideális lehetőség, ha csak egy szálnak szeretnénk engedélyezni a megosztott erőforrás elérését.
Ezt a végrehajtási megközelítést általában "aszinkron" programozásnak nevezik. Ezeken a processzorokon szálak is találhatók, amelyek könnyű folyamatok, amelyek egyidejűleg képesek végrehajtani az utasításokat.
Típusok Synchronizálás
Kétféle szinkronizálási módszer létezik Java:
1) Folyamat szinkronizálás
2) Szálszinkronizálás.
Tanulmányozzuk a szálat és Folyamat szinkronizálás részletesen.
Folyamat szinkronizálás: Kezeli a programok közötti szinkronizálást. Például olyan programok, mint a `Microsoft Word` és `Acrobat reader` önálló folyamatként fut.
Szál szinkronizálás: A kritikus erőforrás két vagy több szál egyidejű végrehajtását szálnak nevezzük Synchronizálás. Tovább csoportosítható az egymást kölcsönösen kizáró" és a szálak közötti kommunikációhoz.
Mi az a Lock in Java?
Bezárni Java a monitornak vagy zárnak nevezett belső entitás köré épül. Minden objektumhoz tartozik egy zár. Tehát annak a szálnak, amelynek konzisztens 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, és feloldja a zárolást a munka végeztével. Ez biztosítja, hogy egyszerre csak egy szál férhessen hozzá a megosztott adatokhoz.
Többszálú program szinkronizálással
Többszálú program egy metódus vagy blokk, amely védve van a többi, ugyanazt az erőforrást megosztó száltól származó interferencia ellen, amelyet a `synchronized` kulcsszóval jelez.
A szinkronizált módszer használatával
Minden szinkronizált módszert szinkronizált módszernek nevezünk. Azt is használják, hogy zároljon egy objektumot bármely megosztott erőforráshoz. Tehát amikor egy szál szinkronizált metódust hív meg. Automatikusan birtokba veszi az objektum zárját, és feloldja, amikor befejezte feladatát.
Jegyzet: A szinkronizált kulcsszó nem használható osztályokkal és változókkal. A kulcsszóval csak metódusok és blokkok használhatók.
Miért használja a Synchronizált módszer?
- Egy objektum zárolására szolgál bármely megosztott erőforráshoz.
- Az objektum mindig megkapja a zárolást, amikor a szinkronizált metódust hívják.
- A zár nem oldódik ki, amíg a szál be nem fejezi funkcióját
Syntax:
Acess_modifiers synchronized return_type method_name (Method_Parameters) { }
class MathService { synchronized void getSumOfArray(int[] numbers) { int sum = 0; for (int number : numbers) { System.out.println(Thread.currentThread() .getName() + " adds " + sum + " to " + number + " to get -> " + (sum += number)); try { Thread.sleep(500); } catch (InterruptedException e) { throw new RuntimeException(e); } } } } public class Synchronization { public static void main(String[] args) { MathService mathService = new MathService(); Thread threadOne = new Thread(() -> mathService.getSumOfArray(new int[]{10, 11, 12})); Thread threadTwo = new Thread(() -> mathService.getSumOfArray(new int[]{20, 21, 22})); threadOne.start(); threadTwo.start(); } }
A kód magyarázata:
Futtassa ezt a példát, és figyelje meg, hogy a "0" szál először a "mathService" objektum zárolását kapja meg, és kizárólag ezt a zárolást használja, amíg a végrehajtás be nem fejeződik. A "0" és az "1" szál nincs átlapolva ebben a kódban. A kimenet az alábbi ábrán látható.
output:
Thread-0 adds 0 to 10 to get -> 10 Thread-0 adds 10 to 11 to get -> 21 Thread-0 adds 21 to 12 to get -> 33 Thread-1 adds 0 to 20 to get -> 20 Thread-1 adds 20 to 21 to get -> 41 Thread-1 adds 41 to 22 to get -> 63
Szinkronizált blokk használata
Tegyük fel, hogy nem szeretné szinkronizálni a teljes metódust. Ehelyett szinkronizálni szeretne néhány kódsort. Abban az időben a Synchronizált blokk segített a kiválasztott szinkronizálásában Java kód. SyncA hronizált metóduszárak a metóduson érhetők el, míg a szinkronizált blokkzárak az objektumon.
class MathService { void getSumOfArray(int[] numbers) { synchronized (this){ int sum = 0; for (int number : numbers) { System.out.println(Thread.currentThread() .getName() + " adds " + sum + " to " + number + " to get -> " + (sum += number)); try { Thread.sleep(500); } catch (InterruptedException e) { throw new RuntimeException(e); } } } } } public class Synchronization { public static void main(String[] args) { MathService mathService = new MathService(); Thread threadOne = new Thread(() -> mathService.getSumOfArray(new int[]{10, 11, 12})); Thread threadTwo = new Thread(() -> mathService.getSumOfArray(new int[]{20, 21, 22})); threadOne.start(); threadTwo.start(); } }
Kód magyarázata:
A kód futtatásakor észre fogja venni, hogy minden interferencia nélkül működik. A szinkronizált metódusban a zárolást a metódus alkalmazza, de a szinkronizált blokkban a zárolást az objektum alkalmazza. Győződjön meg arról, hogy a kimenet az alábbi ábrán látható.
output:
Thread-0 adds 0 to 10 to get -> 10 Thread-0 adds 10 to 11 to get -> 21 Thread-0 adds 21 to 12 to get -> 33 Thread-1 adds 0 to 20 to get -> 20 Thread-1 adds 20 to 21 to get -> 41 Thread-1 adds 41 to 22 to get -> 63
A kód magyarázata:
Amikor futtatja ezt a kódot, észre fogja venni, hogy interferencia nélkül működik, amire számítottunk. A szinkronizált metódusban a zárolást a metódus alkalmazza, a szinkronizált blokk módszernél viszont az objektum alkalmazza a zárolást.
Statikus szinkronizálás használata
In Java szinkronizálás, ha egynél több objektum van, két szál szerezheti meg a zárakat, és beléphet egy szinkronizált blokkba vagy blokkba, minden objektumhoz külön zárral. Ennek elkerülésére statikus szinkronizálás használható. Synca horonizált kulcsszavakat a statikus módszerek előtt használjuk.
Jegyzet: A statikus szinkronizálás során a hozzáférés zárolása az osztályra vonatkozik, nem az objektumra és a metódusra.
Kód, amely bemutatja a több objektum zárolásának problémáját
class MathService { synchronized void getSumOfArray(int[] numbers) { int sum = 0; for (int number : numbers) { System.out.println(Thread.currentThread() .getName() + " adds " + sum + " to " + number + " to get -> " + (sum += number)); try { Thread.sleep(500); } catch (InterruptedException e) { throw new RuntimeException(e); } } } } public class Synchronization { public static void main(String[] args) { MathService mathService = new MathService(); MathService mathService1 = new MathService(); Thread threadOne = new Thread(() -> mathService.getSumOfArray(new int[]{10, 11, 12})); Thread threadTwo = new Thread(() -> mathService.getSumOfArray(new int[]{20, 21, 22})); Thread threadThree = new Thread(() -> mathService1.getSumOfArray(new int[]{10, 11, 12})); Thread threadFour = new Thread(() -> mathService1.getSumOfArray(new int[]{20, 21, 22})); threadOne.start(); threadTwo.start(); threadThree.start(); threadFour.start(); } }
A kód magyarázata:
Amikor létrehozzuk a "MathService" egy másik példányát, interferenciát vezetünk be a szálakban, mivel azok a két objektummal lesznek átlapolva. Vegye figyelembe, hogy a "0" és a "2" szál a két objektummal, míg az "1" és "3" szál a két objektummal van átlapolva.
output:
Thread-0 adds 0 to 10 to get -> 10 Thread-2 adds 0 to 10 to get -> 10 Thread-0 adds 10 to 11 to get -> 21 Thread-2 adds 10 to 11 to get -> 21 Thread-0 adds 21 to 12 to get -> 33 Thread-2 adds 21 to 12 to get -> 33 Thread-1 adds 0 to 20 to get -> 20 Thread-3 adds 0 to 20 to get -> 20 Thread-1 adds 20 to 21 to get -> 41 Thread-3 adds 20 to 21 to get -> 41 Thread-1 adds 41 to 22 to get -> 63 Thread-3 adds 41 to 22 to get -> 63
Ugyanaz a kód szinkronizált statikus módszerrel
class MathService { synchronized static void getSumOfArray(int[] numbers) { int sum = 0; for (int number : numbers) { System.out.println(Thread.currentThread() .getName() + " adds " + sum + " to " + number + " to get -> " + (sum += number)); try { Thread.sleep(500); } catch (InterruptedException e) { throw new RuntimeException(e); } } } } public class Synchronization { public static void main(String[] args) { MathService mathService = new MathService(); MathService mathService1 = new MathService(); Thread threadOne = new Thread(() -> mathService.getSumOfArray(new int[]{10, 11, 12})); Thread threadTwo = new Thread(() -> mathService.getSumOfArray(new int[]{20, 21, 22})); Thread threadThree = new Thread(() -> mathService1.getSumOfArray(new int[]{10, 11, 12})); Thread threadFour = new Thread(() -> mathService1.getSumOfArray(new int[]{20, 21, 22})); threadOne.start(); threadTwo.start(); threadThree.start(); threadFour.start(); } }
Futtassa a fenti kódot, és vegye figyelembe, hogy a szálak interferenciáját megszüntettük. A kód kimenete lent látható.
output:
Thread-0 adds 0 to 10 to get -> 10 Thread-0 adds 10 to 11 to get -> 21 Thread-0 adds 21 to 12 to get -> 33 Thread-3 adds 0 to 20 to get -> 20 Thread-3 adds 20 to 21 to get -> 41 Thread-3 adds 41 to 22 to get -> 63 Thread-2 adds 0 to 10 to get -> 10 Thread-2 adds 10 to 11 to get -> 21 Thread-2 adds 21 to 12 to get -> 33 Thread-1 adds 0 to 20 to get -> 20 Thread-1 adds 20 to 21 to get -> 41 Thread-1 adds 41 to 22 to get -> 63
A szinkronizálás használatának előnyei
Íme a párhuzamos alkalmazásokkal végzett munka előnyei:
- A szinkronizálás fő célja Java célja az inkonzisztens adatok megakadályozása a szálak interferenciájának megakadályozásával.
- A szinkronizált kulcsszó be Java zárolást biztosít, amely kölcsönösen kizárja a hozzáférést a megosztott erőforráshoz, és megakadályozza az adatversenyt.
- Ezenkívül megakadályozza a kódutasítások átrendezését a fordítóprogram, ami finom egyidejű problémát okozhat, ha nem használunk illékony vagy szinkronizált kulcsszavakat.
- SyncA hronizált kulcsszó beolvassa az adatokat a fő memóriából, mint a gyorsítótárból, és amikor feloldja a zárolást.
- Ezenkívül kiüríti az írási műveleteket a fő memóriából, kiküszöbölve a memória inkonzisztencia hibáit.
Hátrányai Synchronizációs mechanizmus
SyncA hronizációs mechanizmusok teljesítménye gyenge.
Például
- Tegyük fel, hogy öt folyamat van, A1, A2, A3, A4 és A5.
- Arra várnak, hogy a megosztott erőforrások hozzáférjenek egy-egy szálhoz.
- Minden folyamat várakozik, így a sorban utolsónak meg kell várnia, amíg az összes többi folyamat befejeződik.
Összegzésként
- SyncA hronizálás több szál hozzáférésének szabályozására utal bármely megosztott erőforráshoz.
- Java kétféle szinkronizálási módszerrel rendelkezik: 1) Folyamat szinkronizálás és 2) Szálszinkronizálás.
- Bezárni Java a monitornak vagy zárnak nevezett belső entitás köré épül.
- A többszálú program egy metódus vagy blokk, amely védett más, ugyanazon az erőforráson osztozó szálak által okozott interferencia ellen, amelyet a `synchronized` kulcsszó jelzi.
- Minden szinkronizált metódus szinkronizált módszerként ismert.
- In Java, a szinkronizált metóduszárak a metóduson, míg a szinkronizált blokkzárak az objektumon érhetők el.
- A statikus szinkronizálás során a hozzáférés zárolása az osztályra vonatkozik, nem az objektumra és a metódusra.
- A szinkronizálás fő célja Java célja az inkonzisztens adatok megakadályozása a szálak interferenciájának megakadályozásával.
- Ennek a módszernek a legnagyobb hátránya, hogy minden folyamat várakozik, így a sorban utolsónak meg kell várnia, amíg az összes többi folyamat befejeződik.