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:
- Miért érdemes használni a szinkronizálást a Java-ban?
- A szinkronizálás típusai
- Zárak a Java-ban
- Több szál szinkronizálás nélkül
- Többszálas szinkronizálás
- Szinkronizált kulcsszó
- Különbség a szinkronizált kulcsszó és a szinkronizált blokk között
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:
- 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.
- 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:
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.