java synchronized what is thread synchronization java
Ta vadnica razlaga sinhronizacijo niti v Javi skupaj s sorodnimi koncepti, kot so Java Lock, Race Condition, Mutex, Java Volatile & Deadlock v Javi:
V okolju z več nitmi, kjer je vključenih več niti, bodo zagotovo prišlo do spopadov, kadar več niti hkrati poskuša dobiti isti vir hkrati. Rezultat teh spopadov je 'stanje dirke', zato program daje nepričakovane rezultate.
Na primer, eno datoteko posodabljata dve niti. Če ena nit T1 posodablja to datoteko, recimo nekaj spremenljivk. Zdaj, ko ta posodobitev s strani T1 še poteka, recimo, da druga nit T2 posodobi isto spremenljivko. Tako bo spremenljivka dala napačne rezultate.
=> Tu si oglejte celotno serijo usposabljanja za Java.
Ko gre za več niti, bi morali te niti upravljati tako, da lahko do vira hkrati dostopa ena sama nit. V zgornjem primeru je treba datoteko, do katere dostopata obe niti, upravljati tako, da T2 ne more dostopati do datoteke, dokler T1 ne dostopi do nje.
To se naredi v Javi z uporabo » Sinhronizacija niti '.
Kaj se boste naučili:
Sinhronizacija niti v Javi
Ker je Java jezik z več nitmi, je sinhronizacija niti v Javi zelo pomembna, saj se več niti izvaja vzporedno v aplikaciji.
Uporabljamo ključne besede 'Sinhronizirano' in 'hlapljivo' za sinhronizacijo v Javi
Sinhronizacijo potrebujemo, če je predmet ali vir v skupni rabi spremenljiv. Če je vir nespremenljiv, bodo niti prebrale vir le sočasno ali posamično.
V tem primeru nam ni treba sinhronizirati vira. V tem primeru JVM to zagotavlja Sinhronizirana koda Java se izvaja po eni niti naenkrat .
V večini primerov lahko sočasni dostop do skupnih virov v Javi povzroči napake, kot sta »Nedoslednost pomnilnika« in »Vmešavanje niti«. Da bi se izognili tem napakam, moramo uporabiti sinhronizacijo skupnih virov, tako da se dostop do teh virov medsebojno izključuje.
Uporabljamo koncept, imenovan Monitorji za izvajanje sinhronizacije. Do monitorja lahko hkrati dostopa samo ena nit. Ko nit pridobi ključavnico, lahko rečemo, da je nit vstopila v monitor.
Ko določena nit dostopa do monitorja, se zaslon zaklene, vse druge niti, ki poskušajo vstopiti v monitor, pa se prekinejo, dokler se nit za dostop ne konča in sprosti ključavnico.
V nadaljevanju bomo v tej vadnici podrobno razpravljali o sinhronizaciji v Javi. Zdaj pa razpravljajmo o nekaterih osnovnih pojmih, povezanih s sinhronizacijo v Javi.
Race Condition in Java
V večnitnem okolju, ko več niti poskuša hkrati dostopati do vira v skupni rabi za pisanje, se več niti med seboj dirkajo do konca dostopa do vira. To povzroča 'kondicijske pogoje'.
Upoštevati je treba, da ni težav, če več niti poskuša dostopati do vira v skupni rabi samo za branje. Težava nastane, ko več niti hkrati dostopa do istega vira.
Dirkalni pogoji se pojavijo zaradi pomanjkanja ustrezne sinhronizacije niti v programu. Ko pravilno sinhroniziramo niti, tako da bo do vira naenkrat dostopala samo ena nit, in dirkaško stanje preneha obstajati.
Kako torej zaznati dirkalne pogoje?
Najboljši način zaznavanja stanja dirke je pregled kode. Kot programer bi morali temeljito pregledati kodo in preveriti morebitne pogoje dirke, ki bi se lahko pojavili.
Ključavnice / monitorji v Javi
Omenili smo že, da za izvajanje sinhronizacije uporabljamo monitorje ali ključavnice. Monitor ali zaklepanje je notranja entiteta in je povezano z vsakim predmetom. Torej, kadar mora nit do predmeta dostopati, mora najprej pridobiti ključavnico ali monitor svojega predmeta, obdelati predmet in nato sprostiti ključavnico.
Ključavnice v Javi bodo videti tako, kot je prikazano spodaj:
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(); } } Kot je prikazano zgoraj, imamo metodo lock (), ki zaklene primerek. Vse niti, ki kličejo metodo lock (), bodo blokirane, dokler se nizi metod unblock () ne zaklenejo na false in obvestijo vse čakajoče niti.
Nekaj napotkov, ki si jih je treba zapomniti glede ključavnic:
- V Javi ima vsak predmet ključavnico ali monitor. Do te ključavnice lahko dostopa nit.
- Naenkrat lahko ta monitor ali zaklepanje pridobi samo ena nit.
- Programski jezik Java ponuja ključno besedo Synchronized (Sinhronizirano), ki nam omogoča sinhronizacijo niti z izdelavo bloka ali metode kot Synchronized.
- Viri v skupni rabi, do katerih morajo niti dostopati, se hranijo v tem sinhroniziranem bloku / metodi.
Muteksi v Javi
Že smo razpravljali, da se v večnitnem okolju lahko pojavijo dirkalni pogoji, ko več niti hkrati poskuša dostopati do virov v skupni rabi in dirkalni pogoji povzročijo nepričakovane rezultate.
Del programa, ki poskuša dostopati do vira v skupni rabi, se imenuje 'Kritični odsek' . Da bi se izognili pogojem dirke, je treba sinhronizirati dostop do kritičnega odseka. S sinhronizacijo tega kritičnega odseka poskrbimo, da lahko naenkrat dostopa do kritičnega odseka samo ena nit.
Najpreprostejši tip sinhronizatorja je 'mutex'. Mutex zagotavlja, da lahko v katerem koli primeru samo ena nit izvede kritični odsek.
Mutex je podoben konceptu monitorjev ali ključavnic, ki smo ga obravnavali zgoraj. Če mora nit dostopati do kritičnega odseka, mora pridobiti mutex. Ko je mutex pridobljen, bo nit dostopala do kritične kode odseka in po zaključku sprosti mutex.
Ostale niti, ki čakajo na dostop do kritičnega odseka, bodo medtem blokirane. Takoj, ko ga nit, ki drži mutex, sprosti, bo druga nit vstopila v kritični odsek.
kako zagnati datoteko swf v
Obstaja več načinov, kako lahko uporabimo mutex v Javi.
- Uporaba sinhronizirane ključne besede
- Uporaba Semaphore
- Uporaba ReentrantLock
V tej vadnici bomo obravnavali prvi pristop, tj. Sinhronizacijo. O drugih dveh pristopih - Semaphore in ReentrantLock bomo razpravljali v naslednji vadnici, v kateri bomo razpravljali o sočasnem paketu java.
Sinhronizirana ključna beseda
Java ponuja ključno besedo »Sinhronizirano«, ki jo lahko v programu uporabimo za označevanje kritičnega odseka. Kritični odsek je lahko blok kode ali celotna metoda. Tako lahko samo ena nit dostopa do kritičnega odseka, označenega s sinhronizirano ključno besedo.
Sočasne dele (dele, ki se izvajajo hkrati) lahko zapišemo za aplikacijo z uporabo sinhronizirane ključne besede. Dirkalnih pogojev se znebimo tudi tako, da naredimo blok kode ali sinhronizirano metodo.
Ko označimo blok ali metodo sinhronizirano, zaščitimo skupne vire v teh entitetah pred hkratnim dostopom in s tem pred poškodbami.
Vrste sinhronizacije
Kot je razloženo spodaj, obstajata dve vrsti sinhronizacije:
# 1) Sinhronizacija procesa
Sinhronizacija procesov vključuje več procesov ali niti, ki se izvajajo hkrati. Končno dosežejo stanje, ko se ti procesi ali niti zavežejo določenemu zaporedju dejanj.
# 2) Sinhronizacija niti
Pri sinhronizaciji niti več kot ena nit poskuša dostopati do skupnega prostora. Niti se sinhronizirajo tako, da naenkrat dostopa do skupnega prostora samo ena nit.
Sinhronizacija procesov je izven področja uporabe te vadnice. Zato bomo tukaj razpravljali samo o sinhronizaciji niti.
V Javi lahko sinhronizirano ključno besedo uporabljamo z:
- Blok kode
- Metoda
Zgornje vrste se med seboj izključujejo vrste sinhronizacije niti. Medsebojna izključitev preprečuje, da bi se niti, ki dostopajo do skupnih podatkov, motile med seboj.
Druga vrsta sinhronizacije niti je »InterThread komunikacija«, ki temelji na sodelovanju med nitmi. Komunikacija med nitmi je zunaj področja uporabe te vadnice.
Preden nadaljujemo s sinhronizacijo blokov in metod, izvedimo program Java, ki bo prikazal vedenje niti, ko sinhronizacije ni.
Večnitni navoji brez sinhronizacije
Naslednji program Java ima več niti, ki niso sinhronizirane.
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'); } } }Izhod
Iz izhoda lahko vidimo, da je izhod neskladen, ker niti niso sinhronizirane. Obe niti se začneta, nato pa števec prikažeta ena za drugo. Obe niti izstopata na koncu.
Iz prikazanega programa bi morala prva nit izstopiti po prikazu vrednosti števca, nato pa bi morala druga nit začeti prikazovati vrednosti števca.
Zdaj pa pojdimo na sinhronizacijo in začnimo s sinhronizacijo blokov kode.
Blok sinhronizirane kode
Sinhronizirani blok se uporablja za sinhronizacijo bloka kode. Ta blok je običajno sestavljen iz nekaj vrstic. Sinhronizirani blok se uporablja, kadar ne želimo, da se sinhronizira celotna metoda.
Na primer, imamo metodo z recimo 75 vrsticami kode. Od tega je treba samo eno vrstico naenkrat izvesti samo 10 vrstic kode. V tem primeru, če naredimo celotno metodo sinhronizirano, bo to breme za sistem. V takih situacijah se odločimo za sinhronizirane bloke.
Obseg sinhronizirane metode je vedno manjši od obsega sinhronizirane metode. Sinhronizirana metoda zaklene predmet vira v skupni rabi, ki ga bo uporabljalo več niti.
Splošna sintaksa sinhroniziranega bloka je prikazana spodaj:
synchronized (lock_object){ //synchronized code statements }Tu je »lock_object« referenčni izraz predmeta, na katerem naj se zaklene. Torej, kadar hoče nit za izvedbo dostopati do sinhroniziranih stavkov znotraj bloka, mora pridobiti ključavnico na monitorju ‘lock_object’.
Kot smo že omenili, sinhronizirana ključna beseda zagotavlja, da lahko samo ena nit naenkrat pridobi ključavnico, vse druge niti pa morajo počakati, da se nit, ki drži ključavnico, konča in sprosti ključavnico.
Opomba
- Vrne se 'NullPointerException', če je uporabljeni objekt lock_objavil Null.
- Če nit spi, medtem ko še vedno drži ključavnico, se ključavnica ne sprosti. Druge niti v tem času spanja ne bodo mogle dostopati do predmeta v skupni rabi.
Zdaj bomo predstavili zgornji primer, ki je bil že izveden z majhnimi spremembami. V prejšnjem programu kode nismo sinhronizirali. Zdaj bomo uporabili sinhronizirani blok in primerjali izhod.
Večnitni s sinhronizacijo
V spodnjem programu Java uporabljamo sinhroniziran blok. V načinu izvajanja sinhroniziramo kodo vrstic, ki natisnejo števec za vsako nit.
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'); } } }Izhod
Zdaj je izhod tega programa s sinhroniziranim blokom dokaj skladen. Po pričakovanju se obe niti začneta izvajati. Prva nit je končala s prikazom vrednosti števca in izstopov. Nato druga nit prikaže vrednosti števca in izstopi.
Sinhronizirana metoda
V tem poglavju razpravljamo o sinhronizirani metodi. Prej smo videli, da lahko majhen blok, sestavljen iz manj kodnih vrstic, razglasimo za sinhroniziran blok. Če želimo, da se sinhronizira celotna funkcija, lahko metodo razglasimo za sinhronizirano.
Ko je metoda sinhronizirana, lahko samo ena nit naenkrat izvede klic metode.
Splošna sintaksa za pisanje sinhronizirane metode je:
synchronized method_name (parameters){ //synchronized code } Tako kot sinhronizirani blok tudi pri sinhronizirani metodi potrebujemo lock_object, ki ga bodo uporabljale niti, ki dostopajo do sinhronizirane metode.
Pri sinhronizirani metodi je objekt zaklepanja lahko eden od naslednjih:
- Če je sinhronizirana metoda statična, je objekt zaklepanja podan z objektom .class.
- Za nestatično metodo je objekt zaklepanja podan s trenutnim objektom, tj. 'Ta' objekt.
Posebnost sinhronizirane ključne besede je, da se ponovno vključi. To pomeni, da lahko sinhronizirana metoda pokliče drugo sinhronizirano metodo z isto ključavnico. Tako lahko nit, ki drži ključavnico, dostopa do druge sinhronizirane metode, ne da bi morali pridobiti drugo ključavnico.
Sinhronizirana metoda je prikazana na spodnjem primeru.
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(); } } Izhod
V zgornjem programu smo s sinhronizirano metodo natisnili kvadratke števila. Zgornja meja števila se kot argument posreduje metodi. Nato se od 1 začnejo kvadratki vsake številke tiskati, dokler ni dosežena zgornja meja.
V glavni funkciji se ustvari primerek niti. Vsakemu primerku niti se pošlje številka za tiskanje kvadratov.
Kot je bilo omenjeno zgoraj, ko je metoda, ki jo je treba sinhronizirati, statična, potem je v razred vključen objekt zaklepanja in ne predmet. To pomeni, da bomo zaklenili razred in ne objekt. To se imenuje statična sinhronizacija.
Spodaj je naveden še en primer.
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(); } } Izhod
V zgornjem programu tiskamo množilne tabele števil. Vsaka številka, katere tabelo je treba natisniti, je primerek niti različnega razreda niti. Tako natisnemo množilne tabele 2 in 5, tako da imamo dva razreda 'thread_one in thread_two za tiskanje tabel 2 oziroma 5.
kaj je najboljši os za pc
Če povzamemo, sinhronizirana ključna beseda Java izvaja naslednje funkcije:
- Sinhronizirana ključna beseda v Javi zagotavlja vzajemno izključen dostop do skupnih virov z zagotavljanjem mehanizma za zaklepanje. Zaklepanje preprečuje tudi dirkalne razmere.
- Z uporabo sinhronizirane ključne besede preprečujemo sočasne napake pri programiranju v kodi.
- Ko je metoda ali blok razglašen za sinhroniziran, potem nit potrebuje izključno zaklepanje, da vstopi v sinhronizirano metodo ali blok. Po izvedbi potrebnih dejanj nit sprosti ključavnico in izpiše operacijo zapisovanja. Na ta način bo odpravil napake v pomnilniku, povezane z nedoslednostjo.
Hlapljivo v Javi
Hlapljiva ključna beseda v Javi se uporablja za izdelavo razredov varnih pred nitmi. Ključno besedo volatile uporabljamo tudi za spreminjanje vrednosti spremenljivke z različnimi nitmi. Hlapljivo ključno besedo lahko uporabimo za razglasitev spremenljivke s primitivnimi tipi in predmeti.
V nekaterih primerih se kot nadomestna sinhronizirana ključna beseda uporablja volatilna ključna beseda, vendar upoštevajte, da ne nadomešča sinhronizirane ključne besede.
Ko je spremenljivka razglašena za volatilno, se njena vrednost nikoli ne shrani v predpomnilnik, ampak se vedno bere iz glavnega pomnilnika. Hlapljiva spremenljivka zagotavlja urejenost in vidnost. Čeprav je spremenljivko mogoče razglasiti za spremenljivo, razredov ali metod ne moremo razglasiti za spremenljive.
Upoštevajte naslednji blok kode:
class ABC{ static volatile int myvar =10; }V zgornji kodi je spremenljivka myvar statična in spremenljiva. Statična spremenljivka je v skupni rabi med vsemi predmeti razreda. Hlapljiva spremenljivka se vedno nahaja v glavnem pomnilniku in se nikoli ne shrani v predpomnilnik.
Zato bo v glavnem pomnilniku samo ena kopija myvarja in vsa dejanja branja / pisanja bodo izvedena na tej spremenljivki iz glavnega pomnilnika. Če myvar ne bi bil razglašen za hlapljiv, bi imel vsak predmet niti drugačno kopijo, ki bi povzročila nedoslednosti.
Nekatere razlike med hlapljivimi in sinhroniziranimi ključnimi besedami so navedene spodaj.
| Hlapljiva ključna beseda | Sinhronizirana ključna beseda |
|---|---|
| Hlapljiva ključna beseda se uporablja samo s spremenljivkami. | Sinhronizirana ključna beseda se uporablja s kodnimi bloki in metodami. |
| Hlapljiva ključna beseda ne more blokirati niti za čakanje. | Sinhronizirana ključna beseda lahko blokira nit za čakanje. |
| Učinkovitost niti je izboljšana z Volatile. | Zmogljivost niti se s sinhronizirano nekoliko poslabša. |
| Hlapljive spremenljivke se nahajajo v glavnem pomnilniku. | Sinhronizirani konstrukti niso v glavnem pomnilniku. |
| Hlapno sinhronizira eno spremenljivko med pomnilnikom niti in glavnim pomnilnikom hkrati. | Sinhronizirana ključna beseda sinhronizira vse spremenljivke hkrati. |
Zastoj v Javi
Videli smo, da lahko sinhroniziramo več niti z uporabo sinhronizirane ključne besede in programe naredimo varne za nit. S sinhronizacijo niti zagotovimo, da se več niti izvaja istočasno v okolju z več nitmi.
Včasih pa pride do situacije, ko niti ne morejo več delovati hkrati. Namesto tega čakajo neskončno. To se zgodi, ko ena nit čaka na vir, drugi vir pa jo blokira.
Druga nit pa čaka na viru, ki ga blokira prva nit. Takšna situacija na Javi povzroči 'mrtvo točko'.
Zastoj v Javi je prikazan s spodnjo sliko.
Kot lahko vidimo iz zgornjega diagrama, je nit A zaklenila vir r1 in čaka na vir r2. Nit B pa je blokiral vir r2 in čaka na r1.
Tako nobena od niti ne more dokončati izvajanja, če ne dobijo čakajočih virov. Zaradi tega je prišlo do zastoja, kjer obe niti neskončno čakata na vire.
Spodaj je primer mrtvih blokov v Javi.
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(); } }Izhod
V zgornjem programu imamo dva skupna sredstva in dve niti. Obe niti poskušata dostopati do virov v skupni rabi enega za drugim. Izhod prikazuje obe niti, ki med čakanjem na druge zakleneta po en vir. S tem se ustvari mrtva točka.
Čeprav se ne moremo popolnoma ustaviti, da bi se zgodilo, da se mrtve točke popolnoma pojavijo, se jim lahko z nekaj koraki izognemo.
Spodaj so navedena sredstva, s katerimi se lahko izognemo zastojem v Javi.
# 1) Z izogibanjem ugnezdenim ključavnicam
Vgnezdene ključavnice so najpomembnejši razlog za blokado. Vgnezdene ključavnice so ključavnice, ki so dane več niti. Tako se moramo izogibati dajanju ključavnic več kot eni niti.
# 2) Uporabi nit Pridružite se
Thread.join bi morali uporabiti z največjim časom, da lahko niti uporabijo največ časa za izvedbo. To bo preprečilo zastoj, ki se večinoma pojavi, ko ena nit neprestano čaka na druge.
# 3) Izogibajte se nepotrebnemu zaklepanju
Zaklenili bi morali samo potrebno kodo. Če imate nepotrebne ključavnice za kodo, lahko pride do zastojev v programu. Ker lahko zastoji zlomijo kodo in ovirajo pretok programa, se moramo nagibati k temu, da se v naših programih izognemo zastojem.
Pogosto zastavljena vprašanja
V # 1) Kaj je sinhronizacija in zakaj je pomembna?
Odgovor: Sinhronizacija je postopek nadzora dostopa vira v skupni rabi do več niti. Brez sinhronizacije lahko več niti hkrati posodobi ali spremeni vir v skupni rabi, kar povzroči nedoslednosti.
Tako bi morali zagotoviti, da se niti v večnitnem okolju sinhronizirajo, tako da se način dostopa do skupnih virov medsebojno izključuje in dosledno.
V # 2) Kaj je sinhronizacija in nesinhronizacija v Javi?
Odgovor: Sinhronizacija pomeni, da je konstrukcija varna pred nitmi. To pomeni, da več niti ne more hkrati dostopati do konstrukta (blok kode, metoda itd.).
Nesinhronizirani konstrukti niso varni pred nitmi. Več niti lahko kadar koli dostopa do nesinhroniziranih metod ali blokov. Priljubljen nesinhroniziran razred v Javi je StringBuilder.
V # 3) Zakaj je potrebna sinhronizacija?
Odgovor: Kadar se morajo procesi izvajati sočasno, potrebujemo sinhronizacijo. To je zato, ker potrebujemo vire, ki si jih lahko delijo številni procesi.
Da bi se izognili spopadom med procesi ali nitmi za dostop do virov v skupni rabi, moramo te vire sinhronizirati, tako da vse niti dobijo dostop do virov in tudi aplikacija deluje nemoteno.
V # 4) Kako dobite sinhroniziran seznam arrayList?
Odgovor: Za pretvorbo ArrayList v sinhroniziran seznam lahko uporabimo metodo Collections.synchronized list z ArrayList kot argument.
V # 5) Ali je HashMap sinhroniziran?
kako najti varnostni ključ usmerjevalnika
Odgovor: Ne, HashMap ni sinhroniziran, HashTable pa je sinhroniziran.
Zaključek
V tej vadnici smo podrobno razpravljali o sinhronizaciji niti. Skupaj z njo smo spoznali tudi spremenljivo ključno besedo in zastoje v Javi. Sinhronizacija je sestavljena iz sinhronizacije procesov in niti.
V okolju z več nitmi se bolj ukvarjamo s sinhronizacijo niti. Tu smo videli pristop sinhronizirane ključne besede pri sinhronizaciji niti.
Zastoj je situacija, ko več niti neskončno čaka na vire. Videli smo primer zastojev v Javi, skupaj z metodami, kako se izogniti zastojem v Javi.
=> Obiščite tukaj, če se želite naučiti Jave iz nič.
Priporočeno branje
- Thread.Sleep () - metoda spanja Thread () v Javi s primeri
- Java niti z metodami in življenjskim ciklom
- Osnove Java: Sintaksa Java, Razred Java in Osnovni koncepti Java
- Večnitnost v Javi - Vadnica s primeri
- Večnitnost v jeziku C ++ z primeri
- JAVA Vadnica za začetnike: 100+ praktičnih Javnih video vadnic
- Komponente Java: Java Platform, JDK, JRE in Java Virtual Machine
- Vadnica za Java String | Nizovske metode Java s primeri