Wat is Syncronisatie op Java? methode, blok, statisch type

Wat is Syncronisatie op Java?

op Java, syncronisatie verwijst naar de mogelijkheid om de toegang van meerdere threads tot een gedeelde bron te controleren. Het is een ideale optie als we slechts één thread toegang willen geven tot de gedeelde bron.

Deze benadering van uitvoering wordt gewoonlijk 'a' genoemdsyncroneuze programmering. Er zijn ook threads op deze processors, dit zijn lichtgewicht processen die instructies gelijktijdig kunnen uitvoerenneonormaal.

Types van Synckroning

Er zijn twee types syncronisatiemethoden in Java:

1) Proces synckroning

2) Draad synckroning.

Laten we Thread en bestuderen Proces synckroning in detail.

Proces synchronisatie: Het lukt syncronisatie tussen programma's. Programma's zoals `Microsoft Word` en `Acrobat reader` draaien als afzonderlijke processen.

Draad synchronisatie: De gelijktijdige uitvoering van de kritieke bron door twee of meer Threads wordt Thread genoemd Syncronisatie. U kunt verder worden gegroepeerd op het gebied van wederzijds exclusieve communicatie en communicatie tussen threads.

Wat is vergrendelen in Java?

Slot in Java is gebouwd rond een interne entiteit die bekend staat als een monitor of het slot. Aan al het object is een slot gekoppeld. De thread die consistente toegang tot de velden van een object nodig heeft, moet dus de vergrendeling van het object verkrijgen voordat hij er toegang toe krijgt, en geeft de vergrendeling vrij wanneer het werk is gedaan. Dit zorgt ervoor dat slechts één thread tegelijk toegang heeft tot de gedeelde gegevens.

Multithreaded programma met synckroning

Een multithreaded programma is een methode of blok beschermd tegen interferentie van andere threads die dezelfde bron delen, aangegeven met de `syncgeroniseerd' trefwoord.

De syncgeroniseerde methode

Elke methode die is gedeclareerd als syncgeroniseerd staat bekend als a syncgeroniseerde methode. Het wordt ook gebruikt om een ​​object voor een gedeelde bron te vergrendelen. Dus wanneer een thread een syncgeroniseerde methode. Het neemt automatisch bezit van het slot voor dat object en geeft het vrij als het zijn taak heeft voltooid.

Opmerking: Het synchronized trefwoord kan niet werken met klassen en variabelen. Alleen methoden en blokken kunnen met het trefwoord worden gebruikt.

Waarom de Syncgeroniseerde methode?

  • Het wordt gebruikt voor het vergrendelen van een object voor gedeelde bronnen.
  • Het object krijgt het slot wanneer de syncgeroniseerde methode wordt genoemd.
  • De vergrendeling wordt pas vrijgegeven als de draad zijn functie heeft voltooid

Syntax:

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();
    }
}

Verklaring van code:

Voer dit voorbeeld uit en zie dat thread `0` eerst de vergrendeling van het `mathService`-object ophaalt en deze vergrendeling exclusief gebruikt totdat de uitvoering ervan is voltooid. Thread `0` en `1` zijn in deze code niet doorschoten. De uitvoer is zoals hieronder weergegeven.

Output:

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

Met een syncgeroniseerd blok

Laten we ervan uitgaan dat u dat niet wilt synchoniseer de hele methode. In plaats daarvan wil je dat syncMaak een paar regels code. Destijds was de Syncgeroniseerd blok hielp hierbij synchoniseer de geselecteerde Java-code.

Syncgeroniseerde methodesloten zijn toegankelijk via de methode, terwijl syncgeroniseerde bloksloten zijn toegankelijk op het object.

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();
    }
}

Code Verklaring:

Wanneer u deze code uitvoert, zult u merken dat deze zonder enige interferentie werkt.

In het syncgeroniseerde methode, het slot wordt toegepast door de methode, maar in de syncgeroniseerd blok, het slot wordt door het object aangebracht.

Zorg ervoor dat de uitvoer is zoals hieronder weergegeven.

Output:

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

Toelichting code:

Wanneer u deze code uitvoert, zult u merken dat deze zonder interferentie werkt, wat we hadden verwacht. In de syncgeroniseerde methode, het slot wordt toegepast door de methode, maar in de syncgeroniseerde blokmethode, het slot wordt toegepast door het object.

Statisch gebruiken synckroning

op Java syncronisatie, als er meer dan één object is, kunnen twee draden de sloten verwerven en een syncgeroniseerd blok of blok, met voor elk object een apart slot. Om dit te voorkomen, statisch syncronisatie kan worden gebruikt.

SyncGehroniseerde trefwoorden zullen vóór statische methoden worden gebruikt.

Opmerking: in statische syncronisatie, de toegang tot het slot is afhankelijk van de klasse, niet van het object en de methode.

Code om het probleem van het vergrendelen van meerdere objecten aan te tonen

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();
    }
}

Toelichting code:

Wanneer we nog een exemplaar van de `MathService` maken, introduceren we interferentie in de threads, aangezien deze worden verweven met de twee objecten. Merk op dat thread '0' en thread '2' zijn verweven met de twee objecten, terwijl thread '1' en '3' zijn verweven met de twee objecten.

Output:

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

Dezelfde code gebruikt syncgeroniseerde statische methode

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();
    }
}

Voer de bovenstaande code uit en merk op dat we nu threadinterferentie hebben geëlimineerd. De uitvoer van de code wordt hieronder weergegeven.

Output:

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

Voordelen van het gebruik synckroning

Dit zijn de voordelen van het werken met gelijktijdige toepassingen:

  • Het hoofddoel van syncHronisatie in Java is bedoeld om inconsistente gegevens te voorkomen door threadinterferentie te voorkomen.
  • Het syncHet geroniseerde trefwoord in Java biedt vergrendeling, waardoor wederzijds uitsluitende toegang tot de gedeelde bron wordt gegarandeerd en gegevensrace wordt voorkomen.
  • Het voorkomt ook dat de code-instructies opnieuw worden geordend door de compiler, wat een subtiel gelijktijdig probleem kan veroorzaken als we geen gebruik maken van vluchtige of syncgeroniseerde trefwoorden.
  • Synchronized trefwoord leest gegevens uit het hoofdgeheugen dan de cache en wanneer het de vergrendeling vrijgeeft.
  • Het verwijdert ook schrijfbewerkingen uit het hoofdgeheugen, waardoor inconsistentiefouten in het geheugen worden geëlimineerd.

Nadelen van Syncronisatiemechanisme

Syncronisatie Mechanismen presteren slecht.

Bij voorbeeld

  • Stel dat er vijf processen zijn: A1, A2, A3, A4 en A5.
  • Ze wachten tot de gedeelde bronnen toegang krijgen tot één thread tegelijk.
  • Alle processen blijven wachten, dus de laatste in de wachtrij moet wachten totdat alle andere processen zijn voltooid.

Samengevat

  • Syncronisatie verwijst naar de mogelijkheid om de toegang van meerdere threads tot een gedeelde bron te controleren.
  • Java kent twee soorten syncronisatiemethoden: 1) Proces syncronisatie en 2) Draad synckroning.
  • Slot in Java is gebouwd rond een interne entiteit die bekend staat als een monitor of het slot.
  • Een Multithreaded programma is een methode of blok dat beschermd is tegen interferentie van andere threads die dezelfde bron delen, aangegeven met de `syncgeroniseerd' trefwoord.
  • Elke methode die is gedeclareerd als syncgeroniseerd staat bekend als a syncgeroniseerde methode.
  • op Java, syncgeroniseerde methodesloten zijn toegankelijk via de methode, terwijl syncgeroniseerde bloksloten zijn toegankelijk op het object.
  • in statische syncronisatie, de toegang tot het slot is afhankelijk van de klasse, niet van het object en de methode.
  • Het hoofddoel van syncHronisatie in Java is bedoeld om inconsistente gegevens te voorkomen door threadinterferentie te voorkomen.
  • Het grootste nadeel van deze methode is dat alle processen wachten, dus de laatste in de wachtrij moet wachten totdat alle andere processen zijn voltooid.