blocks|key|3032035|text|这两种方法锁定相同的监视器。因此，您不能从不同的线程同时在同一对象上执行它们(两个方法中的一个会阻塞，直到另一个完成为止)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3032036|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Both methods lock the same monitor. Therefore, you can't simultaneously execute them on the same object from different threads (one of the two methods will block until the other is finished).

blocks|key|2819385|text|您正在对象上同步它，而不是在类上。因此它们不能在同一对象上同时运行|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2819386|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You are synchronizing it on object not on class. So they cant run simultaneously on the same object

blocks|key|3032090|text|在本例中，methodA和methodB是实例方法(与静态方法相对)。将synchronized放在实例方法上意味着线程必须先获取调用该方法的对象实例上的锁(“内在锁”)，然后线程才能开始执行该方法中的任何代码。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3032091|如果有两个不同的实例方法被标记为已同步，并且不同的线程在同一对象上同时调用这两个方法，则这些线程将争用相同的锁。一旦一个线程获得了锁，所有其他线程都会被该对象上的所有同步实例方法拒之门外。|3032092|为了让这两个方法同时运行，它们必须使用不同的锁，如下所示：|3032093|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
++++++++}
++++}
}|code-block|syntax|javascript|3032094|其中，同步块语法允许指定执行线程需要获取其上的固有锁以进入块的特定对象。|3032095|需要理解的重要一点是，尽管我们将“同步”关键字放在单个方法上，但核心概念是幕后的内在锁。|3032096|下面是the+Java+tutorial对这种关系的描述：|3032097|3032098|同步是围绕称为固有锁或监视器锁的内部实体构建的。(+API规范通常将此实体简称为“监视器”。)内部锁在同步的两个方面都起着作用:强制独占访问对象的状态和建立对可见性至关重要的发生前关系。|blockquote|3032099|3032100|每个对象都有一个关联的内在锁。按照惯例，需要独占和一致访问对象字段的线程必须在访问对象字段之前获取对象的固有锁，然后在使用完它们后释放固有锁。线程在获得锁和释放锁之间拥有固有锁。只要一个线程拥有一个内部锁，其他线程就不能获得相同的锁。当另一个线程试图获取锁时，它将阻塞。|3032101|3032102|锁定的目的是保护共享数据。只有当每个锁保护不同的数据成员时，才会使用上面的示例代码中所示的单独锁。|3032103|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html^0|10|C|0|0|0|0|0|0|3|H|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1F|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1G|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1H|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1I|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1J|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|1K|8|@]|D|@$9|1L|A|1M|1|1N]]|E|$]]|$1|U|3|-4|5|6|7|1O|8|@]|D|@]|E|$]]|$1|V|3|W|5|X|7|1P|8|@]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|Z|3|10|5|6|7|1R|8|@]|D|@]|E|$]]|$1|11|3|-4|5|6|7|1S|8|@]|D|@]|E|$]]|$1|12|3|13|5|6|7|1T|8|@]|D|@]|E|$]]|$1|14|3|-4|5|6|7|1U|8|@]|D|@]|E|$]]]|15|$16|$5|17|18|19|E|$1A|1B]]]]

In the example methodA and methodB are instance methods (as opposed to static methods). Putting <code>synchronized</code> on an instance method means that the thread has to acquire the lock (the &quot;intrinsic lock&quot;) on the object instance that the method is called on before the thread can start executing any code in that method.
If you have two different instance methods marked synchronized and different threads are calling those methods concurrently on the same object, those threads will be contending for the same lock. Once one thread gets the lock all other threads are shut out of all synchronized instance methods on that object.
In order for the two methods to run concurrently they would have to use different locks, like this:
<pre><code>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
 }
 }
}
</code></pre>
where the synchronized block syntax allows specifying a specific object that the executing thread needs to acquire the intrinsic lock on in order to enter the block.
The important thing to understand is that even though we are putting a &quot;synchronized&quot; keyword on individual methods, the core concept is the intrinsic lock behind the scenes.
Here is how <a href="https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html" rel="noreferrer">the Java tutorial</a> describes the relationship:
<blockquote>
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 &quot;monitor.&quot;) 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.
</blockquote>
The purpose of locking is to protect shared data. You would use separate locks as shown in the example code above only if each lock protected different data members.

blocks|key|2819488|text|Java+Thread在进入实例同步java方法时获取对象级锁，在进入静态同步java方法时获取类级别锁。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2819489|在您的示例中，这些方法(实例)属于同一个类。因此，每当线程进入java同步方法或块时，它都会获得一个锁(调用该方法的对象)。因此，在完成第一个方法并释放lock(on+object)之前，不能在同一对象上同时调用其他方法。|2819490|entityMap^0|E|2|R|4|Z|2|1C|5|0|0|33|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|I|$]]

Java Thread acquires an object level lock when it enters into an instance synchronized java method and acquires a class level lock when it enters into static synchronized java method.

In your case, the methods(instance) are of same class. So when ever a thread enters into java synchronized method or block it acquires a lock(the object on which the method is called). So other method cannot be called at the same time on the same object until the first method is completed and lock(on object) is released.

blocks|key|2819533|text|在本例中，您在类的同一实例上同步了两个方法。因此，这两个方法不能同时在类A的同一实例的不同线程上运行，但它们可以在不同的类A实例上同时运行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2819534|class+A+{
++++public+synchronized+void+methodA()+{
++++++++//method+A
++++}
}|code-block|syntax|javascript|2819535|与以下内容相同：|2819536|class+A+{
++++public+void+methodA()+{
++++++++synchronized(this){
++++++++++++//+code+of+method+A
++++++++}
++++}
}|2819537|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

In your case you synchronized two method on the same instance of class. So, these two methods can't run simultaneously on different thread of the same instance of class A. But they can on different class A instances.

<pre><code>class A {
 public synchronized void methodA() {
 //method A
 }
}
</code></pre>

is the same as:

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

blocks|key|3032201|text|为了清楚起见，静态同步方法和非静态同步方法都可以同时或并发运行，因为其中一个方法具有对象级锁和其他类级锁。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3032202|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Just to all clarity, It’s possible that both static synchronized and non static synchronized method can run simultaneously or concurrently because one is having object level lock and other class level lock.

blocks|key|3032232|text|来自oracle+documentation+link|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3032233|使方法同步有两个效果：|3032234|3032235|首先，在同一对象上两次调用同步方法是不可能交错的。当一个线程正在执行对象的同步方法时，调用同一对象的同步方法的所有其他线程都会阻塞(暂停执行)，直到第一个线程处理完该对象为止。|blockquote|3032236|3032237|其次，当同步的方法退出时，它会自动与同一对象的同步方法的任何后续调用建立一种先于发生的关系。这保证了对对象状态的更改对所有线程都可见。|3032238|3032239|这将回答您的问题:在同一对象上，当第一个同步的方法正在执行时，您不能调用第二个同步的方法。|3032240|请查看文档page以了解内部锁和锁行为。|3032241|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html|1|https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html^0|N|4|0|0|0|0|0|0|0|0|0|5|4|1|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|6|7|15|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|16|8|@]|9|@]|C|$]]|$1|G|3|H|5|I|7|17|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|18|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|19|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]|$1|N|3|O|5|6|7|1B|8|@]|9|@]|C|$]]|$1|P|3|Q|5|6|7|1C|8|@]|9|@$A|1D|B|1E|1|1F]]|C|$]]|$1|R|3|-4|5|6|7|1G|8|@]|9|@]|C|$]]]|S|$T|$5|U|V|W|C|$X|Y]]|Z|$5|U|V|W|C|$X|10]]]]

From oracle documentation <a href="https://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html" rel="noreferrer">link</a>
Making methods synchronized has two effects:
<blockquote>
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
</blockquote>
This will answer your question: On same object, You can't call second synchronized method when first synchronized method execution is in progress.
Have a look at this documentation <a href="https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html" rel="noreferrer">page</a> to understand intrinsic locks and lock behavior.

blocks|key|3032293|text|两个不同的线程在单个对象上执行公共的同步方法，因为对象是相同的，当一个线程将它与同步方法一起使用时，它将不得不验证锁，如果锁被启用，这个线程将进入等待状态，如果锁被禁用，那么它可以访问对象，而它将访问它将启用锁，并且只有在它执行完成时才会释放锁。当另一个线程到达时，它将验证锁，因为它被启用，它将等待第一个线程完成它的执行，并释放放在对象上的锁，一旦锁被释放，第二个线程将获得对象的访问权，它将启用该锁，直到它执行。因此执行不会是并发的，两个线程将一个接一个地执行，当两个线程在不同的对象上使用同步方法时，它们将并发运行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3032294|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

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.

blocks|key|194717|text|将您的代码想象为以下代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|194718|class+A+{

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

public+void+methodB()+{
++++synchronized(this){
++++++//+method+B+body
++++}
}|code-block|syntax|javascript|194719|因此，在方法级别上的synchronized仅仅意味着已同步(This)。如果任何线程运行此类的方法，它将在开始执行之前获得锁，并持有该锁，直到该方法的执行完成。|194720|194721|但是当methodA()还在运行时，我可以在不同的线程上运行methodB()吗？(同一对象)|blockquote|194722|194723|194724|事实上，这是不可能的！|194725|因此，多个线程将不能同时在同一对象上运行任何数量的同步方法。|194726|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|Y|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|11|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|12|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|T|$]]

Think of your code as the below one:

<pre><code>class A {

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

public void methodB() {
 synchronized(this){
 // method B body
 }
}
</code></pre>

So, synchronized on method level simply means synchronized(this).
if any thread runs a method of this class, it would obtain the lock before starting the execution and hold it until the execution of the method is finished.

<blockquote>
 But can I run methodB() on different thread while methodA() is still
 running? (same object)
</blockquote>

Indeed, it is not possible!

Hence, multiple threads will not able to run any number of synchronized methods on the same object simultaneously.

blocks|key|2819730|text|不，这是不可能的，如果这是可能的，那么两种方法可以同时更新相同的变量，这很容易破坏数据。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2819731|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

No it is not possible, if it were possible then both method could be updating same variable simultaneously which could easily corrupt the data.

blocks|key|194407|text|同步的key思想不容易理解，它只有在相同的object实例上调用方法时才有效-它已经在答案和评论中突出显示-|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|194408|下面的示例程序是清楚地指出相同的-|194409|public+class+Test+{

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

public+synchronized+void+methodB(String+currentObjectName)++throws+InterruptedException+{
++++System.out.println(Thread.currentThread().getName()+%2B+"->"+%2BcurrentObjectName+%2B+"->methodB+in");
++++Thread.sleep(1000);
++++System.out.println(Thread.currentThread().getName()+%2B+"->"+%2BcurrentObjectName+%2B+"->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();
++++}
}
}|code-block|syntax|javascript|194410|请注意，如果在不同的对象实例上调用方法，则允许同时访问的输出与预期的不同。|194411|output+with+noEffectOfSynchronizedAsMethodsCalledOnDifferentObjects()+注释+-the输出的顺序是methodA+in+>+methodA+Out+..methodB+in+>+methodB+Out|194412|📷|atomic|194413|​|194414|使用synchronizedEffectiveAsMethodsCalledOnSameObject()+注释的输出-输出在突出显示的部分中显示Thread1和Thread0对methodA的同时访问-|194415|194416|194417|194418|增加线程的数量将使其更加引人注目。|194419|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/62de864e2f7c0bca94c45bfb9bf7d92c.png|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/fd77d2c84523cb9c0926b6255709fd50.png^0|3|3|I|9|0|0|0|0|1Y|2|0|0|1|0|0|0|1H|5|0|0|0|1|1|0|0|0^^$0|@$1|2|3|4|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1I|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1J|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1K|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1L|8|@$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|S|7|1O|8|@]|D|@$9|1P|A|1Q|1|1R]]|E|$]]|$1|T|3|U|5|6|7|1S|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|1T|8|@$9|1U|A|1V|B|C]]|D|@]|E|$]]|$1|X|3|U|5|6|7|1W|8|@]|D|@]|E|$]]|$1|Y|3|R|5|S|7|1X|8|@]|D|@$9|1Y|A|1Z|1|20]]|E|$]]|$1|Z|3|U|5|6|7|21|8|@]|D|@]|E|$]]|$1|10|3|11|5|6|7|22|8|@]|D|@]|E|$]]|$1|12|3|-4|5|6|7|23|8|@]|D|@]|E|$]]]|13|$14|$5|15|16|17|E|$18|19|1A|-4]]|1B|$5|15|16|17|E|$18|1C|1A|-4]]]]

The key idea with synchronizing which does not sink in easily is that it will have effect only if methods are called on the same object instance - it has already been highlighted in the answers and comments - 

Below sample program is to clearly pinpoint the same - 

<pre><code>public class Test {

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

public synchronized void methodB(String currentObjectName) throws InterruptedException {
 System.out.println(Thread.currentThread().getName() + "-&gt;" +currentObjectName + "-&gt;methodB in");
 Thread.sleep(1000);
 System.out.println(Thread.currentThread().getName() + "-&gt;" +currentObjectName + "-&gt;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();
 }
}
}
</code></pre>

Notice the difference in output of how simultaneous access is allowed as expected if methods are called on different object instances.

Ouput with noEffectOfSynchronizedAsMethodsCalledOnDifferentObjects() commented -the output is in order methodA in > methodA Out .. methodB in > methodB Out
<a href="https://i.stack.imgur.com/2FOTF.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/2FOTF.png" alt="Ouput with *noEffectOfSynchronizedAsMethodsCalledOnDifferentObjects()* commented "></a>

and Ouput with synchronizedEffectiveAsMethodsCalledOnSameObject() commented - 
the output shows simultaneous access of methodA by Thread1 and Thread0 in highlighted section - 

<a href="https://i.stack.imgur.com/pCcUJ.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/pCcUJ.png" alt="Ouput with *synchronizedEffectiveAsMethodsCalledOnSameObject()* commented "></a>

Increasing the number of threads will make it even more noticeable.

blocks|key|3032514|text|是的，它们可以同时运行两个线程。如果你创建了2个类的对象，因为每个对象只包含一个锁，并且每个同步的方法都需要锁。因此，如果您希望同时运行，请创建两个对象，然后尝试使用这些对象引用来运行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3032515|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Yes, they can run simultaneously both threads. If you create 2 objects of the class as each object contains only one lock and every synchronized method requires lock.
So if you want to run simultaneously, create two objects and then try to run by using of those object reference.

If I synchronized two methods on the same class, can they run simultaneously on the same object? For example:
<pre><code>class A {
 public synchronized void methodA() {
 //method A
 }

 public synchronized void methodB() {
 // method B
 }
}
</code></pre>
I know that I can't run <code>methodA()</code> twice on same object in two different threads. same thing in <code>methodB()</code>.
But can I run <code>methodB()</code> on different thread while <code>methodA()</code> is still running? (same object)

If I synchronized two methods on the same class, can they run simultaneously?

Java

如果我在同一个类上同步了两个方法，它们能在同一个对象上同时运行吗？例如：class A {    public synchronized void methodA() {        //method A    }    public synchronized void methodB() {        // m...

问如果我在同一个类上同步了两个方法，它们能同时运行吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如果我在同一个类上同步了两个方法，它们能同时运行吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如果我在同一个类上同步了两个方法，它们能同时运行吗？
EN