Gestion des données partagées en Java

Nous pouvons penser à un ensemble de données partagées, comme toutes autres tâches de traitement de l'information d'être exposés à plusieurs parties. Imaginez, par exemple, de stocker une valeur numérique représentant la parité euro / dollar. Nous avons un programme qui vérifie périodiquement ce que le taux de change et met à jour la valeur de la variable. Un ou plusieurs autres programmes, cependant, l'utilisation des informations mises à jour pour faire fonctionner le prix de conversion de taux de change.

Remarquez comment la gestion d'une commune, même dans cet exemple simple, une attention particulière. Imaginez par exemple que si une application a besoin de lire le taux de change pour convertir, est également reçu par un autre programme, une demande de changement du taux de change lui-même.

Quel est exécuté en premier? Lequel de conversion de taux de change se fait? Le problème, même dans certains cas un peu plus complexe, pourrait être encore plus sévère.

Imaginez que la variable d'intérêt n'est pas élémentaire mais, par exemple, se compose d'un ensemble de données. Il peut maintenant être effectuée seulement écrire partielle, puis suivies par une lecture de l'achèvement de la rédaction. Les opérations seraient alors effectués avec un ensemble de valeurs que partiellement changé, donnant lieu à des résultats insignifiants, et donc inacceptable.

Compte tenu de l'existence de ce genre de problèmes nombreux langages de programmation fournissent des outils spécifiques pour la gestion des variables partagées. Nous examinons ci-dessous en particulier en cette catégorie de problèmes est traitée dans le langage de programmation Java, l'un des plus utilisé de tous.

Vous devez d'abord comprendre comment nous pouvons assurer que seul programme à la fois, ou plus précisément un seul thread à la fois (un fil est le composant de base d'un processus ou programme, en d'autres termes d'un programme peut se composer de plusieurs threads, fonctionner simultanément) peuvent accéder à une variable partagée. Le mécanisme qui nous permet d'offrir cette garantie est appelé exclusion mutuelle.

L'exclusion mutuelle

Imaginez le développement d'une classe (ou un ensemble de données et méthodes, qui est des fonctions utiles pour traiter les données lui-même) a appelé Variabile_Condivisa structuré comme suit:

 public class Variabile_Condivisa







 {



   



 euro_dollaro flotteur;



   



 euro_sterlina flotteur;





   



 Variabile_Condivisa ()



  



 {



     



 euro_dollaro = 1;



     



 euro_sterlina = 1;



  



 }





   



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



   



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





   



 float get_euro_dollaro () {return euro_dollaro;}



   



 float get_euro_sterlina () {return euro_sterlina;}







 }

Les deux déclarations, et que euro_sterlina euro_dollaro, représentant le taux de change euro / dollar et euro / livre sterling et que nous souhaitons partager des informations entre plusieurs programmes (ou entre plusieurs threads). Les méthodes développées vous permettent d'attribuer une valeur à ces données (et set_euro_dollaro set_euro_sterlina) et de lire ces valeurs (et get_euro_dollaro get_euro_sterlina).

Puis nous identifions une méthode particulière (Variabile_Condivisa), qui est appelé le constructeur de classe est exécuté et que la création de chaque Variabile_Condivisa, dans ce cas, en définissant les valeurs de variables et de euro_dollaro euro_sterlina sont mis à 1.

Puis nous créons dans notre programme un type d'objet nommée var Variabile_Condivisa (la classe représente un ensemble d'entités ayant des caractéristiques communes, tandis qu'un objet représente un élément spécifique de cet ensemble, qui peut être référencé au sein du programme ) de cette façon:

 Variabile_Condivisa Variabile_Condivisa var = new ();

Comme nous pouvons maintenant faire en sorte qu'il n'y ait pas de problèmes dans la gestion des données partagées var? Le langage Java fournit le mot-clé (ou mots-clés) synchronisé, qui accepte n'importe quel objet comme paramètre. Grâce synchronisés, vous pouvez définir, comme le montre l'exemple, le bloc de code:

 synchronisé (var)







 {



  



 / / Synchronisée bloc de code de délimité (var)

  





 }

Avant d'effectuer les instructions dans le bloc synchronisé, aucun thread acquiert le verrou sur la variable var, ou de bloquer tous les accès ultérieur à un même bloc de code jusqu'à ce que le verrou est libéré, ou jusqu'à ce que après l'exécution de l'ensemble du bloc exemple de délimité par des accolades de code.

En d'autres termes, le premier thread (que nous imaginons au premier appel) qui effectue la déclaration synchronisé (var) crée une barrière qui empêche un autre thread pour exécuter la commande synchronisée (var) jusqu'à ce que le premier n'a pas terminé l'exécution du bloc synchronisé des délimité code. Dans ces blocs sont ensuite insérées instructions de lecture ou d'écriture de données partagées.

De cette façon, il est garanti exclusion mutuelle, qui assure qu'un seul thread à la fois peut accéder à une variable partagée. Il faut noter, cependant, qu'il est nécessaire de bien choisir l'objet à être passé comme un paramètre à synchronisée. Il doit être un objet commun à tous les fils dans lequel vous voulez créer un mécanisme d'exclusion mutuelle, par exemple, comme dans ce cas, la variable que vous souhaitez lire ou modifier.

Imaginez, à ce stade, vous souhaitez définir notre programme de telle sorte que les fils qui veulent lire la valeur de la variable var à être mis en attente et d'évaluer les résultats seulement après la première mise à jour suite à leur demande. Imaginez que vous voulez définir un mécanisme de synchronisation entre la lecture et l'écriture.

• <<
• 1
• 2
• >>