清楚地说，静态同步和非静态同步方法都可能同时或并发地运行，因为一个有对象级锁，另一个有类级锁。

在示例中，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.

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

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

class A {

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

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

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

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

的确，这是不可能的!

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

从oracle文档链接

使方法同步有两个效果:

First, it is not possible for two invocations of synchronized methods on the same object to interleave. When one thread is executing a synchronized method for an object, all other threads that invoke synchronized methods for the same object block (suspend execution) until the first thread is done with the object. Second, when a synchronized method exits, it automatically establishes a happens-before relationship with any subsequent invocation of a synchronized method for the same object. This guarantees that changes to the state of the object are visible to all threads

这将回答您的问题:在同一个对象上，当第一个同步方法正在执行时，您不能调用第二个同步方法。

看看这个文档页，了解内在锁和锁的行为。

清楚地说，静态同步和非静态同步方法都可能同时或并发地运行，因为一个有对象级锁，另一个有类级锁。

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