Conceitos para utilização de Threads em Java

Conceitos para utilização de Threads em Java

• Java oferece na sua interface de programação a classe Thread através da qual o programador pode dotar objetos de fluxos de execução independentes.
• Da classe são herdados três métodos cujo uso é associado a manipulação de threads: run, start e join.

Método Run

• É  um método virtual na classe thread, devendo ser implementado pela classe do usuário com o serviço que deve ser executado pela thread a ser criada.

Métodos Start e Join

• São implementados pela própria classe thread. Permitem iniciar a execução de uma nova thread e sincronizar com o seu termino.
• A função a ser executada pela thread é definido por um método de uma classe.
• Para executar uma thread é necessário a criação de um objeto da classe que especializa a classe Thread.
• Os métodos start e join são invocados no objeto, e o método RUN invocado implicitamente por start.

Class ThExemplo extends Thread{

        Public ThExemplo(){  }

        Public void Run() {implementação do serviço}

}

Public void static main(String [] args){

        ThExemplo A= new ThExemplo();

                       B= new ThExemplo();

A.Start();

B.Start();

Try{

A.join();

}catch(Exception e){

}

Try{

        B.join();

}catch(Exception e){}

• O controle de execução de seções criticas é garantido por um mecanismo de monitores.
• Ele garante que determinada seção de código será executada por apenas uma thread em um determinado instante de tempo.

Sincronização em nível de objeto

• Garante que apenas uma thread possa executar métodos dentro do escopo de um objeto.
• Faz uso(Implicito) do ponteiro this, permitindo que o objeto sirva uma única thread por vez.

Class Buffer{

        Private pilha p;

        Public Buffer(){p = pilha();}

        Syncronized public void insere(Object _o){

        p.push(_o);

}

Syncronized public object retira(){

Return p.pop();

}

}

• Classe Buffer representa uma área de memória compartilhada entre duas Threads.
• Insere e retira consistem em métodos que atuam sobre uma memória compartilhada (seção crítica).
• Syncronized garante que somente uma thread vai executar o código correspondente a um dos métodos de um determinado objeto buffer.
• Se existir dois objetos buffer criados em um programa, ambos poderão executar ao mesmo tempo seus respectivos métodos insere e retira.
• Um mesmo objeto que esteja sendo utilizado ao mesmo tempo por duas threads não poderá ter os métodos insere e retira executando ao mesmo tempo.

Sincronização em nível de Classe

• Garante que apenas um thread possa executar métodos dentro do escopo de uma classe.
• Uma Classe pode possuir atributos de classe, necessitando de controle de sincronização a nível de classe.
• Para garantir a exclusividade de execução de threads no escopo de uma classe, faz-se uso de métodos static.

Class Buffer{

Private static pilha p;

Initialize{p= new pilha();}

Public Buffer(){}

Syncronized static public void insere(object _o){

p.push(_o);

}

Syncronized static public Object retira(){

Return p.pop();

}

}

• A classe buffer define que a área de dados a ser compartilhada entre produtores e os consumidores é um atributo de classe.
• Todos os produtores e consumidores compartilharão a mesma área de dados.
• O escopo deste atributo é a classe, não podendo ter seu acesso protegido no escopo de um objeto, mas deve ser protegido considerando a execução de todos os produtores e consumidores que venham a ser construídos.

Sincronização em nível de Bloco

• Garante que apenas uma thread possa executar o conjunto de instruções definidas dentro do escopo de bloco.
• Para controlar a execução de uma seção critica definida por um bloco, é utilizado um mecanismo de sincronização apoiado em um objeto auxiliar.
• Este objeto auxiliar pode ser um objeto qualquer, mas a garantia de correção semântica é de responsabilidade do usuário que deve utilizar sempre o mesmo objeto para blocos que compartilham um mesmo dado.
• O único cuidado é que este objeto não seja null e deve ser evitado seu uso dentro da seção critica.

Class Buffer{

        Private object mon;

        Private pilha p;

        Public Buffer(){

        P = new pilha();

        Mon = new object();