O que esse código de associação de encadeamento significa?

Nesse código, o que as duas junções e quebra significam? t1.join()faz t2parar até t1terminar?

Thread t1 = new Thread(new EventThread("e1"));
t1.start();
Thread t2 = new Thread(new EventThread("e2"));
t2.start();
while (true) {
   try {
      t1.join();
      t2.join();
      break;
   } catch (InterruptedException e) {
      e.printStackTrace();
   }
}

O que esse código de associação de encadeamento significa?

Para citar o Thread.join()método javadocs :

join() Aguarda que este segmento morra.

Há um encadeamento que está executando seu código de exemplo que provavelmente é o encadeamento principal .

1. O thread principal cria e inicia os threads t1e t2. Os dois threads começam a ser executados em paralelo.
2. O encadeamento principal pede t1.join()para aguardar o t1encadeamento.
3. O t1encadeamento é concluído e o t1.join()método retorna no encadeamento principal. Observe que t1já poderia ter terminado antes que a join()chamada seja feita . Nesse caso, a join()chamada retornará imediatamente.
4. O encadeamento principal pede t2.join()para aguardar o t2encadeamento.
5. O t2encadeamento é concluído (ou pode ter sido concluído antes do t1encadeamento) e o t2.join()método retorna no encadeamento principal.

É importante entender que os threads t1e t2estão sendo executados em paralelo, mas o thread principal que os iniciou precisa aguardar o término antes de continuar. Esse é um padrão comum. Além disso, t1e / ou t2poderia ter terminado antes que o thread principal os chamasse join(). Nesse caso, join()não esperará, mas retornará imediatamente.

t1.join() significa fazer com que t2 pare até que t1 termine?

Não. O thread principal que está chamando t1.join()irá parar de executar e aguardará o t1término do thread. O t2encadeamento está sendo executado em paralelo e não é afetado t1nem pela t1.join()chamada.

Em termos de tentativa / captura, os join()arremessos InterruptedExceptionsignificam que o thread principal que está chamando join()pode ser interrompido por outro thread.

while (true) {

Ter as junções em whileloop é um padrão estranho. Normalmente, você faria a primeira junção e, em seguida, a segunda junção, manipulando InterruptedExceptionadequadamente em cada caso. Não há necessidade de colocá-los em um loop.

Esta é uma pergunta favorita da entrevista sobre Java .

Thread t1 = new Thread(new EventThread("e1"));
t1.start();
Thread e2 = new Thread(new EventThread("e2"));
t2.start();

while (true) {
    try {
        t1.join(); // 1
        t2.join(); // 2  These lines (1,2) are in in public static void main
        break;
    }
}

t1.join()significa, t1 diz algo como " Eu quero terminar primeiro ". Mesmo é o caso com t2. Independentemente de quem iniciou t1ou t2encadeava (neste caso, o mainmétodo), o main aguardará t1e t2concluirá sua tarefa.

No entanto, um ponto importante a ser anotado t1e t2eles mesmos podem ser executados em paralelo, independentemente da sequência de chamada de junção em t1e t2. É o main/daemonfio que tem que esperar .

join()significa aguardar a conclusão de um encadeamento. Este é um método bloqueador. Seu encadeamento principal (aquele que faz o join()) aguardará na t1.join()linha até t1concluir seu trabalho e, em seguida, fará o mesmo t2.join().

Uma imagem vale mais que mil palavras.

    Main thread-->----->--->-->--block##########continue--->---->
                 \                 |               |
sub thread start()\                | join()        |
                   \               |               |
                    ---sub thread----->--->--->--finish    

Espero útil, para mais detalhes clique aqui

Quando o encadeamento tA chama tB.join (), suas causas não apenas esperam que o tB morra ou o tA seja interrompido, mas criam uma relação de ocorrência anterior entre a última instrução em tB e a próxima instrução após tB.join () no segmento tA.

Todas as ações em um encadeamento ocorrem antes que qualquer outro encadeamento retorne com êxito de uma junção () nesse encadeamento.

Significa programa

class App {
    // shared, not synchronized variable = bad practice
    static int sharedVar = 0;
    public static void main(String[] args) throws Exception {
        Thread threadB = new Thread(() -> {sharedVar = 1;});
        threadB.start();
        threadB.join();

        while (true) 
            System.out.print(sharedVar);
    }
}

Sempre imprima

>> 1111111111111111111111111 ...

Mas programa

class App {
    // shared, not synchronized variable = bad practice
    static int sharedVar = 0;
    public static void main(String[] args) throws Exception {
        Thread threadB = new Thread(() -> {sharedVar = 1;});
        threadB.start();
        // threadB.join();  COMMENT JOIN

        while (true)
            System.out.print(sharedVar);
    }
}

Pode imprimir não apenas

>> 0000000000 ... 000000111111111111111111111111 ...

Mas

>> 00000000000000000000000000000000000000000000 ... 

Sempre apenas '0'.

Como o Java Memory Model não exige 'transferência' do novo valor de 'sharedVar' do threadB para o thread principal sem relação heppens-before (início do thread, associação do thread, uso da palavra-chave 'synchonized', uso de variáveis ​​AtomicXXX, etc.).

Simplificando:
t1.join()retorna após a t1conclusão.
Ele não faz nada para encadear t1, exceto esperar que termine.
Naturalmente, o código a seguir t1.join()será executado somente após t1.join()retornos.

Da página de documentação do oracle em Junções

O joinmétodo permite que um thread aguarde a conclusão de outro.

Se t1 for um Threadobjeto cuja thread está em execução no momento,

t1.join() : causes the current thread to pause execution until t1's thread terminates.

Se t2 for um Threadobjeto cuja thread está em execução no momento,

t2.join(); causes the current thread to pause execution until t2's thread terminates.

joinAPI é uma API de baixo nível, que foi introduzida em versões anteriores do java. Muitas coisas foram alteradas ao longo de um período de tempo (especialmente com o lançamento do jdk 1.5) na frente da concorrência.

Você pode conseguir o mesmo com a API java.util.concurrent. Alguns dos exemplos são

1. Usando invokeAll onExecutorService
2. Usando CountDownLatch
3. Usando ForkJoinPool ou newWorkStealingPool de Executors(desde java 8)

Consulte as perguntas relacionadas ao SE:

aguarde até que todos os threads concluam seu trabalho em java

Para mim, o comportamento do Join () sempre foi confuso, porque eu estava tentando lembrar quem esperaria por quem. Não tente se lembrar dessa maneira.

Por baixo, é puro mecanismo wait () e notify ().

Todos sabemos que, quando chamamos wait () em qualquer objeto (t1), o objeto de chamada (main) é enviado para a sala de espera (estado bloqueado).

Aqui, o thread principal está chamando join () que é wait () sob as cobertas. Portanto, o thread principal aguardará até que seja notificado. A notificação é dada por t1 quando termina sua execução (conclusão do encadeamento).

Após receber a notificação, o main sai da sala de espera e continua sua execução.

Espero que ajude!

package join;

public class ThreadJoinApp {

    Thread th = new Thread("Thread 1") {
        public void run() {
            System.out.println("Current thread execution - " + Thread.currentThread().getName());
            for (int i = 0; i < 10; i++) {
                System.out.println("Current thread execution - " + Thread.currentThread().getName() + " at index - " + i);
            }
        }
    };

    Thread th2 = new Thread("Thread 2") {
        public void run() {
            System.out.println("Current thread execution - " + Thread.currentThread().getName());

            //Thread 2 waits until the thread 1 successfully completes.
            try {
            th.join();
            } catch( InterruptedException ex) {
                System.out.println("Exception has been caught");
            }

            for (int i = 0; i < 10; i++) {
                System.out.println("Current thread execution - " + Thread.currentThread().getName() + " at index - " + i);
            }
        }
    };

    public static void main(String[] args) {
        ThreadJoinApp threadJoinApp = new ThreadJoinApp();
        threadJoinApp.th.start();
        threadJoinApp.th2.start();
    }

    //Happy coding -- Parthasarathy S
}

digamos que nosso thread principal inicie os threads t1 e t2. Agora, quando t1.join () é chamado, o encadeamento principal se suspende até o encadeamento t1 morrer e, em seguida, recomeça. Da mesma forma, quando t2.join () é executado, o encadeamento principal se suspende novamente até o encadeamento t2 morrer e, em seguida, retomar.

Então é assim que funciona.

Além disso, o loop while não era realmente necessário aqui.