Java/A classe Thread

Origem: Wikilivros, livros abertos por um mundo aberto.
Saltar para a navegação Saltar para a pesquisa

Resumidamente, uma Thread em Java é composta de três partes:

  1. CPU ( processamento compartilhado para executar rotinas )
  2. Código ( linhas de código de uma rotina que serão executadas )
  3. Dados ( área de dados que fazem parte da execução da rotina )

Ou seja, o objeto Thread do Java proveniente da classe java.lang.Thread, representa uma instância da CPU da máquina virtual Java, e que tem associada um trecho de código que será executado, e uma área de memória.

Podemos criar uma Thread em Java de duas maneiras:

  1. Estendendo o comportamento da classe Thread
  2. Implementando a interface Runnable

Criando uma Thread a partir da classe java.lang.Thread[editar | editar código-fonte]

O código abaixo mostra como criar uma classe que [funciona][1] como uma Thread:

// MinhaThread.java
public class MinhaThread extends java.lang.Thread {

    // área de dados da Thread
    private int contador; 
    private int limite;
    
    // inicializador da MinhaThread 
    public MinhaThread( int limite ) {
        this.limite = limite; 
        this.contador = 0;
    }

    // área de código da Thread
    public void run() {
        while (contador <= limite) {
            System.out.println( super.getName() + "\t" + contador );
            contador ++;
            // trecho de código para demonstração somente
            try {
                Thread.sleep( 1000 ); // coloca a "thread" para "dormir" 1 segundo
            } catch (InterruptedException e) {
                e.printStackTrace( System.err );
            }
        }
    }
}

O código abaixo mostra como usar a classe MinhaThread:

// TesteMinhaThread.java
public class TesteMinhaThread {
    
    public static void main(String[] args) {
        MinhaThread mt1 = new MinhaThread( 200 );
        mt1.setName("MinhaThread1");
        MinhaThread mt2 = new MinhaThread( 300 );
        mt2.setName("MinhaThread2");
        MinhaThread mt3 = new MinhaThread( 200 );
        mt3.setName("MinhaThread3");
        MinhaThread mt4 = new MinhaThread( 400 );
        mt4.setName("MinhaThread4");
        mt2.start();
        mt1.start();
        mt3.start();
        mt4.start();
    }
}

Executando o classe TesteMinhaThread, veremos que as Threads incrementam o contador separadamente, baseado no objeto MinhaThead.

Criando uma Thread a partir da interface java.lang.Runnable[editar | editar código-fonte]

O código abaixo mostra como criar uma classe que funciona como uma Thread:


// MeuRunnable.java
public class MeuRunnable implements java.lang.Runnable {

    // área de dados da Thread
    private int contador; 
    private int limite;
    
    // inicializador da MinhaThread 
    public MeuRunnable ( int limite ) {
        this.limite = limite; 
        this.contador = 0;
    }

    // área de código da Thread
    public void run() {
        while (contador <= limite) {
            System.out.println( Thread.currentThread().getName() + "\t" + contador );
            contador ++;
            // trecho de código para demonstração somente
            try {
                Thread.sleep( 1000 ); // coloca a "thread" para "dormir" 1 segundo
            } catch (InterruptedException e) {
                e.printStackTrace( System.err );
            }
        }
    }
}

O código abaixo mostra como usar a classe MeuRunnable:

// TesteMeuRunnable.java
public class TesteMeuRunnable {
    
    public static void main(String[] args) {
        MeuRunnable mr1 = new MeuRunnable ( 300 );
        MeuRunnable mr2 = new MeuRunnable ( 200 );
        MeuRunnable mr3 = new MeuRunnable ( 400 );
        MeuRunnable mr4 = new MeuRunnable ( 200 );
        Thread t1 = new Thread( mr1 );
        t1.setName("MeuRunnable1");
        Thread t2 = new Thread( mr2 );
        t2.setName("MeuRunnable2");
        Thread t3 = new Thread( mr3 );
        t3.setName("MeuRunnable3");
        Thread t4 = new Thread( mr4 );
        t4.setName("MeuRunnable4");
        t2.start();
        t1.start();
        t3.start();
        t4.start();
    }
}

Executando o classe TesteMeuRunnable, veremos que as Threads incrementam o contador separadamente, baseado no objeto MeuRunnable.

Considerações de Design[editar | editar código-fonte]

  • Usar a implementação do Runnable, dá maior flexibilidade de Design, pois permite que a classe que implementou a interface java.lang.Runnable estenda o comportamento de outra classe.
  • Estender diretamente a classe Thread, facilita o acesso aos métodos da classe java.lang.Thread, mas dificulta a modelagem da POO pois impede que a sub-classe de Thread estenda outra classe.

Desafio[editar | editar código-fonte]

Criar uma pequena aplicação gráfica usando a Java SWING API de simulador simples para um prédio que tenha 3 elevadores e que funcionam independentemente.

Ligações externas[editar | editar código-fonte]