synchronized (this) {
 }

и он может выбирать, на каком объекте он синхронизируется. Синхронизированный метод может использовать толькоэтот' (или соответствующий экземпляр класса для синхронизированного метода класса)

Посмотрите эти ссылки, может быть, это даст вам лучший ответ.

связанную с объектом, на который указывает "этот", Когда мы используем этот блок, мы имеем в виду, что мы готовы подождать, пока поток, использующий этот монитор, не освободит его. Это имеет смысл использовать блокировку, если вы измените объект данных (объект 'переменные).

wait - заставляет текущий выполняющийся поток ждать, пока другой поток не вызовет метод notify или в течение указанной продолжительности.

кода. Только один поток одновременно может выполнять блок кода одновременно. Прочтите Раздел 2.2этот урок для дополнительной информации

synchronized (this) {

Приведенный ниже блок кода, по-видимому, использует (очень плохой) метод приостановки выполнения потока на определенный период времени.

    try {
        wait(endTime - System.currentTimeMillis());
    } catch (Exception e) {
    }

Кроме того, этоглотание» любые исключения, которые могут быть выброшены во время ожидания, что действительно очень непослушно.

synchronized (this)

синхронизация на уровне блоков.

Это означает, что наthis только объект, и только один поток может извинить закрытый блок за один раз.

Смотрите здесь для более подробного ответа:Синхронизация на уровне блоков

ное (это)» вовремя. Но это не всегда так! Рассмотрим код ниже. В моем коде я синхронизировал статический объект как блокировку, и все работает нормально. Когда я изменяю код для синхронизации с (этим), несколько потоков обращаются к коду одновременно, и это все портит. Будьте осторожны при синхронизации (это). Примечание. Код создает рекурсивные потоки, а затем отображает их в обратном порядке.

public class Project2 
{
    public static void main(String[] args) throws InterruptedException 
    {
        Object lock = new Object();
        Threads2 t1 = new Threads2(1);
        t1.setName("Thread 1");
        t1.start();
        Threads2.que.add(t1);
        t1.join();
    } 
}

public class Threads2 extends Thread
{
    //private final ArrayBlockingQueue<threads> que = new ArrayBlockingQueue<>(5);
    public static ArrayList<thread> que = new ArrayList<>(5);
    private volatile int i;
    private static volatile boolean locked = true;
    private static final Object lock = new Object();

    public Threads2(int i) 
    {        
        this.i = i;
    }
    @Override
    public void run()
    {   
        try
        {
            System.out.println("Thread " + i + ": created");       
            synchronized(lock)
            {
                i++;
            }       
            if(i <= 50)
            {
                Threads2 t = new Threads2(i);
                t.setName("Thread " + i);
                t.start();  
                que.add(Thread.currentThread());
            }
            else
            {
                Thread.currentThread().interrupt();
            }
            while(locked)
            {
                Thread.sleep(10000);
            }
        }
        catch(InterruptedException ex)
        {   
            synchronized(lock)
            {
                if(i >= 0)
                {
                    que.get(i-2).interrupt();
                    i--;
                    System.out.println(Thread.currentThread().getName());
                }    
            }       
        }       
    }    
}
</thread></threads>