Java wait()/join(): Защо това не блокира?

Методът join() вътрешно извиква wait(), което ще доведе до освобождаване на заключването (на обект Thread).

Вижте кода на join() по-долу:

public final synchronized void join(long millis) 
    throws InterruptedException {
    ....
    if (millis == 0) {
       while (isAlive()) {
         wait(0);  //ends up releasing lock
       }
    }
    ....
}

Причина, поради която вашият код вижда това и не се вижда като цяло:: Причината, поради която кодът ви вижда това, а не, не се наблюдава като цяло, е защото методът join() waits() на Thread обекти следователно се отказва от заключването на самия обект Thread и тъй като вашият метод run() също се синхронизира на същия обект Thread, виждате този иначе неочакван сценарий.

Реализацията на Thread.join използва изчакване, което освобождава заключването си, поради което не пречи на другата нишка да получи заключването.

Ето описание стъпка по стъпка на това, което се случва в този пример:

Стартирането на нишката MyThread в основния метод води до нова нишка, изпълняваща метода за изпълнение на MyThread. Основната нишка заспива за цяла секунда, давайки на новата нишка достатъчно време да стартира и да получи заключването на обекта MyThread.

След това новата нишка може да влезе в метода на изчакване и да освободи заключването си. В този момент новата нишка преминава в латентно състояние, тя няма да се опита да получи ключалката отново, докато не бъде събудена. Нишката все още не се връща от метода на изчакване.

В този момент основната нишка се събужда от спящ режим и извиква изключване на обекта MyThread. Няма проблем с придобиването на заключването, защото новата нишка го освободи, след като започна да чака. Извикванията на основната нишка уведомяват сега. Влизайки в метода за присъединяване, основната нишка проверява дали новата нишка е все още жива, след което изчаква, освобождавайки заключването.

Уведомлението се случва, след като основната нишка освободи заключването. Тъй като новата нишка е била в режим на изчакване за заключване по времето, когато главната нишка е наречена notify, новата нишка получава известието и се събужда. Той може да получи заключването, да напусне метода на изчакване и да завърши изпълнението на метода run, като накрая освободи заключването.

Прекратяването на новата нишка кара всички нишки, чакащи нейното заключване, да получат известие. Това събужда основната нишка, тя може да получи заключването и да провери дали новата нишка е мъртва, след което ще излезе от метода за присъединяване и ще завърши изпълнението.

/**
 * Waits at most <code>millis</code> milliseconds for this thread to 
 * die. A timeout of <code>0</code> means to wait forever. 
 *
 * @param      millis   the time to wait in milliseconds.
 * @exception  InterruptedException if any thread has interrupted
 *             the current thread.  The <i>interrupted status</i> of the
 *             current thread is cleared when this exception is thrown.
 */
public final synchronized void join(long millis) 
throws InterruptedException {
long base = System.currentTimeMillis();
long now = 0;

if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
}

if (millis == 0) {
    while (isAlive()) {
    wait(0);
    }
} else {
    while (isAlive()) {
    long delay = millis - now;
    if (delay <= 0) {
        break;
    }
    wait(delay);
    now = System.currentTimeMillis() - base;
    }
}
}

За да допълня другите отговори: не виждам споменаване на join() освобождаване на ключалки в API-документацията, така че това поведение всъщност е специфично за изпълнението.

Научете се от това:

• не подкласирайте Thread, вместо това използвайте имплементация Runnable, предадена на вашия обект на нишка.
• не синхронизирайте/изчаквайте/уведомявайте за обекти, които не „притежавате“, напр. където не знаете кой друг може да синхронизира/изчака/уведоми за него.