Отслеживание этой многопоточной программы [дубликат]

Совместимость Java в книжных состояниях практики - Reentrancy means that locks are acquired on a per-thread rather than per-invocation basis.

Позвольте мне объяснить, что именно это означает. Прежде всего Внутренние замки являются реентерабельными по своей природе. Способ реинтеграции достигается путем поддержания счетчика количества приобретенных замков и владельца замка. Если счетчик равен 0, и владелец не связан с ним, означает, что блокировка не удерживается нитью. Когда поток получает блокировку, JVM записывает владельца и устанавливает счетчик равным 1. Если тот же поток пытается снова получить блокировку, счетчик увеличивается, а при наличии существующего потока синхронизированный счетчик блоков уменьшается. Когда счетчик достигнет 0, блокировка будет высвобождена.

Простым примером будет -

public class Test {
    public synchronized void performTest() {
       //...
    }
}

public class CustomTest extends Test {
    public synchronized void performTest() {
       //...
       super.performTest();
    }
}

без повторного включения в тупик.

Представьте себе что-то вроде этого:

function A():
   lock (X)
       B()
   unlock (X)

function B():
    A()

Теперь мы вызываем A. Происходит следующее:

• Вводим A, блокируя X
• Мы входим в B
• . Мы снова вводим A, снова блокируя X

. Поскольку мы никогда не выходили из первого вызова A, X все еще заблокирован. Это называется повторным входом - пока функция A еще не вернулась, функция A вызывается снова. Если A полагается на какое-то глобальное статическое состояние, это может привести к ошибке «повторного входа», где до того, как статическое состояние будет очищено от выхода функции, функция будет запущена снова, а половина вычисленных значений столкнется с началом второй вызов.

В этом случае мы сталкиваемся с блокировкой, которую мы уже удерживаем. Если замок заново узнает, он поймет, что мы являемся тем же самым потоком, который удерживает блокировку уже и пропустим. В противном случае он будет тупик навсегда - он будет ждать блокировки, которую он уже удерживает.

В java, lock и synchronized являются повторными входами - если блокировка удерживается нитью, и нить пытается переустановить один и тот же замок, это разрешено. Поэтому, если бы мы написали вышеописанный псевдокод в Java, он бы не зашел в тупик.

Это означает, что когда поток имеет блокировку, он может входить в заблокированную секцию кода столько раз, сколько нужно. Поэтому, если у вас есть синхронизированный раздел кода, такой как метод, только тот поток, который достиг блокировки, может вызывать этот метод, но может вызывать этот метод столько раз, сколько захочет, включая любой другой код, хранящийся в той же блокировке. Это важно, если у вас есть один метод, который вызывает другой метод, и оба синхронизируются одной и той же блокировкой. Если это не так. Второй вызов метода будет заблокирован. Это также относится к рекурсивным вызовам методов.

public void methodA()
{
     // other code
     synchronized(this)
     {
          methodB();
     } 
}

public void methodB()
{
     // other code
     syncrhonized(this)
     {
          // it can still enter this code    
     }

}