当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法? 博客分类： JDK thread

当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

日前在网上见到一道Java笔试试题，如题所述。给出的答案如下：

答：不能，一个对象的一个synchronized方法只能由一个线程访问。

本人认为有些所答非所问。故写了两个demo进行测试。发现答案要分三种情况讨论。

• 情况一：

当一个线程进入一个对象的一个synchronized方法后，其它线程访问该对象的非同步方法。
代码如下：

package com.mutithreading.Object; 

public class InvokedObject
{
    public synchronized void synchronizedMethod()
    {
       System.out.println("Invoked synchronizedMethod !") ;
       try {
           Thread.sleep(10000) ;
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
    }

    public void generalMethod()
    {
       System.out.println("Invoked generalMethod ...") ;
    }
}

package com.mutithreading.threads;
import com.mutithreading.Object.InvokedObject;

public class ThreadOne implements Runnable {
    private InvokedObject object ;
    public ThreadOne(InvokedObject object)
    {
       this.object = object ;
    }
    public void run() {
       object.synchronizedMethod() ;
    }
}

package com.mutithreading.threads;

import com.mutithreading.Object.InvokedObject;
public class ThreadTwo implements Runnable {
    private InvokedObject object ;
    public ThreadTwo(InvokedObject object)
    {
       this.object = object ;
    }
    public void run() {
       // TODO Auto-generated method stub
       object.generalMethod() ;
    }
}

package com.mutithreading.client;
import com.mutithreading.Object.InvokedObject;
import com.mutithreading.threads.ThreadOne;
import com.mutithreading.threads.ThreadTwo;

public class Client {
    public static void main(String[] args) {
    InvokedObject object = new InvokedObject() ;
    ThreadOne one = new ThreadOne(object) ;
    ThreadTwo two = new ThreadTwo(object) ;
    Thread threadOne = new Thread(one) ;
    Thread threadTwo = new Thread(two) ;
 
    threadOne.start() ;
    threadTwo.start() ;
}
}

运行结果：

一个线程在访问一个对象的同步方法时，另一个线程可以同时访问这个对象的非同步方法。

• 情况二：

当一个线程进入一个对象的一个synchronized方法后，其它线程也访问该同步方法。


运行结果：

一个线程在访问一个对象的同步方法时，另一个线程不能同时访问这个同步方法。（代码略）

• 情况三：

当一个线程进入一个对象的一个synchronized方法后，其它线程同时访问该对象的另一个同步方法。

此处仅给出对InvokedObject类做出的修改代码：

package com.mutithreading.Object;
public class InvokedObject
{
    public synchronized void synchronizedMethod1()
    {
       System.out.println("Invoked synchronizedMethod1 !") ;
       try {
           Thread.sleep(10000) ;
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
    }   
    public synchronized void synchronizedMethod2()
    {
       System.out.println("Invoked synchronizedMethod2 !") ;
    }
}

运行结果：

一个线程在访问一个对象的同步方法时，另一个线程不能同时访问这个对象的另一个同步方法。