Что означает этот код присоединения к потоку?

В этом коде, что означают два соединения и разрыв? t1.join()вызывает, t2чтобы остановить, пока не t1закончится?

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();
   }
}

Что означает этот код присоединения к потоку?

Цитировать из Thread.join()метода Javadocs :

join() Ждет, когда эта нить умрет.

Существует поток, который выполняет ваш пример кода, который, вероятно, является основным потоком .

1. Основной поток создает и запускает t1и t2тему. Два потока начинают работать параллельно.
2. Основной поток вызывает t1.join()ожидание завершения t1потока.
3. Поток t1завершается, и t1.join()метод возвращается в основной поток. Обратите внимание, что t1он уже мог закончиться до join()того, как будет выполнен вызов, и в этом случае join()вызов будет немедленно возвращен.
4. Основной поток вызывает t2.join()ожидание завершения t2потока.
5. Поток t2завершается (или мог завершиться раньше, чем t1поток), и t2.join()метод возвращается в основной поток.

Важно понимать, что потоки t1and t2работали параллельно, но основному потоку, который их запустил, нужно дождаться их завершения, прежде чем он сможет продолжить. Это обычная модель. Кроме того, t1и / или t2мог завершиться до того, как основной поток вызовет join()их. Если это так, то join()не будет ждать, но вернется немедленно.

t1.join() означает, что t2 останавливается до тех пор, пока не закончится t1?

Нет. Основной вызывающий поток t1.join()прекратит работу и будет ждать t1его завершения. Поток t2работает параллельно и не подвержен влиянию t1илиt1.join() вызову вообще.

С точки зрения try / catch, join()throws InterruptedExceptionозначает, что основной поток, который вызывает, join()может сам быть прерван другим потоком.

while (true) {

Наличие соединений в whileцикле - странная картина. Как правило, вы выполняете первое соединение, а затем второе соединение, обрабатывая InterruptedExceptionсоответственно в каждом случае. Не нужно их зацикливать.

Это любимый вопрос интервью на 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()означает, что t1 говорит что-то вроде « Я хочу закончить первым ». То же самое в случае с t2. Независимо от того, кто начал t1или в t2каком потоке (в данном случае это mainметод), main будет ждать, пока t1и не t2завершит свою задачу.

Тем не менее, важно отметить, t1и t2сами могут работать параллельно, независимо от последовательности вызовов соединения на t1и t2. Это main/daemonнить, которая должна ждать .

join()означает ожидание завершения потока. Это метод блокирования. Ваш основной поток (тот, который выполняет join()) будет ждать на t1.join()линии, пока не завершит t1свою работу, а затем будет делать то же самое для t2.join().

Одна картинка стоит тысячи слов.

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

Надеюсь на полезное, для более подробной информации нажмите здесь

Когда поток tA вызывает tB.join (), его причины не только ждут смерти tB или самого прерывания tA, но и создают случайное отношение между последним оператором в tB и следующим оператором после tB.join () в потоке tA.

Все действия в потоке происходят до того, как любой другой поток успешно вернется из join () в этом потоке.

Значит программа

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);
    }
}

Всегда печатать

>> 1111111111111111111111111 ...

Но программа

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);
    }
}

Можно печатать не только

>> 0000000000 ... 000000111111111111111111111111 ...

Но

>> 00000000000000000000000000000000000000000000 ... 

Всегда только «0».

Поскольку Java Memory Model не требует «передачи» нового значения sharedVar из threadB в основной поток без отношения heppens-before (начало потока, объединение потока, использование ключевого слова synchronized, использование переменных AtomicXXX и т. Д.).

Проще говоря:
t1.join()возвращается после t1завершения.
Он ничего не делает с потоком t1, кроме как дождаться его завершения.
Естественно, следующий код t1.join()будет выполняться только после t1.join()возврата.

Со страницы документации оракула в Joins

joinМетод позволяет один потоку ждать завершения других.

Если t1 является Threadобъектом, поток которого выполняется в данный момент,

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

Если t2 является Threadобъектом, поток которого выполняется в данный момент,

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

joinAPI - это API низкого уровня, который был представлен в более ранних версиях Java. Многие вещи были изменены в течение определенного периода времени (особенно с выпуском jdk 1.5) на фронте параллелизма.

Вы можете достичь того же с помощью API java.util.concurrent. Некоторые из примеров

1. Использование invokeAll наExecutorService
2. Использование CountDownLatch
3. Используя ForkJoinPool или newWorkStealingPool из Executors(начиная с Java 8)

Обратитесь к связанным вопросам SE:

ждать, пока все потоки не закончат свою работу в Java

Для меня поведение Join () всегда сбивало с толку, потому что я пытался вспомнить, кто кого будет ждать. Не пытайтесь запомнить это таким образом.

Внизу это чистый механизм wait () и notify ().

Все мы знаем, что когда мы вызываем wait () для любого объекта (t1), вызывающий объект (main) отправляется в комнату ожидания (состояние Blocked).

Здесь основной поток вызывает join (), который wait () под прикрытием. Таким образом, основной поток будет ждать, пока не получит уведомление. Уведомление дается t1, когда он заканчивает свою работу (завершение потока).

После получения уведомления главный выходит из комнаты ожидания и приступает к его исполнению.

Надеюсь, поможет!

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
}

скажем, наш основной поток запускает потоки t1 и t2. Теперь, когда вызывается t1.join (), основной поток приостанавливает себя до тех пор, пока поток t1 не умирает, а затем возобновляет себя. Точно так же, когда t2.join () выполняется, основной поток снова приостанавливает себя, пока поток t2 не умирает, а затем возобновляет работу.

Итак, вот как это работает.

Кроме того, цикл while здесь не нужен.