Menu

Synchronizace Java: Co je synchronizace vláken v Javě

  • Hlavní
  • Jiný
  • Synchronizace Java: Co je synchronizace vláken v Javě

java synchronized what is thread synchronization java

Vyzkoušejte Náš Nástroj Pro Odstranění Problémů

Tento výukový program vysvětluje synchronizaci vláken v Javě spolu se souvisejícími pojmy jako Java Lock, Race Condition, Mutex, Java Volatile & Deadlock v Javě:

V prostředí s více vlákny, kde je zapojeno více vláken, musí dojít ke střetům, když se více než jedno vlákno pokusí získat stejný prostředek současně. Výsledkem těchto střetů je „rasový stav“, a proto program vytváří neočekávané výsledky.

Například, jeden soubor je aktualizován dvěma vlákny. Pokud je jedno vlákno T1 v procesu aktualizace tohoto souboru, řekněte nějakou proměnnou. Zatímco tato aktualizace od T1 stále probíhá, řekněme, že druhá nit T2 také aktualizuje stejnou proměnnou. Tímto způsobem bude proměnná poskytovat špatné výsledky.

=> Dávejte si pozor na kompletní sérii školení Java zde.

Synchronizace vláken v Javě

Pokud je zapojeno více vláken, měli bychom tato vlákna spravovat takovým způsobem, aby ke zdroji bylo možné přistupovat pouze jedním vláknem. Ve výše uvedeném příkladu by měl být soubor, ke kterému přistupují obě vlákna, spravován tak, aby T2 nemohl přistupovat k souboru, dokud k němu T1 neprovede přístup.

To se provádí v Javě pomocí „ Synchronizace vláken “.

Co se naučíte:

Synchronizace vláken v Javě

Protože Java je vícevláknový jazyk, synchronizace vláken má v Javě velký význam, protože se v aplikaci paralelně spouští více vláken.

Používáme klíčová slova „Synchronizované“ a 'nestálý' dosáhnout synchronizace v Javě

Když je sdílený objekt nebo prostředek proměnlivý, potřebujeme synchronizaci. Pokud je prostředek neměnný, pak vlákna přečtou prostředek pouze souběžně nebo jednotlivě.

V tomto případě nepotřebujeme zdroj synchronizovat. V tomto případě to JVM zajišťuje Synchronizovaný kód Java se spouští po jednom vlákně najednou .

Souběžný přístup ke sdíleným prostředkům v Javě může po většinu času způsobit chyby jako „Nekonzistence paměti“ a „interference vláken“. Abychom se těmto chybám vyhnuli, musíme jít na synchronizaci sdílených prostředků, aby se přístup k těmto zdrojům vzájemně vylučoval.

Používáme koncept s názvem Monitoruje implementaci synchronizace. K monitoru lze přistupovat pouze z jednoho vlákna najednou. Když vlákno dostane zámek, můžeme říci, že vlákno vstoupilo na monitor.

Když je k monitoru přistupováno konkrétním vláknem, monitor je uzamčen a všechna ostatní vlákna, která se pokoušejí vstoupit na monitor, jsou pozastavena, dokud přístupové vlákno nedokončí a neuvolní zámek.

V budoucnu se budeme podrobně zabývat synchronizací v Javě v tomto kurzu. Nyní pojďme diskutovat o některých základních pojmech souvisejících se synchronizací v Javě.

Stav závodu v Javě

V prostředí s více vlákny, když se více než jedno vlákno pokusí získat přístup ke sdílenému prostředku pro současné psaní, pak se více vláken navzájem proběhne, aby dokončilo přístup k prostředku. To vede k „rasovým podmínkám“.

Je třeba vzít v úvahu, že pokud se více vláken pokouší získat přístup ke sdílenému prostředku pouze pro čtení, není problém. Problém nastává, když více vláken přistupuje ke stejnému prostředku současně.

Podmínky závodu se vyskytují kvůli nedostatečné synchronizaci vláken v programu. Když správně synchronizujeme vlákna tak, že ke zdroji bude mít přístup pouze jeden podproces a podmínka závodu přestane existovat.

Jak tedy zjistíme stav závodu?

Nejlepší způsob, jak zjistit stav závodu, je kontrola kódu. Jako programátor bychom měli důkladně zkontrolovat kód, abychom zkontrolovali potenciální podmínky závodu, ke kterým může dojít.

Zámky / monitory v Javě

Již jsme zmínili, že k implementaci synchronizace používáme monitory nebo zámky. Monitor nebo zámek je interní entita a je přidružen ke každému objektu. Takže kdykoli vlákno potřebuje přístup k objektu, musí nejprve získat zámek nebo monitorovat svůj objekt, pracovat na objektu a poté zámek uvolnit.

Zámky v Javě budou vypadat takto:

public class Lock { private boolean isLocked = false; public synchronized void lock() throws InterruptedException { while(isLocked) { wait(); } isLocked = true; } public synchronized void unlock(){ isLocked = false; notify(); } }

Jak je uvedeno výše, máme metodu lock (), která instanci uzamkne. Všechna vlákna volající metodu lock () budou blokována, dokud nebudou sady metod unblock () uzamčeny na hodnotu false a upozorní všechna čekající vlákna.

Některé ukazatele, které si musíte pamatovat na zámky:

  1. V Javě má ​​každý objekt zámek nebo monitor. K tomuto zámku lze přistupovat pomocí vlákna.
  2. Tento monitor nebo zámek může současně získat pouze jedno vlákno.
  3. Programovací jazyk Java poskytuje klíčové slovo Synchronized, které nám umožňuje synchronizovat vlákna vytvořením bloku nebo metody jako Synchronized.
  4. Sdílené prostředky, ke kterým vlákna potřebují přístup, jsou uchovávány v rámci tohoto synchronizovaného bloku / metody.

Mutexy v Javě

Již jsme diskutovali o tom, že v prostředí s více vlákny může dojít k rasovým podmínkám, když se více než jedno vlákno pokusí o přístup ke sdíleným prostředkům současně a výsledkem sporů bude neočekávaný výstup.

Část programu, která se pokouší získat přístup ke sdílenému prostředku, se nazývá „Kritická sekce“ . Aby nedocházelo k výskytu závodních podmínek, je nutné synchronizovat přístup do kritické sekce. Synchronizací této kritické sekce zajistíme, že do kritické sekce bude mít přístup vždy pouze jedno vlákno.

Nejjednodušší typ synchronizátoru je „mutex“. Mutex zajišťuje, že v kterékoli dané instanci může kritickou sekci spustit pouze jedno vlákno.

Mutex je podobný konceptu monitorů nebo zámků, který jsme diskutovali výše. Pokud vlákno potřebuje přístup do kritické sekce, musí získat mutex. Po získání mutexu bude vlákno přistupovat ke kódu kritické sekce a po dokončení uvolní mutex.

Ostatní vlákna, která čekají na přístup do kritické sekce, budou mezitím blokována. Jakmile to vlákno, které drží mutex, uvolní, vstoupí do kritické sekce další vlákno.

zátěžové testování vs testování výkonu vs zátěžové testování

Existuje několik způsobů, jak můžeme implementovat mutex v Javě.

  1. Používání synchronizovaného klíčového slova
  2. Pomocí semaforu
  3. Pomocí ReentrantLock

V tomto tutoriálu probereme první přístup, tj. Synchronizaci. Další dva přístupy - Semaphore a ReentrantLock budou probrány v dalším kurzu, kde probereme souběžný balíček Java.

Synchronizované klíčové slovo

Java poskytuje klíčové slovo „Synchronizované“, které lze v programu použít k označení kritické sekce. Kritickou částí může být blok kódu nebo úplná metoda. K kritickému oddílu označenému klíčovým slovem Synchronized tedy může přistupovat pouze jedno vlákno.

Můžeme napsat souběžné části (části, které se provádějí souběžně) pro aplikaci pomocí klíčového slova Synchronized. Rovněž se zbavíme podmínek závodu vytvořením bloku kódu nebo metody Synchronized.

Když označíme blok nebo metodu synchronizovanou, chráníme sdílené prostředky uvnitř těchto entit před současným přístupem a tím poškozením.

Druhy synchronizace

Níže jsou vysvětleny 2 typy synchronizace:

# 1) Synchronizace procesu

Synchronizace procesů zahrnuje více procesů nebo podprocesů prováděných současně. Nakonec dosáhnou stavu, kdy se tyto procesy nebo vlákna zaváží ke konkrétní posloupnosti akcí.

# 2) Synchronizace vláken

V synchronizaci vláken se více než jedno vlákno pokouší získat přístup ke sdílenému prostoru. Vlákna jsou synchronizována takovým způsobem, že ke sdílenému prostoru je přistupováno pouze po jednom vlákně.

Synchronizace procesů je mimo rozsah tohoto kurzu. Proto zde budeme diskutovat pouze o synchronizaci vláken.

V Javě můžeme použít synchronizované klíčové slovo s:

  • Blok kódu
  • Metoda

Výše uvedené typy jsou vzájemně se vylučující typy synchronizace vláken. Vzájemné vyloučení udržuje vlákna, která přistupují ke sdíleným datům, aby se navzájem nerušily.

Druhým typem synchronizace vláken je „komunikace mezi vlákny“, která je založena na spolupráci mezi vlákny. Komunikace mezi vlákny je mimo rozsah tohoto kurzu.

Než se pustíme do synchronizace bloků a metod, implementujme program Java, který předvede chování vláken, když neexistuje žádná synchronizace.

Vícevláknové zpracování bez synchronizace

Následující program Java má více podprocesů, které nejsou synchronizovány.

class PrintCount { //method to print the thread counter public void printcounter() { try { for(int i = 5; i > 0; i--) { System.out.println('Counter ==> ' + i ); } } catch (Exception e) { System.out.println('Thread interrupted.'); } } } //thread class class ThreadCounter extends Thread { private Thread t; private String threadName; PrintCount PD; //class constructor for initialization ThreadCounter( String name, PrintCount pd) { threadName = name; PD = pd; } //run method for thread public void run() { PD.printcounter(); System.out.println('Thread ' + threadName + ' exiting.'); } //start method for thread public void start () { System.out.println('Starting ' + threadName ); if (t == null) { t = new Thread (this, threadName); t.start (); } } } public class Main { public static void main(String args()) { PrintCount PD = new PrintCount(); //create two instances of thread class ThreadCounter T1 = new ThreadCounter( 'ThreadCounter_1 ', PD ); ThreadCounter T2 = new ThreadCounter( 'ThreadCounter_2 ', PD ); //start both the threads T1.start(); T2.start(); // wait for threads to end try { T1.join(); T2.join(); } catch ( Exception e) { System.out.println('Interrupted'); } } }

Výstup

Vícevláknové zpracování bez synchronizace

Z výstupu vidíme, že jelikož vlákna nejsou synchronizována, je výstup nekonzistentní. Obě vlákna začínají a poté postupně zobrazují počítadlo. Obě vlákna končí na konci.

Z daného programu mělo první vlákno po zobrazení hodnot čítače vystoupit a poté by mělo druhé vlákno začít zobrazovat hodnoty čítače.

Nyní pojďme k synchronizaci a začneme synchronizací bloku kódu.

Synchronizovaný blok kódu

Synchronizovaný blok se používá k synchronizaci bloku kódu. Tento blok se obvykle skládá z několika řádků. Synchronizovaný blok se používá, když nechceme, aby byla synchronizována celá metoda.

Například, máme metodu s řekněme 75 řádky kódu. Z toho pouze 10 řádků kódu musí být provedeno jedním vláknem najednou. V tomto případě, pokud provedeme celou metodu synchronizovanou, bude to pro systém zátěž. V takových situacích jdeme na synchronizované bloky.

nástroje pro testování výkonu pro webové aplikace

Rozsah synchronizované metody je vždy menší než rozsah synchronizované metody. Synchronizovaná metoda uzamkne objekt sdíleného prostředku, který má být používán více vlákny.

Obecná syntaxe synchronizovaného bloku je uvedena níže:

synchronized (lock_object){ //synchronized code statements }

Zde „lock_object“ je výraz odkazu na objekt, u kterého má být zámek získán. Takže kdykoli chce vlákno získat přístup k synchronizovaným příkazům uvnitř bloku k provedení, musí získat zámek na monitoru ‚lock_object '.

Jak již bylo řečeno, synchronizované klíčové slovo zajišťuje, že pouze jeden podproces může získat zámek najednou a všechna ostatní podprocesy musí čekat, dokud podproces, který drží zámek, nedokončí a uvolní zámek.

Poznámka

  • „NullPointerException“ je vyvolána, pokud je použitý lock_object Null.
  • Pokud vlákno spí, zatímco stále drží zámek, zámek se neuvolní. Ostatní vlákna nebudou mít během této doby spánku přístup ke sdílenému objektu.

Nyní představíme výše uvedený příklad, který byl již implementován s mírnými změnami. V dřívějším programu jsme nesynchronizovali kód. Nyní použijeme synchronizovaný blok a porovnáme výstup.

Multi-threading se synchronizací

V níže uvedeném programu Java používáme synchronizovaný blok. V metodě spuštění synchronizujeme kód řádků, které tisknou čítač pro každé vlákno.

class PrintCount { //print thread counter public void printCounter() { try { for(int i = 5; i > 0; i--) { System.out.println('Counter ==> ' + i ); } } catch (Exception e) { System.out.println('Thread interrupted.'); } } } //thread class class ThreadCounter extends Thread { private Thread t; private String threadName; PrintCount PD; //class constructor for initialization ThreadCounter( String name, PrintCount pd) { threadName = name; PD = pd; } //run () method for thread with synchronized block public void run() { synchronized(PD) { PD.printCounter(); } System.out.println('Thread ' + threadName + ' exiting.'); } //start () method for thread public void start () { System.out.println('Starting ' + threadName ); if (t == null) { t = new Thread (this, threadName); t.start (); } } } public class Main { public static void main(String args()) { PrintCount PD = new PrintCount(); //create thread instances ThreadCounter T1 = new ThreadCounter( 'Thread_1 ', PD ); ThreadCounter T2 = new ThreadCounter( 'Thread_2 ', PD ); //start both the threads T1.start(); T2.start(); // wait for threads to end try { T1.join(); T2.join(); } catch ( Exception e) { System.out.println('Interrupted'); } } }

Výstup

Vícevláknové zpracování se synchronizací

Nyní je výstup tohoto programu pomocí synchronizovaného bloku docela konzistentní. Podle očekávání se obě vlákna začnou spouštět. První podproces dokončil zobrazování hodnot čítače a ukončí se. Potom druhé vlákno zobrazí hodnoty čítače a ukončí se.

Synchronizovaná metoda

Pojďme si v této části promluvit o synchronizované metodě. Dříve jsme viděli, že můžeme deklarovat malý blok skládající se z méně řádků kódu jako synchronizovaný blok. Pokud chceme, aby byla synchronizována celá funkce, můžeme deklarovat metodu jako synchronizovanou.

Když je metoda provedena synchronizována, pak bude možné volání metody provádět pouze jedno vlákno najednou.

Obecná syntaxe pro zápis synchronizované metody je:

synchronized method_name (parameters){ //synchronized code }

Stejně jako synchronizovaný blok potřebujeme v případě synchronizované metody lock_object, který bude používán vlákny přistupujícími k synchronizované metodě.

U synchronizované metody může být objekt zámku jedním z následujících:

  • Pokud je synchronizovaná metoda statická, pak je objekt zámku dán objektem „.class“.
  • U nestatické metody je objekt zámku dán aktuálním objektem, tj. „Tímto“ objektem.

Zvláštním rysem synchronizovaného klíčového slova je to, že je znovu zadáno. To znamená, že synchronizovaná metoda může volat jinou synchronizovanou metodu se stejným zámkem. Takže vlákno, které drží zámek, může přistupovat k další synchronizované metodě, aniž by muselo získat jiný zámek.

Synchronizovaná metoda je demonstrována pomocí níže uvedeného příkladu.

class NumberClass { //synchronized method to print squares of numbers synchronized void printSquares(int n) throws InterruptedException { //iterate from 1 to given number and print the squares at each iteration for (int i = 1; i <= n; i++) { System.out.println(Thread.currentThread().getName() + ' :: '+ i*i); Thread.sleep(500); } } } public class Main { public static void main(String args()) { final NumberClass number = new NumberClass(); //create thread Runnable thread = new Runnable() { public void run() { try { number.printSquares(3); } catch (InterruptedException e) { e.printStackTrace(); } } }; //start thread instance new Thread(thread, 'Thread One').start(); new Thread(thread, 'Thread Two').start(); } }

Výstup

synchronizovaná metoda

Ve výše uvedeném programu jsme použili synchronizovanou metodu k tisku čtverců čísla. Horní limit čísla je metodě předán jako argument. Poté počínaje od 1 se čtverce každého čísla vytisknou, dokud není dosaženo horní hranice.

V hlavní funkci je vytvořena instance vlákna. Každá instance vlákna je předána číslo pro tisk čtverců.

Jak již bylo zmíněno výše, když je metoda, která má být synchronizována, statická, pak je do třídy zahrnut objekt zámku, a nikoli objekt. To znamená, že se zamkneme na třídu a ne na objekt. Tomu se říká statická synchronizace.

Další příklad je uveden níže.

class Table{ //synchronized static method to print squares of numbers synchronized static void printTable(int n){ for(int i=1;i<=10;i++){ System.out.print(n*i + ' '); try{ Thread.sleep(400); }catch(Exception e){} } System.out.println(); } } //thread class Thread_One class Thread_One extends Thread{ public void run(){ Table.printTable(2); } } //thread class Thread_Two class Thread_Two extends Thread{ public void run(){ Table.printTable(5); } } public class Main{ public static void main(String t()){ //create instances of Thread_One and Thread_Two Thread_One t1=new Thread_One (); Thread_Two t2=new Thread_Two (); //start each thread instance t1.start(); t2.start(); } }

Výstup

výstup synchronizace statické metody

Ve výše uvedeném programu tiskneme tabulky násobení čísel. Každé číslo, jehož tabulka má být vytištěna, je instancí vlákna jiné třídy vláken. Vytiskneme tedy multiplikační tabulky 2 a 5, takže k tisku tabulek 2 a 5 máme dvě třídy thread_one a thread_two.

Stručně řečeno, klíčové slovo synchronizované v jazyce Java provádí následující funkce:

  1. Synchronizované klíčové slovo v Javě zaručuje vzájemně se vylučující přístup ke sdíleným prostředkům poskytnutím uzamykacího mechanismu. Zamykání také brání podmínkám závodu.
  2. Pomocí synchronizovaného klíčového slova zabráníme souběžným programovacím chybám v kódu.
  3. Když je metoda nebo blok deklarována jako synchronizovaná, pak vlákno potřebuje exkluzivní zámek pro vstup do synchronizované metody nebo bloku. Po provedení nezbytných akcí vlákno uvolní zámek a vyprázdní operaci zápisu. Tímto způsobem eliminuje chyby paměti související s nekonzistencí.

Volatilní v Javě

Těkavé klíčové slovo v Javě se používá k tomu, aby třídy byly bezpečné pro vlákna. Pomocí klíčového slova volatile také upravujeme hodnotu proměnné různými vlákny. Klíčové slovo volatile lze použít k deklaraci proměnné s primitivními typy i objekty.

V určitých případech se volatilní klíčové slovo používá jako alternativa k synchronizovanému klíčovému slovu, ale uvědomte si, že nejde o náhradu za synchronizované klíčové slovo.

Když je proměnná deklarována jako volatilní, její hodnota se nikdy neukládá do mezipaměti, ale vždy se čte z hlavní paměti. Nestálá proměnná zaručuje uspořádání a viditelnost. Ačkoli proměnnou lze deklarovat jako volatilní, nemůžeme deklarovat třídy nebo metody jako volatilní.

Zvažte následující blok kódu:

class ABC{ static volatile int myvar =10; }

Ve výše uvedeném kódu je proměnná myvar statická a nestálá. Statická proměnná je sdílena mezi všechny objekty třídy. Těkavá proměnná se vždy nachází v hlavní paměti a nikdy se neukládá do mezipaměti.

Proto bude v hlavní paměti pouze jedna kopie myvaru a všechny akce čtení / zápisu budou na této proměnné prováděny z hlavní paměti. Pokud by myvar nebyl deklarován jako těkavý, pak by každý objekt vlákna měl jinou kopii, která by vedla k nekonzistenci.

Níže jsou uvedeny některé rozdíly mezi těkavými a synchronizovanými klíčovými slovy.

Těkavé klíčové slovoSynchronizované klíčové slovo
Klíčové slovo volatile se používá pouze s proměnnými.Synchronizované klíčové slovo se používá s bloky kódu a metodami.
Prchavé klíčové slovo nemůže blokovat vlákno na čekání.Synchronizované klíčové slovo může blokovat vlákno na čekání.
Výkon vlákna se díky Volatile zlepšuje.Výkon vlákna se při synchronizaci poněkud zhoršuje.
Těkavé proměnné se nacházejí v hlavní paměti.Synchronizované konstrukce nejsou umístěny v hlavní paměti.
Volatile synchronizuje jednu proměnnou mezi podprocesovou pamětí a hlavní pamětí najednou.Synchronizované klíčové slovo synchronizuje všechny proměnné najednou.

Zablokování v Javě

Viděli jsme, že můžeme synchronizovat více vláken pomocí synchronizovaného klíčového slova a zajistit programy bezpečné pro vlákna. Synchronizací podprocesů zajistíme, aby se více podprocesů provádělo současně v prostředí s více podprocesy.

Někdy však nastane situace, kdy vlákna již nebudou fungovat současně. Místo toho čekají donekonečna. K tomu dochází, když jedno vlákno čeká na prostředek a tento prostředek je blokován druhým vláknem.

Druhé vlákno naopak čeká na prostředek blokovaný prvním vláknem. Taková situace vede v Javě k „zablokování“.

Zablokování v Javě je znázorněno pomocí obrázku níže.

Zablokování v Javě

Jak vidíme z výše uvedeného diagramu, vlákno A uzamklo prostředek r1 a čeká na prostředek r2. Na druhé straně vlákno B zablokovalo prostředek r2 a čeká na r1.

Žádný z vláken tak nemůže dokončit své spuštění, dokud se nedostane k nevyřízeným zdrojům. Tato situace vyústila v zablokování, kde obě vlákna nekonečně čekají na zdroje.

Níže je uveden příklad zablokování v Javě.

public class Main { public static void main(String() args) { //define shared resources final String shared_res1 = 'Java tutorials'; final String shared_res2 = 'Multithreading'; // thread_one => locks shared_res1 then shared_res2 Thread thread_one = new Thread() { public void run() { synchronized (shared_res1) { System.out.println('Thread one: locked shared resource 1'); try { Thread.sleep(100);} catch (Exception e) {} synchronized (shared_res2) { System.out.println('Thread one: locked shared resource 2'); } } } }; // thread_two=> locks shared_res2 then shared_res1 Thread thread_two = new Thread() { public void run() { synchronized (shared_res2) { System.out.println('Thread two: locked shared resource 2'); try { Thread.sleep(100);} catch (Exception e) {} synchronized (shared_res1) { System.out.println('Thread two: locked shared resource 1'); } } } }; //start both the threads thread_one.start(); thread_two.start(); } }

Výstup

Zablokování v Javě - výstup

Ve výše uvedeném programu máme dva sdílené zdroje a dvě vlákna. Obě vlákna se pokoušejí přistupovat ke sdíleným prostředkům jeden po druhém. Výstup ukazuje, že obě vlákna uzamykají každý jeden prostředek, zatímco čekají na ostatní. Tím dochází k zablokování situace.

I když nemůžeme zastavit úplné zablokování situace, určitě se jim můžeme vyhnout provedením některých kroků.

Níže jsou uvedeny prostředky, pomocí kterých se můžeme vyhnout zablokování v Javě.

# 1) Vyhýbáním se vnořeným zámkům

Mít vnořené zámky je nejdůležitějším důvodem zablokování. Vnořené zámky jsou zámky, které jsou přiděleny více vláknům. Proto bychom se měli vyvarovat blokování více než jednoho vlákna.

# 2) Použijte vlákno Připojit

Měli bychom používat Thread.join s maximálním časem, aby vlákna mohla využívat maximální čas pro provedení. Tím se zabrání zablokování, ke kterému většinou dochází, když jedno vlákno nepřetržitě čeká na ostatní.

# 3) Vyvarujte se zbytečného zámku

Měli bychom zamknout pouze potřebný kód. Mít zbytečné zámky kódu může vést k zablokování v programu. Protože zablokování může narušit kód a bránit toku programu, měli bychom být nakloněni tomu, abychom v našich programech zabránili zablokování.

Často kladené otázky

Otázka č. 1) Co je synchronizace a proč je důležitá?

Odpovědět: Synchronizace je proces řízení přístupu sdíleného prostředku k více vláknům. Bez synchronizace může více vláken aktualizovat nebo měnit sdílený prostředek současně, což má za následek nekonzistence.

Proto bychom měli zajistit, aby se ve vícevláknovém prostředí vlákna synchronizovala, takže způsob, jakým přistupují ke sdíleným prostředkům, se vzájemně vylučuje a je konzistentní.

Otázka 2) Co je to synchronizace a nesynchronizace v Javě?

Odpovědět: Synchronizace znamená, že konstrukce je bezpečná pro vlákna. To znamená, že více vláken nemůže přistupovat ke konstrukci (blok kódu, metoda atd.) Najednou.

Nesynchronizované konstrukce nejsou bezpečné pro vlákna. K nesynchronizovaným metodám nebo blokům může kdykoli přistupovat více vláken. Populární nesynchronizovanou třídou v Javě je StringBuilder.

Otázka č. 3) Proč je vyžadována synchronizace?

Odpovědět: Když procesy potřebují provádět současně, potřebujeme synchronizaci. Je to proto, že potřebujeme zdroje, které mohou být sdíleny mezi mnoha procesy.

Aby se předešlo střetům mezi procesy nebo vlákny pro přístup ke sdíleným prostředkům, musíme tyto prostředky synchronizovat, aby všechna vlákna získala přístup k prostředkům a aplikace také běžela hladce.

Otázka č. 4) Jak získáte seznam Synchronized ArrayList?

Odpovědět: Můžeme použít Collection.synchronized list metodu s ArrayList jako argument pro převod ArrayList na synchronizovaný seznam.

Otázka č. 5) Je HashMap synchronizován?

jaký je nejlepší software pro čištění počítače

Odpovědět: Ne, HashMap není synchronizován, ale HashTable je synchronizován.

Závěr

V tomto kurzu jsme podrobně diskutovali o synchronizaci vláken. Spolu s ním jsme se také dozvěděli o volatilním klíčovém slovu a zablokování v Javě. Synchronizace se skládá ze synchronizace procesů a vláken.

V prostředí s více vlákny se více zajímáme o synchronizaci vláken. Zde jsme viděli přístup synchronizovaného klíčového slova k synchronizaci vláken.

Zablokování je situace, kdy více vláken nekonečně čeká na zdroje. Viděli jsme příklad zablokování v Javě spolu s metodami, jak se vyhnout zablokování v Javě.

=> Navštivte zde a dozvíte se Java od začátku.

Doporučené čtení

^