将您的代码想像如下所示:

class A {

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

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

因此，在方法级别上同步仅仅意味着同步(这个)。 如果任何线程运行该类的方法，它将在开始执行之前获得锁，并持有它直到方法执行完成。

但是我可以在不同的线程上运行methodB()而methodA()仍然是 跑步吗?(同一对象)

的确，这是不可能的!

因此，多个线程将不能同时在同一个对象上运行任意数量的同步方法。

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

在示例中，methodA和methodB是实例方法(与静态方法相反)。将synchronized放在实例方法上意味着线程必须在线程开始执行该方法中的任何代码之前获得调用该方法的对象实例上的锁(“固有锁”)。

如果您有两个标记为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教程描述的关系:

Synchronization is built around an internal entity known as the intrinsic lock or monitor lock. (The API specification often refers to this entity simply as a "monitor.") Intrinsic locks play a role in both aspects of synchronization: enforcing exclusive access to an object's state and establishing happens-before relationships that are essential to visibility. Every object has an intrinsic lock associated with it. By convention, a thread that needs exclusive and consistent access to an object's fields has to acquire the object's intrinsic lock before accessing them, and then release the intrinsic lock when it's done with them. A thread is said to own the intrinsic lock between the time it has acquired the lock and released the lock. As long as a thread owns an intrinsic lock, no other thread can acquire the same lock. The other thread will block when it attempts to acquire the lock.

锁定的目的是保护共享数据。只有当每个锁保护不同的数据成员时，才可以使用上面示例代码中所示的单独锁。

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

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

等于:

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

Java线程在进入实例同步Java方法时获得一个对象级锁，在进入静态同步Java方法时获得一个类级锁。

在您的示例中，方法(实例)属于同一个类。因此，当一个线程进入java synchronized方法或块时，它会获得一个锁(方法被调用的对象)。因此，在第一个方法完成并释放lock(on object)之前，不能在同一对象上同时调用其他方法。

是的，它们可以同时运行两个线程。如果创建类的2个对象，每个对象只包含一个锁，并且每个同步方法都需要锁。 如果你想同时运行，创建两个对象然后使用那些对象引用来运行。