Beheer van gedeelde data op Java

We kunnen denken aan een gedeelde data als alle andere informatie die de verwerking van taken die worden blootgesteld aan meer partijen. Stel je voor, bijvoorbeeld, een numerieke waarde die de euro / dollar op te slaan. We hebben een programma dat periodiek controleert of wat de wisselkoers en updates van de waarde van de variabele. Een of meer andere programma's, zal echter gebruik maken van de actuele informatie van de wisselkoers conversieprijs te bedienen.

Merk op hoe het beheer van een gedeelde, zelfs in dit eenvoudige voorbeeld, speciale aandacht nodig hebben. Stel je bijvoorbeeld dat, terwijl een applicatie nodig heeft om de wisselkoers te lezen om te zetten, ook wordt ontvangen door een ander programma, een verzoek om de wisselkoers zelf te veranderen.

Die voor het eerst wordt uitgevoerd? Welke koers conversie wordt gedaan? Het probleem, zelfs in sommige gevallen iets meer complex, zou nog ernstiger zijn.

Stel je voor dat de variabele rente niet elementair is, maar, bijvoorbeeld, bestaat uit een set van data. Het kan nu worden uitgevoerd slechts gedeeltelijk te schrijven, en dan gevolgd door een lezing van de voltooiing van het schrijven. De transacties zouden dan worden uitgevoerd met een set van waarden slechts gedeeltelijk veranderd, die aanleiding geven tot nietszeggende resultaten en derhalve onaanvaardbaar.

Gezien het bestaan ​​van dit soort problemen veel programmeertalen speciale hulpmiddelen gaan aanbieden voor het beheer van gedeelde variabelen. We gaan hieronder in het bijzonder als deze categorie van problemen wordt behandeld in de Java-programmeertaal, een van de meest gebruikte van allemaal.

Je moet eerst begrijpen hoe we ervoor kunnen zorgen dat slechts een programma tegelijk, of beter gezegd slechts een thread per keer (een thread is de hoeksteen van een proces of programma, met andere woorden een programma kan bestaan ​​uit meerdere threads, run tegelijk) kan een gedeelde variabele toegang. Het mechanisme dat ons in staat stelt aan te bieden deze garantie wordt genoemd wederzijdse uitsluiting.

Wederzijdse uitsluiting

Stel je voor het ontwikkelen van een klasse (of een set van data en methoden, dat is nuttige functies om de data zelf-proces) genoemd Variabile_Condivisa als volgt opgebouwd:

 public class Variabile_Condivisa







 {



   



 euro_dollaro drijven;



   



 euro_sterlina drijven;





   



 Variabile_Condivisa ()



  



 {



     



 euro_dollaro = 1;



     



 euro_sterlina = 1;



  



 }





   



 set_euro_dollaro void (float e_d) = {euro_dollaro e_d;}



   



 set_euro_sterlina void (float e_s) = {euro_sterlina e_s;}





   



 get_euro_dollaro float () {return euro_dollaro;}



   



 get_euro_sterlina float () {return euro_sterlina;}







 }

De twee verklaringen, en dat euro_dollaro euro_sterlina, wat neerkomt op de wisselkoers euro / dollar en de euro / pond en dat willen we informatie tussen meerdere programma's (of tussen meerdere threads) te delen. De ontwikkelde methoden kunt u een waarde om deze gegevens (en set_euro_dollaro set_euro_sterlina) toe te wijzen en deze waarden (en get_euro_dollaro get_euro_sterlina) te lezen.

Vervolgens identificeren we een bepaalde methode (Variabile_Condivisa), die wordt genoemd de constructor van de klasse wordt uitgevoerd en dat de creatie van elk Variabile_Condivisa, in dit geval door het instellen van de waarden van variabelen en euro_dollaro euro_sterlina zijn ingesteld op 1.

Dan creëren we in ons programma een object type de naam var Variabile_Condivisa (de klasse vertegenwoordigt een set van entiteiten met gemeenschappelijke kenmerken, terwijl een object vertegenwoordigt een specifiek onderdeel van deze set, die kan worden verwezen in het programma ) op deze manier:

 Variabile_Condivisa Variabile_Condivisa var = new ();

Als we kunnen nu voor zorgen dat er geen problemen zijn bij het beheer van de gedeelde informatie var? De Java-taal biedt het trefwoord (of trefwoorden) gesynchroniseerd, dat elk object als een parameter accepteert. Door middel van gesynchroniseerd, kunt u definiëren, zoals in het voorbeeld, het blok van de code:

 gesynchroniseerd (var)







 {



  



 / / Gesynchroniseerde blok code gescheiden (var)

  





 }

Voor het uitvoeren van de instructies in de gesynchroniseerde blok, elke discussie verwerft het slot op de variabele var, of blokkeren alle verdere toegang tot dezelfde blok van code tot de vergrendeling wordt opgeheven, of tot na het uitvoeren van het hele blok voorbeeld van de code begrensd door accolades.

Met andere woorden, de eerste draad (die we voorstellen om het eerste gesprek) dat de gesynchroniseerde verklaring (var) voert creëert eigenlijk een barrière die een andere draad voorkomt dat de gesynchroniseerde verklaring (var) uit te voeren totdat het eerste is niet voltooid de uitvoering van de gesynchroniseerde blok code afgebakend. In deze blokken worden vervolgens de instructies lezen of schrijven van gedeelde data.

Op deze manier is het gegarandeerd wederzijdse uitsluiting, die ervoor zorgt dat slechts een thread tegelijk toegang tot een gedeelde variabele. Hierbij moet echter worden opgemerkt, dat het noodzakelijk is om zorgvuldig te kiezen het object worden doorgegeven als een parameter om te synchroniseren. Het moet een object gemeenschappelijk zijn voor alle threads in die u wilt een mechanisme voor wederzijdse uitsluiting, bijvoorbeeld, zoals in dit geval, de variabele die u wilt lezen of bewerken creëren.

Stel je voor, op dit punt, wilt u ons programma zo instellen dat de draden die willen de waarde van de variabele var te worden in de wacht gezet te lezen en de resultaten te evalueren pas na de eerste update na hun verzoek. Stel je voor dat je een synchronisatie-mechanisme tussen lezen en schrijven te definiëren.

• <<
• 1
• 2
• >>