Если я синхронизировал два метода в одном классе, могут ли они работать одновременно?

Если я синхронизировал два метода в одном и том же классе, могут ли они одновременно работать на одном и том же объекте ? например:

class A {
    public synchronized void methodA() {
        //method A
    }

    public synchronized void methodB() {
        // method B
    }
}

Я знаю, что не могу methodA()дважды запустить один и тот же объект в двух разных потоках. то же самое в methodB().

Но могу ли я работать methodB()в другом потоке, пока methodA()он еще работает? (тот же объект)

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

В примере methodA и methodB являются методами экземпляра (в отличие от статических методов). Установка synchronizedметода экземпляра означает, что поток должен получить блокировку («внутреннюю блокировку») для экземпляра объекта, к которому вызывается метод, прежде чем поток сможет начать выполнение любого кода в этом методе.

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

Чтобы два метода работали одновременно, они должны использовать разные блокировки, например:

class A {
    private final Object lockA = new Object();
    private final Object lockB = new Object();

    public void methodA() {
        synchronized(lockA) {
            //method A
        }
    }

    public void methodB() {
        synchronized(lockB) {
            //method B
        }
    }
}

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

Важно понимать, что, несмотря на то, что мы помещаем ключевое слово «synchronized» в отдельные методы, основная концепция - это внутренняя блокировка за кулисами.

Вот как учебник Java описывает отношения:

Синхронизация строится вокруг внутренней сущности, известной как внутренняя блокировка или блокировка монитора. (Спецификация API часто именует эту сущность просто как «монитор».) Внутренние блокировки играют роль в обоих аспектах синхронизации: обеспечение исключительного доступа к состоянию объекта и установление отношений «до и после», которые важны для видимости.

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

Целью блокировки является защита общих данных. Вы будете использовать отдельные блокировки, как показано в приведенном выше примере кода, только если каждая блокировка защищает разные элементы данных.

Поток Java получает блокировку уровня объекта, когда входит в экземпляр синхронизированного метода java, и получает блокировку уровня класса, когда входит в статический синхронизированный метод java.

В вашем случае методы (экземпляр) одного класса. Поэтому, когда поток входит в синхронизированный метод или блок Java, он получает блокировку (объект, для которого вызывается метод). Таким образом, нельзя одновременно вызывать другой метод для того же объекта, пока не будет завершен первый метод и не будет снята блокировка (для объекта).

В вашем случае вы синхронизировали два метода на одном экземпляре класса. Таким образом, эти два метода не могут выполняться одновременно в разных потоках одного и того же экземпляра класса А. Но они могут работать в разных экземплярах класса А.

class A {
    public synchronized void methodA() {
        //method A
    }
}

такой же как:

class A {
    public void methodA() {
        synchronized(this){
            // code of method A
        }
    }
}

Из документации оракула ссылка

Синхронизация методов имеет два эффекта:

Во-первых, невозможно выполнить два вызова синхронизированных методов для одного и того же объекта. Когда один поток выполняет синхронизированный метод для объекта, все остальные потоки, которые вызывают синхронизированные методы для того же блока объекта (приостанавливают выполнение), пока первый поток не завершится с объектом.

Во-вторых, при выходе из синхронизированного метода он автоматически устанавливает отношение «до и после» с любым последующим вызовом синхронизированного метода для того же объекта. Это гарантирует, что изменения состояния объекта видны всем потокам.

Это ответит на ваш вопрос: для того же объекта вы не можете вызвать второй синхронизированный метод, когда выполняется выполнение первого синхронизированного метода.

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

Думайте о своем коде как о следующем:

class A {

public void methodA() {
    synchronized(this){        
      //method A body
    }
}

public void methodB() {
    synchronized(this){
      // method B body
    }
}

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

Но можно ли запустить methodB () в другом потоке, пока methodA () еще работает? (тот же объект)

Действительно, это невозможно!

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

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

Ключевая идея с синхронизацией , который не тонет в легко то , что это будет иметь эффект , только если методы вызываются на одном объекте , например - это уже выделены ответы и комментарии -

Ниже приведен пример программы, чтобы четко определить то же самое -

public class Test {

public synchronized void methodA(String currentObjectName) throws InterruptedException {
    System.out.println(Thread.currentThread().getName() + "->" +currentObjectName + "->methodA in");
    Thread.sleep(1000);
    System.out.println(Thread.currentThread().getName() + "->" +currentObjectName + "->methodA out");
}

public synchronized void methodB(String currentObjectName)  throws InterruptedException {
    System.out.println(Thread.currentThread().getName() + "->" +currentObjectName + "->methodB in");
    Thread.sleep(1000);
    System.out.println(Thread.currentThread().getName() + "->" +currentObjectName + "->methodB out");
}

public static void main(String[] args){
    Test object1 = new Test();
    Test object2 = new Test();
    //passing object instances to the runnable to make calls later
    TestRunner runner = new TestRunner(object1,object2);
    // you need to start atleast two threads to properly see the behaviour
    Thread thread1 = new Thread(runner);
    thread1.start();
    Thread thread2 = new Thread(runner);
    thread2.start();
}
}

class TestRunner implements Runnable {
Test object1;
Test object2;

public TestRunner(Test h1,Test h2) {
    this.object1 = h1;
    this.object2 = h2;
}

@Override
public void run() {
    synchronizedEffectiveAsMethodsCalledOnSameObject(object1);
    //noEffectOfSynchronizedAsMethodsCalledOnDifferentObjects(object1,object2);
}

// this method calls the method A and B with same object instance object1 hence simultaneous NOT possible
private void synchronizedEffectiveAsMethodsCalledOnSameObject(Test object1) {
    try {
        object1.methodA("object1");
        object1.methodB("object1");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

// this method calls the method A and B with different object instances object1 and object2 hence simultaneous IS possible
private void noEffectOfSynchronizedAsMethodsCalledOnDifferentObjects(Test object1,Test object2) {
    try {
        object1.methodA("object1");
        object2.methodB("object2");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
}

Обратите внимание на разницу в выводе о том, как одновременный доступ разрешен, как и ожидалось, если методы вызываются для разных экземпляров объекта.

Ouput с noEffectOfSynchronizedAsMethodsCalledOnDifferentObjects () прокомментированных -The выход в порядке Methoda в> Methoda Out .. methodB в> methodB Out

и Ouput с прокомментированным synchronizedEffectiveAsMethodsCalledOnSameObject () - выходные данные показывают одновременный доступ метода A Thread1 и Thread0 в выделенном разделе -

Увеличение количества потоков сделает это еще более заметным.

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

Да, они могут запускать оба потока одновременно. Если вы создаете 2 объекта класса, так как каждый объект содержит только одну блокировку, и каждый синхронизированный метод требует блокировки. Поэтому, если вы хотите запустить одновременно, создайте два объекта, а затем попробуйте запустить, используя ссылку на этот объект.

Вы синхронизируете его с объектом, а не с классом. Таким образом, они не могут работать одновременно на одном и том же объекте

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