Szinkronizálás Java-ban: mit, hogyan és miért?

Ez a cikk a Java szinkronizálásáról segít eligazodni a többszálú programok szinkronizálásában.

A több szálon futó programok rendszeresen előállhatnak olyan körülményekkel, amikor többszörös megpróbál ugyanahhoz az erőforráshoz jutni, amely csalárd és megdöbbentő eredményeket hoz. Ez megoldható a Java szinkronizálásának használatával. Csak egy adott szál juthat el az erőforráshoz egy adott időpontban. Ez a cikk segít megismerkedni a szinkronizálási stratégiával.



A témákat ebben a sorrendben fogom megvitatni:



Lássunk neki!

Miért érdemes használni a szinkronizálást a Java-ban?



Ha egy programon belül legalább két szálból indul, akkor esélye lehet arra, hogy több szál ugyanarra az erőforrásra próbáljon eljutni. Akár váratlan eredményt hozhat létre a párhuzamossági problémák miatt.

Szintaxis :

szinkronizált (objektumazonosító) {// Megosztott változók és más megosztott források elérése}

Például, megkísérel egy egyenértékű fájlba írni. Ez megrongálhatja az adatokat, mivel az egyik szál felülírhatja az adatokat, vagy amikor egy szál megnyitja a szálatugyanabban a fájlban, lehet, hogy egy másik szál bezárja ugyanazt a fájlt.Szükség van több szál szinkronizálására. Ez egy úgynevezett koncepció segítségével valósítható meg M figyelők .



  • Minden egyes monitorhoz van társítva, amelyet egy szál rögzíthet vagy feloldhat.
  • Egyszerre csak egy szál tarthatja meg a zárat a monitoron.
  • Jáva A programozási nyelv nagyon praktikus módot kínál a szálak létrehozására és feladatuk szinkronizálására a Szinkronizált blokkok.
  • A megosztott erőforrásokat ebben a blokkban is tartja.

A Java szinkronizált blokkjait a Szinkronizált kulcsszó. Ez a Java blokk szinkronizálva van valamilyen objektumon. Az ugyanazon objektumon szinkronizált blokkok egyszerre csak egy szálat hajthatnak végre. Az összes többi szál, amely megpróbál belépni a szinkronizált blokkba, addig blokkolódik, amíg a szinkronizált blokk belsejében lévő szál kilép a blokkból.

A szinkronizálás típusai

Alapvetően kétféle szinkronizálás érhető el. Ők:

  1. Folyamat szinkronizálása: Több szál vagy folyamat egyidejű végrehajtása olyan állapot elérése érdekében, amely elkötelezi magát egy bizonyos műveletsorozat mellett.
  2. Szál szinkronizálása: Olykor, amikor egynél több szálmegpróbál hozzáférni egy megosztott erőforráshoz, meg kell győződnie arról, hogy az erőforrást csak egy szál fogja használni a domainenEgy idő.

Ne menjünk bele ezeknek a típusoknak a részleteibe, és próbáljuk megérteni, hogy mik vannak a zárak .

Zárak a Java-ban

Mint korábban említettem, a szinkronizálás egy belső entitás köré épül zár vagy monitor . Minden objektumhoz tartozik egy zár. Tehát egy szálnak, amelynek állandó hozzáférésre van szüksége egy objektum mezőihez, meg kell szereznie az objektum zárját, mielőtt hozzáférne hozzájuk, majd fel kell oldania a zárat, amikor a munka elkészült.

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

A zár így néz ki:

public class Lock {privát logikai isLocked = hamis nyilvános szinkronizált void lock () dobja az InterruptedException {while (isLocked) {wait ()} isLocked = true} nyilvános szinkronizált void unlock () {isLocked = hamis értesítés ()}}

A lock () metódus úgy zárolja a Lock példányt, hogy az összes lock () hívó szál blokkolva legyen, amíg a unlock () végrehajtásra nem kerül.

Több szál szinkronizálás nélkül

Itt van egy egyszerű példa, amely egy sorozatban kinyomtatja a számláló értékét, és ahányszor futtatjuk, a CPU elérhetősége alapján egy szálhoz más eredményt ad. Ezt nézd meg!

osztály Többszálas {public void printCount () {try {for (int i = 5 i<0 i--) { System.out.println('Counter --- ' + i ) } } catch (Exception e) { System.out.println('Thread interrupted.') } } } class Thread extends Multithread { private Thread t private String threadName Multithread MT Thread( String name, Multithread mt) { threadName = name MT= mt } public void run() { MT.printCount() System.out.println('Thread ' + threadName + ' exiting.') } public void start () { System.out.println('Starting ' + threadName ) if (t == null) { t = new Thread (this, threadName) t.start () } } } public class TestThread { public static void main(String args[]) { Multithread MT = new Multithread() Thread t = new Thread( 'Thread - 1 ', MT) Thread t1 = new Thread( 'Thread - 2 ', MT) t.start() t1.start() // wait for threads to end try { t.join() t1.join() } catch ( Exception e) { System.out.println('Interrupted') } } }

A fenti program eredményei ebben:

Kimenet- Szinkronizálás Java- Edureka-ban

Többszálas szinkronizálás

Ez ugyanaz a példa, mint fent, de kiírja a számláló értékét a sorozatban. Valahányszor futtatjuk, ugyanazt az eredményt hozza.

class Többszálas {public void printCount () {try {for (int i = 5 i> 0 i--) {System.out.println ('Counter ---' + i)}} catch (e kivétel) {System. out.println ('A szál megszakadt.')}}} osztály A szál kiterjeszti a többszálat {private Thread t private String threadName Multithread MT Thread (String name, Multithread mt) {threadName = name MT = mt} public void run () {synchronized ( MT) {MT.printCount ()} System.out.println ('Thread' + threadName + 'exit'.)}} Public void start () {System.out.println ('Starting' + threadName) if (t == null) {t = new Thread (this, threadName) t.start ()}}} public class TestThread {public static void main (String args []) {Multithread MT = new Multithread () Thread T = new Thread ('Thread) - 1 ', MT) T1 szál = új szál (' Thread - 2 ', MT) T.start () T1.start () // várja meg, amíg a szálak véget érnek, próbálkozzon {T.join () T1.join ()} fogás (e kivétel) {System.out.println ('megszakítva')}}}

A kimenetet az alábbiakban mutatjuk be:

Szinkronizált kulcsszó

szinkronizált kulcsszó egy blokkot vagy egy metódust kritikus részként jelöl meg. Kritikus szakasz az, ahol egyszerre csak egy szál fut, és a szál tartja a szinkronizált szakasz zárját. Ez szinkronizált kulcsszó segít az írásban egyidejű bármely alkalmazás részei. Megvédi a blokkon belüli megosztott erőforrásokat is.

A szinkronizált kulcsszó a következőkkel használható:

Beszéljük meg a kódblokkot.

Szinkronizált kulcsszó: Kódblokk

Szintaxis

A szinkronizált blokk írásának általános szintaxisa:

szinkronizált (lockObject) {// szinkronizált utasítások}

Ha egy szál a blokk belsejében szeretné végrehajtani a szinkronizált utasításokat, meg kell szereznie a lockObject monitorának zárját. Egyszerre csak egy szál képes megszerezni a zár objektum monitorát. Tehát az összes többi szálnak meg kell várnia, amíg az éppen futó szál megszerzi a zárat, és befejezi a végrehajtását.
Így a szinkronizált kulcsszó garantálja, hogy egyszerre csak egy szál hajtja végre a szinkronizált blokk utasításokat, és így megakadályozza, hogy több szál megrontsa a blokkon belül lévő megosztott adatokat.

hogyan lehet megfordítani egy karakterlánc-pitont

jegyzet :

  • Ha egy szálat alszanak (a alvás() módszer), akkor nem oldja fel a zárat. Ezen alvási idő alatt egyetlen szál sem hajtja végre a szinkronizált blokk utasításokat.
  • A Java szinkronizálás dobni fog NullPointerException ha a zárban használt objektum szinkronizált (zár) ' nulla.

Most beszéljük meg a módszert.

Szinkronizált kulcsszó: Egy metódus

Szintaxis

Az írás általános szintaxisa a szinkronizált módszer az:

szinkronizált módszer (paraméterek) {// szinkronizált kód}

Itt lockObject csak hivatkozás egy objektumra, amelynek zárja a monitorhoz van társítva, amely a szinkronizált utasításokat képviseli.

A szinkronizált blokkhoz hasonlóan egy szálnak a szinkronizált módszerrel meg kell szereznie a csatlakoztatott monitor objektum zárolását. Szinkronizált módszer esetén a zár objektum:

  • ‘.Osztály’ objektum - ha az adott módszer statikus .
  • ’Ez’ tárgy - ha a módszer nem statikus . „Ez” az aktuális objektumra való hivatkozás, amelyben a szinkronizált módszert meghívják.

Java szinkronizált kulcsszó visszatérő a természetben. Ez azt jelenti, hogy ha egy szinkronizált módszer meghív egy másik szinkronizált módszert, amely ugyanazt a zárat igényli, akkor a zárat tartó jelenlegi szál beléphet abba a módszerbe anélkül, hogy megszerezné a zárat.

Térjünk át a cikk utolsó témájára, és mutassuk meg a szinkronizált kulcsszó és a szinkronizálási blokk közötti főbb különbségeket.

Különbség a szinkronizált kulcsszó és a szinkronizált blokk között

  • Ha szinkronizált kulcsszót használ a módszer , zárolást szerez az objektumban a teljes módszer számára. Ez azt jelenti, hogy egyetlen más szál sem használhat szinkronizált módszert, amíg az aktuális meghívott szál befejezi a végrehajtását.
  • Szinkronizált Blokk csak a zárójelek között szerez zárat az objektumban a szinkronizált kulcsszó megadása után. Ez azt jelenti, hogy egyetlen más szál sem szerezhet zárat a már lezárt objektumon, amíg a blokk nem lép ki. De más szálak képesek lesznek elérni a kód többi részét, amely a metódusban található.

Ezzel a cikk végére jutunk, ahol megvitattuk, hogyan működik pontosan a Java szinkronizálása. Remélem, hogy tisztában van azzal, amit megosztott veled ebben az oktatóanyagban.

Nézze meg a az Edureka, egy megbízható online tanulási vállalat, amelynek több mint 250 000 elégedett tanulóval rendelkező hálózata elterjedt az egész világon. Azért vagyunk itt, hogy segítséget nyújthassunk utazásának minden lépésében, hogy e java interjúk kérdései mellett a tanévre váltsunk, előállítunk egy tananyagot, amelyet azoknak a hallgatóknak és szakembereknek tervezünk, akik Java fejlesztők szeretnének lenni.

Van egy kérdésünk? Kérjük, említse meg a „Szinkronizálás Java-ban” megjegyzés szakaszában ' cikket, és a lehető leghamarabb kapcsolatba lépünk Önnel.