Cap 11 Programação com várias threads

Principais habilidades e conceitos
• Entender os fundamentos da criação de várias threads
• Conhecer a classe Thread e a interface Runnable
• Criar uma thread
• Criar várias threads
• Determinar quando uma thread termina
• Usar prioridades de threads
• Entender a sincronização de threads
• Usar métodos sincronizados
• Usar blocos sincronizados
• Promover a comunicação entre threads
• Suspender, retomar e interromper threads

Threads: São caminhos independentes de execução dentro de um programa.
Multitarefa: Pode ser baseada em processos (vários programas) ou em threads (várias tarefas no mesmo programa).
Vantagens:
Maior eficiência ao usar tempo ocioso.
Melhor uso de sistemas multicore/multiprocessadores.

Criação e Gerenciamento de Threads

Classes e Interfaces:
Thread: Classe que encapsula threads.
Runnable: Interface usada para definir threads personalizadas.

Métodos Comuns da Classe Thread:

• getName(): Retorna o nome da thread.
• getPriority(): Retorna a prioridade.
• isAlive(): Verifica se a thread ainda está executando.
• join(): Aguarda o término da thread.
• run(): Define o ponto de entrada da thread.
• sleep(long ms): Suspende a thread por um período.
• start(): Inicia a execução da thread.

Criando Threads:

• Implementando Runnable:

class MyThread implements Runnable {
    String threadName;

    MyThread(String name) {
        threadName = name;
    }

    public void run() {
        System.out.println(threadName + " starting.");
        try {
            for (int i = 0; i < 10; i++) {
                Thread.sleep(400);
                System.out.println("In " + threadName + ", count is " + i);
            }
        } catch (InterruptedException e) {
            System.out.println(threadName + " interrupted.");
        }
        System.out.println(threadName + " terminating.");
    }
}

public class UseThreads {
    public static void main(String[] args) {
        System.out.println("Main thread starting.");

        MyThread myThread = new MyThread("Child #1");
        Thread thread = new Thread(myThread);
        thread.start();

        for (int i = 0; i < 50; i++) {
            System.out.print(".");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                System.out.println("Main thread interrupted.");
            }
        }
        System.out.println("Main thread ending.");
    }
}

Saída esperada:

Main thread starting.
.
Child #1 starting.
..
In Child #1, count is 0
...
In Child #1, count is 1
...
Main thread ending.

Extensão da Classe Thread:

class MyThread extends Thread {
    MyThread(String name) {
        super(name);
    }

    public void run() {
        System.out.println(getName() + " starting.");
        try {
            for (int i = 0; i < 10; i++) {
                Thread.sleep(400);
                System.out.println("In " + getName() + ", count is " + i);
            }
        } catch (InterruptedException e) {
            System.out.println(getName() + " interrupted.");
        }
        System.out.println(getName() + " terminating.");
    }
}

public class UseThreads {
    public static void main(String[] args) {
        System.out.println("Main thread starting.");

        MyThread thread = new MyThread("Child #1");
        thread.start();

        for (int i = 0; i < 50; i++) {
            System.out.print(".");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                System.out.println("Main thread interrupted.");
            }
        }
        System.out.println("Main thread ending.");
    }
}

obs.: O método sleep( ) faz a thread em que é chamado suspender a execução
pelo período de milissegundos especificado.

tabela do livro