對象的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 !") ;
}
}
運行結果：
|
一個線程在訪問一個對象的同步方法時，另一個線程不能同時訪問這個對象的另一個同步方法。 |