Java – Threads

De acordo com o artigo lançado anteriormente sobre heranças, que pode ser consultado aqui, aprendemos que trabalhar com classes em Java é muito prático e reduz trabalho. Se soubermos estruturar bem o nosso código e o nosso problema, temos meio caminho andado para poupar 50% das linhas de código que escrevemos.

Mas, o que faltou aprender? Como bem se lembra o leitor, para vermos o cão e o gato a morrer no nosso tutorial anterior, era necessário escrever várias vezes a mesma linha de código. Hoje, vamos mostrar ao leitor como deixar as coisas acontecerem, no pano de fundo, ou seja em background, mas noutro cenário!

Correção do desafio

Como habitual, deixamos aqui a correção do desafio lançado anteriormente. Foi dos que acertou? Então parabéns.

public class Cachorro extends Cao{    
    public Cachorro(int idade, String nome) {
        super(idade, nome);
    }    
    public void asneira(){
        System.out.println("fiz asneiras");
    }
}

Threads

Mas afinal, o que são threads? Pense o leitor quando executa o programa. Existe todo um ciclo que é invocado. A função main é executada e é lançada uma thread sem que se aperceba. Imagine o cenário de uma fábrica. 

Os trabalhadores estão a produzir mas, por detrás da produção existe todo um processo de materiais a chegar à fábrica e os produtos produzidos a sair da nossa empresa! Podemos considerar isso processos em background, pois nós não nos apercebemos que estão lá, mas eles existem. Por exemplo, crie um procjeto novo chamado “Fabrica” e corra o seguinte exemplo:

O exemplo do código que vamos executar vai simular a fábrica. Acontece que o que irá compilar, não será real. Vai primeiro produzir, depois para a produção, vai exportar e depois importar

thread2

public static void main(String[] args) {
        System.out.println("1 - Estou a produzir");        
        System.out.println("2 - Estou a exportar");
        System.out.println("3 - Estou a importar");
    }

Aplicar as Threads

Se o leitor quer uma fábrica a funcionar de forma correcta e, sem paragens, vamos ter de recorrer à utilização das Threads. Existem duas formas de utilizar threads. Para que não se habitue a más práticas de programação, vamos lhe mostrar a melhor e mais organizada. Para isso vamos criar 3 classes. Cada classe é um sector da fábrica e cada classe irá realizar o implements Runnable. Isto é uma forma de dizer ao compilador que queremos que a nossa classe seja uma thread e o leitor irá reparar que será obrigado a implementar uma função.


O objectivo será ter uma fábrica a produzir, exportar e importar ao mesmo tempo. Estes processos não podem ocorrer um de cada vez porque senão não iria cobrir a realidade do dia-a-dia.

Thread

public class Produzir implements Runnable{

    @Override
    public void run() {
        // Para que nunca pare de correr, colocamos dentro de um ciclo
        while(true){            
            // De 1 em 1 segundo vai escrever
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
            }
            System.out.println("Produzi mais um produto");
        }
    }
}
public class Exportar implements Runnable{
    @Override
    public void run() {
        // Para que nunca pare de correr, colocamos dentro de um ciclo
        while(true){            
            // De 3 em 3 segundos vai escrever
            try {
                 Thread.sleep(3000);
             } catch (InterruptedException ex) {
             }
            System.out.println("Acabei de exportar um produto");
        }
    }
}
public class Importar implements Runnable{
    @Override
    public void run() {
        // Para que nunca pare de correr, colocamos dentro de um ciclo
        while(true){            
            // De 5 em 5 segundos vai escrever
            try {
                Thread.sleep(5000);
            } catch (InterruptedException ex) {
            }
            System.out.println("Importação de matéria prima");
        }
    }
}
public static void main(String[] args) {
        Exportar exportacao = new Exportar();
        Produzir producao = new Produzir();
        Importar importacao = new Importar();
        Thread t1 = new Thread(exportacao);
        Thread t2 = new Thread(producao);
        Thread t3 = new Thread(importacao);
        t1.start();t2.start();t3.start();        
    }

Como deve ter reparado, o output do seu código nunca pára, isto porque na thread main nós lançamos mais 3 threads e elas ficam a correr por detrás sem que o programador tenha nada que fazer. Isto é o que acontece diariamente no seu computador. O leitor está a ler este artigo porque existem centenas de processos a correr por detrás sem que dê conta.

Desafio

Como não poderia faltar, iremos deixar um desafio mas, hoje um pouco mais complexo que o habitual!

O objetivo será o leitor juntar a matéria de heranças com as threads. Com isto, crie duas classes, uma “Tijolo” e outra “Cimento” que são derivadas da classe “Importar”. As classes deverão escrever o seguinte output:

System.out.println("Importação de XPTO feita");

Note-se que a classe importar deixará de ser utilizada na classe main, pelo que a sua classe main deverá ter o seguinte aspecto:

public static void main(String[] args) {
        Exportar exportacao = new Exportar();
        Produzir producao = new Produzir();
        Cimento cimento = new Cimento();
        Tijolo tijolo = new Tijolo();
        
        Thread t1 = new Thread(exportacao);
        Thread t2 = new Thread(producao);
        Thread t3 = new Thread(cimento);
        Thread t4 = new Thread(tijolo);
        t1.start();t2.start();t3.start();t4.start(); 
    }

Mostre-nos que realmente percebeu o artigo ou deixe as suas dúvidas em comentário ou envie mail para erbi.silva@techemportugues.com