TechCodeview

Vluchtig trefwoord wordt gebruikt om de waarde van een variabele door verschillende threads te wijzigen. Het wordt ook gebruikt om klassen veilig te maken. Het betekent dat meerdere threads zonder enig probleem tegelijkertijd een methode en instantie van de klassen kunnen gebruiken. Het vluchtige trefwoord kan worden gebruikt met het primitieve type of met objecten.

als anders als anders als java

Het vluchtige trefwoord slaat de waarde van de variabele niet op in de cache en leest de variabele altijd uit het hoofdgeheugen. Het vluchtige trefwoord kan niet worden gebruikt met klassen of methoden. Het wordt echter gebruikt met variabelen. Het garandeert ook zichtbaarheid en ordening. Het voorkomt dat de compiler de code opnieuw ordent.

De inhoud van het specifieke apparaatregister kan op elk moment veranderen, dus u hebt het vluchtige sleutelwoord nodig om ervoor te zorgen dat dergelijke toegangen niet door de compiler worden geoptimaliseerd.

Voorbeeld

 class Test { static int var=5; } 

Neem in het bovenstaande voorbeeld aan dat twee threads in dezelfde klasse werken. Beide threads draaien op verschillende processors, waarbij elke thread zijn lokale kopie van var heeft. Als een thread zijn waarde wijzigt, zal de verandering niet worden weerspiegeld in de originele thread in het hoofdgeheugen. Het leidt tot inconsistentie van gegevens omdat de andere thread zich niet bewust is van de gewijzigde waarde.

 class Test { static volatile int var =5; } 

In het bovenstaande voorbeeld zijn statische variabelen klasseleden die door alle objecten worden gedeeld. Er bevindt zich slechts één kopie in het hoofdgeheugen. De waarde van een vluchtige variabele wordt nooit in de cache opgeslagen. Alle lees- en schrijfbewerkingen worden van en naar het hoofdgeheugen uitgevoerd.

Wanneer moet je het gebruiken?

• U kunt een vluchtige variabele gebruiken als u automatisch lange en dubbele variabelen wilt lezen en schrijven.
• Het kan worden gebruikt als een alternatieve manier om synchronisatie in Java te bereiken.
• Alle lezerthreads zullen de bijgewerkte waarde van de vluchtige variabele zien na voltooiing van de schrijfbewerking. Als u het vluchtige trefwoord niet gebruikt, kunnen verschillende lezersthreads verschillende waarden zien.
• Het wordt gebruikt om de compiler te informeren dat meerdere threads toegang hebben tot een bepaalde instructie. Het voorkomt dat de compiler een herschikking of optimalisatie uitvoert.
• Als u geen gebruik maakt van de vluchtige variabele, kunt u de code opnieuw ordenen, zodat u de cachewaarde van de vluchtige variabele kunt schrijven in plaats van uit het hoofdgeheugen te lezen.

Belangrijke punten

• U kunt het vluchtige trefwoord met variabelen gebruiken. Het gebruik van vluchtige trefwoorden met klassen en methoden is illegaal.
• Het garandeert dat de waarde van de vluchtige variabele altijd uit het hoofdgeheugen wordt gelezen, en niet uit de lokale threadcache.
• Als u de variabele als vluchtig heeft gedeclareerd, zijn Read en Writes atomair
• Het vermindert het risico op geheugenconsistentiefouten.
• Elke schrijfactie naar een vluchtige variabele in Java zorgt voor een gebeurtenis vóór de relatie met opeenvolgende leesbewerkingen van diezelfde variabele.
• De vluchtige variabelen zijn altijd zichtbaar voor andere threads.
• De vluchtige variabele die een objectreferentie is, kan nul zijn.
• Wanneer een variabele niet wordt gedeeld tussen meerdere threads, hoeft u het vluchtige trefwoord niet bij die variabele te gebruiken.

Verschil tussen synchronisatie en vluchtig trefwoord

Een vluchtig trefwoord is geen vervanging van een gesynchroniseerd trefwoord, maar kan in bepaalde gevallen als alternatief worden gebruikt. Er zijn de volgende verschillen:

Voorbeeld van een vluchtig zoekwoord

In het volgende voorbeeld hebben we een klasse gedefinieerd die de tellerwaarde verhoogt. De run () -methode in VolatileThread.java haalt de bijgewerkte waarde en de oude waarde op wanneer de uitvoering van de thread begint. In de hoofdklasse definiëren we de array van threads.

VolatileData.java

 public class VolatileData { private volatile int counter = 0; public int getCounter() { return counter; } public void increaseCounter() { ++counter; //increases the value of counter by 1 } } 

VolatileThread.java

 VolatileThread.java public class VolatileThread extends Thread { private final VolatileData data; public VolatileThread(VolatileData data) { this.data = data; } @Override public void run() { int oldValue = data.getCounter(); System.out.println('[Thread ' + Thread.currentThread().getId() + ']: Old value = ' + oldValue); data.increaseCounter(); int newValue = data.getCounter(); System.out.println('[Thread ' + Thread.currentThread().getId() + ']: New value = ' + newValue); } } 

VluchtigeMain.java

 public class VolatileMain { private final static int noOfThreads = 2; public static void main(String[] args) throws InterruptedException { VolatileData volatileData = new VolatileData(); //object of VolatileData class Thread[] threads = new Thread[noOfThreads]; //creating Thread array for(int i = 0; i <noofthreads; ++i) threads[i]="new" volatilethread(volatiledata); for(int i="0;" < noofthreads; threads[i].start(); starts all reader threads threads[i].join(); wait for } pre> <p> <strong>Output:</strong> </p> <pre> [Thread 9]: Old value = 0 [Thread 9]: New value = 1 [Thread 10]: Old value = 1 [Thread 10]: New value = 2 </pre> <hr></noofthreads;>