不，这是不可能的，如果这是可能的，那么这两个方法可以同时更新同一个变量，这很容易破坏数据。

你同步的是对象而不是类。所以它们不能同时在同一物体上运行

在你的例子中，你在同一个类实例上同步了两个方法。所以，这两个方法不能同时运行在类A的同一个实例的不同线程上，但是它们可以运行在不同的类A实例上。

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

请注意，如果在不同的对象实例上调用方法，则输出中允许同时访问的方式是不同的。

输出带有noEffectOfSynchronizedAsMethodsCalledOnDifferentObjects()注释-输出是in order methodA in > methodA Out ..methodB in > methodB Out

和输出synchronizedEffectiveAsMethodsCalledOnSameObject()注释- 输出显示在突出显示的部分-中，Thread1和Thread0同时访问方法da

增加线程数将使其更加明显。