一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 package ths; public class Thread1 implements Runnable { public void run() { synchronized(this) { for (int i = 0; i < 5; i++) { System.out.println(Thread.currentThread().getName() + ” synchronized loop ” + i); } } } public static void main(String[] args) { Thread1 t1 = new Thread1(); Thread ta = new Thread(t1, “A”); Thread tb = new Thread(t1, “B”); ta.start(); tb.start(); } } 结果： A synchronized loop 0 A synchronized loop 1 A synchronized loop 2 A synchronized loop 3 A synchronized loop 4 B synchronized loop 0 B synchronized loop 1 B synchronized loop 2 B synchronized loop 3 B synchronized loop 4 二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。 package ths; public class Thread2 { public void m4t1() { synchronized(this) { int i = 5; while( i– > 0) { System.out.println(Thread.currentThread().getName() + ” : ” + i); try { Thread.sleep(500); } catch (InterruptedException ie) { }
} } } public void m4t2() { int i = 5; while( i– > 0) { System.out.println(Thread.currentThread().getName() + ” : ” + i); try { Thread.sleep(500); } catch (InterruptedException ie) { } } }
public static void main(String[] args) { final Thread2 myt2 = new Thread2(); Thread t1 = new Thread( new Runnable() { public void run() { myt2.m4t1(); } }, “t1”); Thread t2 = new Thread( new Runnable() { public void run() { myt2.m4t2(); } }, “t2″); t1.start(); t2.start(); } } 结果： t1 : 4 t2 : 4 t1 : 3 t2 : 3 t1 : 2 t2 : 2 t1 : 1 t2 : 1 t1 : 0 t2 : 0 三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。 package ths; public class Thread2 { public void m4t1() { synchronized(this) { int i = 5; while( i– > 0) { System.out.println(Thread.currentThread().getName() + ” : ” + i); try { Thread.sleep(500); } catch (InterruptedException ie) { }
} } } public void m4t2() { int i = 5; synchronized(this) { while( i– > 0) { System.out.println(Thread.currentThread().getName() + ” : ” + i); try { Thread.sleep(500); } catch (InterruptedException ie) { } } } } }
public static void main(String[] args) { final Thread2 myt2 = new Thread2(); Thread t1 = new Thread( new Runnable() { public void run() { myt2.m4t1(); } }, “t1”); Thread t2 = new Thread( new Runnable() { public void run() { myt2.m4t2(); } }, “t2”); t1.start(); t2.start(); } } 结果： t1 : 4 t2 : 3 t1 : 2 t2 : 1 t1 : 0 t2 : 4 t1 : 3 t2 : 2 t1 : 1 t2 : 0 四、第三个例子同样适用其它同步代码块。也就是说，网站空间，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。 五、以上规则对其它对象锁同样适用: package ths;
public class Thread3 {
class Inner {
private void m4t1() {
int i = 5;
while(i– > 0) {
System.out.println(Thread.currentThread().getName() + ” : Inner.m4t1()=” + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}
private void m4t2() {
int i = 5;
while(i– > 0) {
System.out.println(Thread.currentThread().getName() + ” : Inner.m4t2()=” + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}
}
private void m4t1(Inner inner) {
synchronized(inner) { //使用对象锁
inner.m4t1();
}
}
private void m4t2(Inner inner) { inner.m4t2(); } public static void main(String[] args) {
拥有一颗比九万五千公里还辽阔的心，
