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

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

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

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

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

Two different Threads executing a common synchronized method on the single object, since the object is same, when one thread uses it with synchronized method, it will have to verify the lock, if the lock is enabled, this thread will go to wait state, if lock is disabled then it can access the object, while it will access it will enable the lock and will release the lock only when it's execution is complete. when the another threads arrives, it will verify the lock, since it is enabled it will wait till the first thread completes his execution and releases the lock put on the object, once the lock is released the second thread will gain access to the object and it will enable the lock until it's execution. so the execution will not be not concurrent, both threads will execute one by one, when both the threads use the synchronized method on different objects, they will run concurrently.

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

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