Gestão de dados compartilhados em Java

Podemos pensar em uma base de dados partilhada como qualquer outra informação tarefas de processamento para ser exposto a mais festas. Imagine, por exemplo, armazenar um valor numérico representando o euro / dólar. Temos um programa que verifica periodicamente se o que a taxa de câmbio e atualiza o valor da variável. Um ou mais outros programas, no entanto, vai usar as informações atualizadas para operar a troca preço de conversão de taxa.

Observe como a gestão de uma compartilhada, mesmo neste exemplo simples, precisam de atenção especial. Imagine por exemplo que enquanto um aplicativo precisa ler a taxa de câmbio para converter, também é recebido por outro programa, um pedido para alterar a taxa de câmbio em si.

Que é executado em primeiro lugar? Que a conversão da taxa de câmbio é feito? O problema, mesmo em alguns casos um pouco mais complexo, poderia ser ainda mais grave.

Imagine fato de que a variável de interesse não é elementar, mas, por exemplo, consiste de um conjunto de dados. Pode agora ser realizada apenas escrever parcial, e depois seguida por uma leitura a partir da conclusão da escrita. As transações seriam, então, ser realizada com um conjunto de valores mudou apenas parcialmente, dando origem a resultados sem sentido e, portanto, inaceitável.

Dada a existência deste tipo de problemas muitas linguagens de programação fornecem ferramentas específicas para a gestão de variáveis ​​compartilhadas. Examinamos a seguir em especial no que esta categoria de problemas é tratada na linguagem de programação Java, uma das mais usadas de todos.

Primeiro você precisa entender como podemos garantir que apenas um programa de uma só vez, ou mais precisamente apenas um segmento de cada vez (um fio é o componente básico de um processo ou programa, em outras palavras, um programa pode consistir de vários segmentos, executados simultaneamente) pode acessar uma variável compartilhada. O mecanismo que nos permite oferecer esta garantia é chamado de exclusão mútua.

Exclusão mútua

Imagine o desenvolvimento de uma classe (ou um conjunto de dados e métodos, ou seja funções úteis para processar os dados em si) chamado Variabile_Condivisa estruturado da seguinte forma:

 public class Variabile_Condivisa







 {



   



 euro_dollaro float;



   



 euro_sterlina float;





   



 Variabile_Condivisa ()



  



 {



     



 euro_dollaro = 1;



     



 euro_sterlina = 1;



  



 }





   



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



   



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





   



 get_euro_dollaro float () {return euro_dollaro;}



   



 get_euro_sterlina float () {return euro_sterlina;}







 }

As duas declarações, e que euro_sterlina euro_dollaro, representando a taxa de câmbio euro / dólar e euro / libra esterlina e que queremos partilhar informações entre vários programas (ou entre vários segmentos). Os métodos desenvolvidos permitem que você atribuir um valor a esses dados (e set_euro_dollaro set_euro_sterlina) e ler os valores (e get_euro_dollaro get_euro_sterlina).

Então nós identificamos um método particular (Variabile_Condivisa), que é chamado o construtor da classe é executado e que a criação de cada Variabile_Condivisa, neste caso, definindo os valores de variáveis ​​e euro_sterlina euro_dollaro são definidos a 1.

Então nós criamos em nosso programa de um tipo de objeto chamado var Variabile_Condivisa (a classe representa um conjunto de entidades com características comuns, enquanto um objeto representa um elemento específico deste conjunto, que podem ser referenciados dentro do programa ) desta forma:

 Variabile_Condivisa Variabile_Condivisa var = new ();

Como agora podemos assegurar que não há problemas na gestão de dados compartilhados var? A linguagem Java fornece a palavra-chave (ou palavras-chave) sincronizado, que aceita qualquer objeto como um parâmetro. Através sincronizado, você pode definir, como mostrado no exemplo, o bloco de código:

 sincronizado (var)







 {



  



 / / Synchronized bloco de código delimitado (var)

  





 }

Antes de executar as instruções do bloco sincronizado, qualquer segmento adquire o bloqueio sobre a variável var, ou bloquear todo o acesso ainda mais para o mesmo bloco de código até que o bloqueio é liberado, ou até que depois de executar o bloco inteiro exemplo de código delimitado por chaves.

Em outras palavras, o primeiro segmento (que imaginamos a primeira chamada) que executa a declaração sincronizado (var), na verdade cria uma barreira que impede que qualquer outro segmento para executar a instrução synchronized (var) até que o primeiro não tenha concluído a execução do bloco sincronizado de código delimitado. Nestes blocos são então inseridas as instruções de leitura ou gravação de dados compartilhados.

Desta forma, é garantida a exclusão mútua, o que garante que apenas um thread por vez pode acessar uma variável compartilhada. Deve-se notar, no entanto, que é necessário escolher cuidadosamente o objeto a ser passado como um parâmetro para sincronizados. Deve ser um objeto comum a todos os tópicos em que você deseja criar um mecanismo de exclusão mútua, por exemplo, como neste caso, a variável que você quer ler ou editar.

Imagine, neste momento, que pretende definir o nosso programa para que os tópicos que deseja ler o valor da variável var para ser colocada em espera e avaliar os resultados somente após a primeira atualização após a sua solicitação. Imagine que você deseja definir um mecanismo de sincronização entre a leitura ea escrita.

• <<
• 1
• 2
• >>