Synkronointi Javassa on kyky hallita useiden säikeiden pääsyä mihin tahansa jaettuun resurssiin.

Java-synkronointi on parempi vaihtoehto, jos haluamme sallia vain yhden säikeen pääsyn jaettuun resurssiin.

Miksi käyttää synkronointia?

Synkronointia käytetään pääasiassa

1. Langan häiriöiden estämiseksi.
2. Estä johdonmukaisuusongelmat.

Synkronoinnin tyypit

Synkronointia on kahta tyyppiä

1. Prosessin synkronointi
2. Säikeen synkronointi

Tässä käsitellään vain säikeen synkronointia.

Säikeen synkronointi

On olemassa kahden tyyppistä säietynkronointia keskinäistä poissulkevaa ja säikeiden välistä viestintää.

1. Keskinäinen yksinoikeus
   1. Synkronoitu menetelmä.
   2. Synkronoitu lohko.
   3. Staattinen synkronointi.
2. Yhteistyö (säikeiden välinen viestintä javassa)

Keskinäinen yksinoikeus

Mutual Exclusive auttaa estämään säikeitä häiritsemästä toisiaan tietojen jakamisen aikana. Se voidaan saavuttaa käyttämällä seuraavia kolmea tapaa:

1. Synkronoitua menetelmää käyttämällä
2. Käyttämällä synkronoitua lohkoa
3. Käyttämällä staattista synkronointia

Lukon käsite Javassa

Synkronointi rakentuu sisäisen kokonaisuuden ympärille, joka tunnetaan nimellä lukko tai näyttö. Jokaiseen esineeseen liittyy lukko. Sopimuksen mukaan säikeen, joka tarvitsee jatkuvan pääsyn objektin kenttiin, on hankittava objektin lukko ennen niiden käyttöä ja vapautettava lukko, kun se on valmis.

Java 5:stä alkaen paketti java.util.concurrent.locks sisältää useita lukkototeutuksia.

Ongelman ymmärtäminen ilman synkronointia

Tässä esimerkissä ei ole synkronointia, joten tulos on epäjohdonmukainen. Katsotaanpa esimerkkiä:

TestSynchronization1.java

 class Table{ void printTable(int n){//method not synchronized for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } class mythread1 extends thread{ table t; mythread1(table t){ this.t="t;" public void run(){ t.printtable(5); mythread2 mythread2(table t.printtable(100); testsynchronization1{ static main(string args[]){ obj="new" table(); only one object t1="new" mythread1(obj); t2="new" mythread2(obj); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 100 10 200 15 300 20 400 25 500 </pre> <h3>Java Synchronized Method</h3> <p>If you declare any method as synchronized, it is known as synchronized method.</p> <p>Synchronized method is used to lock an object for any shared resource.</p> <p>When a thread invokes a synchronized method, it automatically acquires the lock for that object and releases it when the thread completes its task.</p> <p> <strong>TestSynchronization2.java</strong> </p> <pre> //example of java synchronized method class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } class mythread1 extends thread{ table t; mythread1(table t){ this.t="t;" public void run(){ t.printtable(5); mythread2 mythread2(table t.printtable(100); testsynchronization2{ static main(string args[]){ obj="new" table(); only one object t1="new" mythread1(obj); t2="new" mythread2(obj); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <h3>Example of synchronized method by using annonymous class</h3> <p>In this program, we have created the two threads by using the anonymous class, so less coding is required.</p> <p> <strong>TestSynchronization3.java</strong> </p> <pre> //Program of synchronized method by using annonymous class class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } public class testsynchronization3{ static void main(string args[]){ final table obj="new" table(); only one object thread t1="new" thread(){ run(){ obj.printtable(5); }; t2="new" obj.printtable(100); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <hr></=5;i++){></pre></=5;i++){></pre></=5;i++){>

Java synkronoitu menetelmä

Jos määrität jonkin menetelmän synkronoiduksi, sitä kutsutaan synkronoiduksi menetelmäksi.

Synkronoitua menetelmää käytetään objektin lukitsemiseen mille tahansa jaetulle resurssille.

Kun säie kutsuu synkronoitua menetelmää, se hankkii automaattisesti kyseisen objektin lukon ja vapauttaa sen, kun säie suorittaa tehtävänsä.

TestSynchronization2.java

 //example of java synchronized method class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } class mythread1 extends thread{ table t; mythread1(table t){ this.t="t;" public void run(){ t.printtable(5); mythread2 mythread2(table t.printtable(100); testsynchronization2{ static main(string args[]){ obj="new" table(); only one object t1="new" mythread1(obj); t2="new" mythread2(obj); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <h3>Example of synchronized method by using annonymous class</h3> <p>In this program, we have created the two threads by using the anonymous class, so less coding is required.</p> <p> <strong>TestSynchronization3.java</strong> </p> <pre> //Program of synchronized method by using annonymous class class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } public class testsynchronization3{ static void main(string args[]){ final table obj="new" table(); only one object thread t1="new" thread(){ run(){ obj.printtable(5); }; t2="new" obj.printtable(100); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <hr></=5;i++){></pre></=5;i++){>

Esimerkki synkronoidusta menetelmästä käyttämällä anonyymiä luokkaa

Tässä ohjelmassa olemme luoneet kaksi säiettä käyttämällä anonyymiä luokkaa, joten koodausta tarvitaan vähemmän.

TestSynchronization3.java

 //Program of synchronized method by using annonymous class class Table{ synchronized void printTable(int n){//synchronized method for(int i=1;i<=5;i++){ system.out.println(n*i); try{ thread.sleep(400); }catch(exception e){system.out.println(e);} } public class testsynchronization3{ static void main(string args[]){ final table obj="new" table(); only one object thread t1="new" thread(){ run(){ obj.printtable(5); }; t2="new" obj.printtable(100); t1.start(); t2.start(); < pre> <p> <strong>Output:</strong> </p> <pre> 5 10 15 20 25 100 200 300 400 500 </pre> <hr></=5;i++){>