O conteúdo envolvido neste capítulo inclui:
1. JONE () INTRODUÇÃO
2. Join () Análise de código -fonte (com base no JDK1.7.0_40)
3. Junir () Exemplo
1. JONE () INTRODUÇÃO
junção () é definido em thread.java.
O papel da junção (): deixe o "thread principal" aguardar o "thread infantil" terminar antes de continuar sendo executado. Esta frase pode ser um pouco obscura, mas devemos entendê -la através de exemplos:
A cópia do código é a seguinte:
// Tópico principal
public classe Padre estende o tópico {
public void run () {
Son s = new Son();
s.start ();
S.Join ();
...
}
}
// Tópico infantil
classe pública Son estende thread {
public void run () {
...
}
}
ilustrar:
O exposto acima são duas classes pai (classe principal de threads) e filho (classe subthread). Como o filho é criado e iniciado no pai, o pai é a principal aula de threads e o filho é a aula de fios infantis.
No painel principal do pai, crie um novo "Libern Threads" através do novo filho (). Em seguida, inicie o "Child Thread S" através do s.start () e ligue para S.Join (). Depois de ligar para S.Join (), o painel principal do pai esperará até que o "tópico da criança" seja concluído; É isso que chamamos de "o papel da junção () é fazer com que o tópico principal aguarde o tópico infantil terminar antes de continuar a correr"!
2. Join () Análise de código -fonte (com base no JDK1.7.0_40)
A cópia do código é a seguinte:
public final void junção () lança interruptedException {
Junte -se (0);
}
Public final sincronizado Void Junção (Long Millis)
throws interruptedException {
Long Base = System.CurrentTimemillis ();
longo agora = 0;
if (millis <0) {
lançar novas ilegalargumentException ("O valor do tempo limite é negativo");
}
if (millis == 0) {
while (isalive ()) {
espere (0);
}
} outro {
while (isalive ()) {
Longo atraso = millis - agora;
if (atraso <= 0) {
quebrar;
}
espera (atraso);
agora = system.currenttimemillis () - base;
}
}
}
ilustrar:
从代码中，我们可以发现。 Quando Millis == 0, ele entrará no While (Isalive ()) Loop;
Entendemos o uso de junção () com base no código acima ao explicar o papel de junção ()!
pergunta:
Embora o local onde S.Join () seja chamado ocorre no "Padre Main Thread", S.Join () é chamado de junção () através de "Libern thread S". Em seguida, o método Isalive () no junção () deve determinar se o "Thread S" é o estado vivo; Mas se for esse o caso, como a função de S.Join () pode ser "Deixe o fio principal esperar até que o tópico da criança seja concluído", deve ser deixar o fio filho esperar (porque o método de espera do tópico infantil Objeto S é chamado bem) "?
Resposta: A função de wait () é fazer com que o "thread atual" aguarde e o "thread atual" aqui se refere ao thread atualmente em execução na CPU. Portanto, embora o método Wait () do thread filho seja chamado, ele é chamado através do "tópico principal";
3. Junir () Exemplo
Depois de entender o papel de junção (), vamos verificar o uso de junção () por meio de exemplos.
A cópia do código é a seguinte:
// Código fonte de Java Java
classe pública Jointest {
public static void main (string [] args) {
tentar {
Threada T1 = novo ThreadA ("T1");
t1.start ();
t1.Join ();
System.out.printf ("%s acabamento/n", thread.currentThread (). GetName ());
} catch (interruptedException e) {
E.PrintStackTrace ();
}
}
classe estática threada estende thread {
public threada (nome da string) {
super (nome);
}
public void run () {
System.out.printf ("%s iniciar/n", this.getName ());
// operação de atraso
para (int i = 0; i <1000000; i ++)
;
System.out.printf("%s finish/n", this.getName());
}
}
}
Resultados em execução:
A cópia do código é a seguinte:
t1 start
t1 finish
final principal
Resultados Descrição:
O processo de operação é mostrado na figura
(01) Crie um novo "Thread T1" em "Principal Main Thread Main" através do novo ThreadA ("T1"). Em seguida, inicie "Thread T1" através de t1.start () e execute t1.join ().
(02) Depois de executar o T1.Join (), o "Principal Main Main" entrará no "estado de bloqueio" e aguardará o final da execução do T1. Após a conclusão do "Thread Child T1", o "Principal principal do tópico" será despertado e o "thread principal" recuperará os direitos de execução da CPU e continuará sendo executado.