笔试:当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法? ?(2nd)

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

 

日前在网上见到一道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 {

 

    /**

     * @param args

     */

    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 !") ;

    }

 

}

 

 

运行结果:

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

 

你可能感兴趣的:(笔试:当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法? ?(2nd))