Synchronisaatio sisään Java
James Hartman
Mikä on Synchronisaatio sisään Java?
In Java, synkronointi viittaa mahdollisuuteen hallita useiden säikeiden pääsyä mihin tahansa jaettuun resurssiin. Se on ihanteellinen vaihtoehto, jos haluamme sallia vain yhden säikeen pääsyn jaettuun resurssiin.
Tätä suoritustapaa kutsutaan yleensä "asynkroniseksi" ohjelmoimiseksi. Näissä prosessoreissa on myös säikeitä, jotka ovat kevyitä prosesseja, jotka voivat suorittaa käskyjä samanaikaisesti.
Tyyppisiä Synchronisointi
Synkronointimenetelmiä on kahdenlaisia Java:
1) Prosessin synkronointi
2) ketjun synkronointi.
Tutkitaan säiettä ja Prosessin synkronointi yksityiskohtaisesti.
Prosessin synkronointi: Se hallitsee ohjelmien välistä synkronointia. Esimerkiksi ohjelmat, kuten `Microsoft Word` ja `Acrobat reader' toimivat yksittäisinä prosesseina.
Viestiketjun synkronointi: Kahden tai useamman säikeen suorittamaa kriittisen resurssin samanaikaista suorittamista kutsutaan säikeeksi Synchronisointi. Sinut voidaan ryhmitellä edelleen toisensa poissulkevaan ja säikeiden väliseen viestintään.
Mikä on Lock in Java?
Lukita Java on rakennettu sisäisen kokonaisuuden ympärille, joka tunnetaan nimellä monitori tai lukko. Kaikkiin esineisiin liittyy lukko. Joten säikeen, joka tarvitsee jatkuvan pääsyn objektin kenttiin, on hankittava objektin lukko ennen pääsyä niihin, ja se vapauttaa lukon, kun työ on tehty. Tämä varmistaa, että vain yksi säie pääsee jaettuihin tietoihin kerrallaan.
Monisäikeinen ohjelma synkronoinnilla
Monisäikeinen ohjelma on menetelmä tai lohko, joka on suojattu häiriöiltä muilta säikeiltä, jotka jakavat saman resurssin, joka on merkitty "synkronoitu"-avainsanalla.
Käyttämällä synkronoitua menetelmää
Kaikki menetelmät, jotka on ilmoitettu synkronoiduiksi, kutsutaan synkronoiduiksi menetelmäksi. Sitä käytetään myös objektin lukitsemiseen mille tahansa jaetulle resurssille. Joten, kun säie kutsuu synkronoituun menetelmään. Se ottaa automaattisesti haltuunsa kyseisen kohteen lukon ja vapauttaa sen, kun se on suorittanut tehtävänsä.
Huomautus: Synkronoitu avainsana ei voi toimia luokkien ja muuttujien kanssa. Vain menetelmiä ja lohkoja voidaan käyttää avainsanan kanssa.
Miksi käyttää Synchronoitu menetelmä?
- Sitä käytetään objektin lukitsemiseen kaikille jaetuille resursseille.
- Objekti saa lukon aina, kun synkronoitua menetelmää kutsutaan.
- Lukko ei vapaudu ennen kuin lanka on suorittanut tehtävänsä
Syntaksi:
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();
}
}
Koodin selitys:
Suorita tämä esimerkki ja huomaa, että säie "0" saa ensin "mathService"-objektin lukon ja käyttää tätä lukkoa yksinomaan, kunnes sen suorittaminen on valmis. Säikeitä "0" ja "1" ei ole lomitettu tässä koodissa. Tulos on alla olevan kuvan mukainen.
lähtö:
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
Synkronoidun lohkon käyttö
Oletetaan, että et halua synkronoida koko menetelmää. Sen sijaan haluat synkronoida muutaman rivin koodia. Tuolloin, Synchronized block auttoi synkronoimaan valitun Java koodi. Synchronisoituihin menetelmälukkoihin päästään menetelmässä, kun taas synkronoituihin lohkolukkoihin päästään objektissa.
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();
}
}
Koodin selitys:
Kun suoritat tämän koodin, huomaat, että se toimii ilman häiriöitä. Synkronoidussa menetelmässä lukko käyttää menetelmällä, mutta synkronoidussa lohkossa lukko käyttää objektia. Varmista, että tulos on alla olevan kuvan mukainen.
lähtö:
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
Koodin selitys:
Kun suoritat tämän koodin, huomaat, että se toimii ilman häiriöitä, mitä odotimme. Synkronoidussa menetelmässä lukkoa käyttää menetelmä, mutta synkronoidussa lohkomenetelmässä lukkoa käyttää objekti.
Staattisen synkronoinnin käyttäminen
In Java synkronointi, jos objekteja on useampi kuin yksi, kaksi säiettä voi hankkia lukot ja siirtyä synkronoituun lohkoon tai lohkoon, jossa jokaiselle objektille on erillinen lukko. Tämän välttämiseksi voidaan käyttää staattista synkronointia. Synckronisoituja avainsanoja käytetään ennen staattisia menetelmiä.
Huomautus: Staattisessa synkronoinnissa pääsylukko on luokassa, ei objektissa ja menetelmässä.
Koodi, joka osoittaa useiden objektien lukitsemisen
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();
}
}
Koodin selitys:
Kun luomme toisen "MathServicen" esiintymän, aiheutamme häiriötä säikeissä, koska ne limitetään kahden objektin kanssa. Huomaa, että säie "0" ja säiettä "2" on limitetty näiden kahden objektin kanssa, kun taas säikeet "1" ja "3" limitetään näiden kahden objektin kanssa.
lähtö:
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
Sama koodi synkronoidun staattisen menetelmän avulla
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();
}
}
Suorita yllä oleva koodi ja huomaa, että olemme nyt poistaneet säikeen häiriöt. Koodin tuloste näkyy alla.
lähtö:
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
Synkronoinnin käytön edut
Tässä on etuja työskennellessäsi samanaikaisten sovellusten kanssa:
- Synkronoinnin päätavoite Java on estää epäjohdonmukaiset tiedot estämällä säikeen häiriöt.
- Synkronoitu avainsana sisään Java tarjoaa lukituksen, joka varmistaa toisensa poissulkevan pääsyn jaettuun resurssiin ja estää datakilpailun.
- Se estää myös koodilauseiden uudelleenjärjestämisen kääntäjä, joka voi aiheuttaa hienovaraisen samanaikaisen ongelman, jos emme käytä haihtuvia tai synkronoituja avainsanoja.
- Synchronized avainsana lukee tiedot päämuistista kuin välimuistista ja kun se vapauttaa lukon.
- Se myös tyhjentää kirjoitustoiminnot päämuistista ja eliminoi muistin epäjohdonmukaisuusvirheet.
Haitat Synchronisaatiomekanismi
Synchronisaatiomekanismien suorituskyky on heikko.
Esimerkiksi
- Oletetaan, että prosesseja on viisi, A1, A2, A3, A4 ja A5.
- He odottavat, että jaetut resurssit pääsevät käyttämään yhtä säiettä kerrallaan.
- Kaikki prosessit jäävät odottamaan, joten jonon viimeisen on odotettava, kunnes kaikki muut prosessit ovat valmiit.
Yhteenveto
- Synchronisaatio tarkoittaa kykyä hallita useiden säikeiden pääsyä mihin tahansa jaettuun resurssiin.
- Java on kahden tyyppisiä synkronointimenetelmiä: 1) Prosessin synkronointi ja 2) ketjun synkronointi.
- Lukita Java on rakennettu sisäisen kokonaisuuden ympärille, joka tunnetaan nimellä monitori tai lukko.
- Monisäikeinen ohjelma on menetelmä tai lohko, joka on suojattu muiden saman resurssin jakavien säikeiden aiheuttamilta häiriöiltä, jotka on merkitty "synkronoitu"-avainsanalla.
- Kaikki synkronoiduiksi ilmoitettu menetelmä tunnetaan synkronoiduksi menetelmäksi.
- In Java, synkronoituihin menetelmälukkoihin päästään menetelmällä, kun taas synkronoituihin lohkolukkoihin päästään objektissa.
- Staattisessa synkronoinnissa pääsylukko on luokassa, ei objektissa ja menetelmässä.
- Synkronoinnin päätavoite Java on estää epäjohdonmukaiset tiedot estämällä säikeen häiriöt.
- Tämän menetelmän suurin haittapuoli on, että kaikki prosessit pidetään odottamassa, joten jonon viimeisen on odotettava, kunnes kaikki muut prosessit ovat valmiit.