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

对象的synchronized方法不能进入了，但它的其他非synchronized方法还是可以访问的

对每一个class只有一个thread可以执行synchronized static method。每个class的instance只有一个thread可以执行synchronized method。任意数目的thread可以执行非synchronized method——不管是否是static。

情况一：

当一个线程进入一个对象的一个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方法后，其它线程访问该对象的非同步方法。

代码如下：

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

}

}

运行结果：

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

 

 

 

http://blog.csdn.net/hsuxu/article/details/8589108