The Beauty of Concurrent

A linguagem Java basicamente utiliza a Interface Runnable e a classe Thread para possibilitar a execução de mais de um fluxo de controle sobre o código de programa. Aqui temos um exemplo simples para ilustrar um dos métodos de criação de múltiplos fluxos de execução (o outro método consiste em estender a classe Thread).

A metáfora é que as instâncias da classe Thread são abstrações de trabalhadores:
Thread operario= new Thread();
Thread trabalhador= new Thread();

Mas trabalhadores precisam de tarefas. As instâncias de classes que implementam a interface Runnable devem definir as tarefas.
class trabalho implements Runnable{…}
class tarefa implements Runnable{…}

Podemos associar uma tarefa a um trabalhador utilizando um construtor de Thread. Uma instância de Thread invoca o método run() da instância de Runnable. o método start() de uma instância de Thread inicia o fluxo de controle. Só  se pode chamar start() uma vez. Resumindo:

class Tarefa implements Runnable{
... public void run() {/* código para realizar a tarefa */}
...
}
...
  public static void main(String[] args){
    Runnable tarefa=new Tarefa();
    Thread trabalhador=new Thread(tarefa);
    trabalhador.start(); /* o fluxo de controle irá retornar, mas um novo fluxo permanecerá em start(). */

No programa abaixo é utilizada a uma interface padrão denominada Runnable. Uma classe que implementa a interface Runnable deve implementar um método com a seguinte assinatura: public void run(). O programa utiliza ainda uma classe denominada Thread. Um dos construtores da classe Thread recebe como parâmetro uma referência para um objeto cuja classe implementa a interface Runnable. Quando invocamos o método start() de uma instância de Thread o fluxo de controle é duplicado e um dos fluxos de controle segue pelo método run() do objeto Runnable associado e o outro fluxo de controle retorna para o ponto onde o método start() foi invocado. A menos dos aspectos denominados de sincronização, não existem garantias sobre a velocidade relativa de execução dos fluxos de controle. Enquanto existirem fluxos de controle a execução de um programa Java continua, ou seja, o fluxo de controle que percorre o método main pode terminar e o programa continua em execução desde que exista um ou mais fluxos de controle. No programa abaixo após o término do fluxo de controle sobre o método main permanecerão dois fluxos de controle sobre as duas instâncias de Thread correspondentes a duas intâncias de Tarefa. Descreva de maneira concisa o que é escrito pelo programa abaixo.
 

class Tarefa implements Runnable{
  private String s;
  Tarefa(String id){
    s=id;
  }
  public void run(){
    for(;;) System.out.print(s+" ");
  }
}
class linhaSimples{
  public static void main(String[] args){
    Runnable tarefa1=new Tarefa("1");
    Runnable tarefa2=new Tarefa("2");
    Thread trabalhador1=new Thread(tarefa1);
    Thread trabalhador2=new Thread(tarefa2);
    trabalhador1.start();
    trabalhador2.start();
  }
}