Linhas do controle em Java

Os programadores são familiares com os programas seqüenciais da escrita. O programa que indica “Hello o mundo! ”, ou o programa que classifica uma lista dos nomes, ou computa a lista de números principais, são seqüencial todos os programas: cada um tem o começo, extremidade, seqüência, e em toda a hora dada durante o runtime do programa há um único ponto da execução.

Uma linha é similar a um programa seqüencial, uma única linha tem também o começo, extremidade, seqüência, e em toda a hora dada durante o runtime da linha haverá um único ponto da execução. Mas a linha própria não é um programa que não pode funcionar por se mas por funcionamentos dentro do programa.

Exemplo simples da linha

O seguinte exemplo é uma aplicação simples de Java que críe e comece duas linhas independentes.

class TwoThreadsTest
{
public static void main (String args[])
{
new SimpleThread("Japan").start();
new SimpleThread("India").start();
}
}

class SimpleThread extends Thread
{
public SimpleThread(String str)
{
super(str);
}
public void run()
{
for (int i = 0; i < 10; i++)
{
System.out.println(i + " " + getName());
try
{
sleep((int)(Math.random() * 1000));
} catch (InterruptedException e)
{}
}
System.out.println("DONE! " + getName());
}
}

O primeiro método na classe de SimpleThread é um construtor que faça exame somente da corda como seu argumento. Este construtor é executado chamando os superclass construtor e é interessante porque ajusta o nome da linha que é usado mais tarde no programa.

O método seguinte nesta classe é () método funcionado. o método do funcionamento () é o coração de toda a linha, esta é onde a ação da linha ocorre. O método do funcionamento () na classe de SimpleThread contem a para o laço que itera dez vezes. Em cada uma da iteração indica o número da iteração e o nome da linha e dorme então para o intervalo aleatório de um tempo entre 0 e 1 segundo. Após ter terminado o laço, o método do funcionamento () imprime “FEITO!” junto com o nome da linha.

Atributos de uma linha

Toda a ação ocorre no corpo da linha, no método do funcionamento da linha (). Nós podemos fornecer o corpo à linha em uma das duas maneiras: primeiramente subclassing uma classe da linha e cancelando o método do funcionamento () da linha, secondly criando uma linha com o objeto Runnable como seu alvo.

Corpo de uma linha

As linhas de Java são executadas usando a classe da linha que é a parte do pacote de java.lang. Uma classe da linha executa a definição independente do sistema de linhas de Java. Mas, a execução real da operação simultânea é fornecida pela execução sistema-específica. Para a maioria das necessidades de programação, a execução subjacente não importa; nós podemos ignorar a execução subjacente e programar a linha API e a outra documentação fornecida com o sistema de Java.

Estados de uma linha

Durante todo a vida, a linha de Java estará em uma entre diversos estados. O estado de uma linha indica o que a linha está fazendo atualmente e o que pode fazer naquele tempo de sua vida: se ele está funcionando? está dormindo? ou está inoperante? Estes estados são ilustrados abaixo.

Linha nova
The statement below creates a new thread but it will not start it thereby leaving the thread in a state labeled "New Thread".

Thread myThread = new MyThreadClass();

Quando a linha está “no estado da linha nova”, meramente é um objeto vazio da linha. Nenhum recurso de sistema é alocado para ele ainda. Assim quando a linha está neste estado, nós podemos somente começar ou parar a linha; quando uma linha está neste estado que chama algum do outro método além do começo () ou o batente () não fará nenhum sentido e não causa um IllegalThreadStateException.

Runnable
O método do começo () cría todos os recursos de sistema necessários para funcionar uma linha, programa a linha para funcionar, e o método do funcionamento da linha das chamadas ().

Thread myThread = new MyThreadClass();
myThread.start();

Neste momento a linha está no estado “Runnable”. Este estado é chamado estado “Runnable” melhor que estado “funcionando” porque a linha não pode funcionar realmente quando está neste estado. Muitos computadores têm um único processador fazê-lo impossível funcionar ao mesmo tempo todas as linhas “Runnable”. Conseqüentemente o sistema runtime de Java deve executar o esquema programando que compartilha do processador entre todas as linhas “Runnable”. Para a maioria das finalidades entretanto, nós podemos pensar do estado “Runnable” como simplesmente “funcionando”. Quando uma linha está funcionando, é “Runnable” e é a linha atual. As instruções no método do funcionamento () estão executando sequencialmente.

Nao runnable
Uma linha participa no estado “nao runnable” quando um de seguintes eventos ocorre:

Quando um método suspender () for chamado
Quando um método do sono () for chamado
Quando a linha usar seu método da espera () esperar uma variável da circunstância
Quando a linha obstruir no I/o.

Thread myThread = new MyThreadClass();
myThread.start();
try
{
myThread.sleep(10000);
} catch (InterruptedException e)
{
}

A linha bold(realce) no exemplo acima põe o myThread para dormir por 10 segundos. Durante estes 10 segundos, mesmo se o processador se tornar disponível o myThread não funcionará. Após 10 segundos sobre, o myThread torna-se “Runnable” outra vez e se o processador estivesse disponível funcionaria.

Seguir indicações indica a rota de escape para cada entrada no estado “nao runnable”.

Se a linha for posta para dormir, então o tempo especificado deve decorrer.
Se a linha for suspendida, então alguém deve chamar o método do resumo ().
Se a linha estiver esperando na variável da circunstância, o que objeto possui a variável deve abandonar esta chamando notifica () ou método do notifyAll ().
Se a linha for obstruída no I/O, a seguir o comando especificado do I/O deve começar completo.

Inoperante
Uma linha pode morrer em duas maneiras diferentes: qualquer um por uma causa natural, ou sendo matado (parado). Uma linha está dita morrer naturalmente quando o método do funcionamento () retira normalmente. Cosider por exemplo, o laço do quando no método do funcionamento for um laço finito, iterará 100 vezes e para-as de então executar.

public void run()
{
int i = 0;
while (i < 100)
{
i++;
System.out.println("i = " + i);
}
}

Nós podemos também matar uma linha em qualquer altura que simplesmente chamando o método do batente (). Isto é como mostrado no código abaixo:

public void run()
{
Thread myThread = new MyThreadClass();
myThread.start();
try
{
Thread.currentThread().sleep(10000);
} catch (InterruptedException e)
{
}
myThread.stop();
}

O método do funcionamento aqui cría e myThread dos começos então põe a linha atual para dormir por uns 10 segundos. Quando a linha atual acorda, a linha bold(realce) no segmento de código matará o myThread.

O método do batente () jogará um objeto de ThreadDeath para matar a linha. Quando a linha é matada desse modo morre asynchronously. A linha morrerá quando recebe realmente uma exceção de ThreadDeath.

IllegalThreadStateException
o sistema runtime joga um IllegalThreadStateException quando nós chamamos um método em uma linha e o estado da linha não permitirá essa chamada do método. Por exemplo, IllegalThreadStateException está jogado quando nós chamamos um método suspender () em uma linha que não seja “Runnable”.

Como por nos exemplos das linhas estudadas assim distante neste capítulo, quando nós chamamos um método da linha que possa jogar uma exceção, você deve travar e segurar a exceção, ou deve declarar isso, a exceção de chamada do uncaught dos throws do método.

public void run()
{
Thread myThread = new MyThreadClass();
myThread.start();
try
{
Thread.currentThread().sleep(10000);
} catch (InterruptedException e)
{
}
myThread.stop();
}

() método isAlive

Se o método que () os retornos isAlive verdadeiros enfíam então for começado e não parado. Assim, se () o método isAlive retornar falso nós sabemos que a linha é qualquer uma “linha nova” ou a “inoperante”. Se () o método isAlive retornar verdadeiro, você então a linha é “Runnable” ou “nao runnable”.

Prioridade da linha

Quando uma linha de Java é criada, herda a prioridade da linha que a criou. Nós podemos também modificar a prioridade da linha em qualquer altura que após sua criação usando o setPriority do método (). As prioridades das linhas variam de MIN_PRIORITY a MAX_PRIORITY (estas são as constantes definidas na linha da classe). Em todo o instante dado do tempo, quando as linhas múltiplas estão prontas para executar, o sistema runtime escolhe a linha “Runnable” que tem a prioridade a mais elevada para a execução. Somente quando esta linha para, rende, ou torna-se “nao runnable” para alguma sorte da razão, executar mais baixo do começo da linha da prioridade. Se houver duas linhas que têm o mesmo processador central de espera da prioridade, o scheduler escolhê-los-á em uma forma do redondo-robin.

Linhas do Daemon

Toda a linha de Java pode ser linha do daemon. As linhas do Daemon são fornecedores de serviço para aqueles linhas ou objetos que funcionam em mesmo processo que a linha do daemon está funcionando. Por exemplo, o browser de HotJava tem uma linha do daemon, chamada o leitor da imagem de fundo, que lê imagens do sistema de lima ou rede para alguma do objeto ou da linha que necessita uma imagem.