java synchronized详解(1)

Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时间最多只有一个线程执行该段代码。

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块是，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

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)同步代码块。

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(Exception e){
    			}
    		}
    	}
    }
    public void m4t2(){
    	int i = 5 ;
    	while(i-- > 0){
    		System.out.println(Thread.currentThread().getName() + " : "+ i);
			try{
				Thread.sleep(500);
			}catch(Exception e){
			}
    	}
    }
    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)同步代码块的访问将被阻塞。

public class Thread2 {
    public void m4t1(){
    	synchronized(this){
    		int i = 5 ; 
    		while(i-- >0){
    			System.out.println(Thread.currentThread().getName() + " : "+ i);
    			try{
    				Thread.sleep(5000);
    			}catch(Exception e){
    			}
    		}
    	}
    }
    public void m4t2(){
    	synchronized(this){
    		int i = 5 ;
        	while(i-- > 0){
        		System.out.println(Thread.currentThread().getName() + " : "+ i);
        	}
    	}
    }
    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
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0

四、第三个例子同样适用其他同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其他线程对该object对象所有同步代码部分的访问都被暂时阻塞。

    //修改Thread2.m4t2()如下：
    public synchronized void m4t2(){
    		int i = 5 ;
        	while(i-- > 0){
        		System.out.println(Thread.currentThread().getName() + " : "+ i);
        	}
    }

t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0

五、以上规则对其他对象锁同样适用。

public class Thread3 {
    class Inner{
    	private void m4t1(){
    		int i = 5 ; 
    		while(i-- >0){
    			System.out.println(Thread.currentThread().getName() + " : "+ i);
    			try{
    				Thread.sleep(5000);
    			}catch(Exception e){
    			}
    		}
    	}
    	private void m4t2(){
    		int i = 5 ; 
    		while(i-- >0){
    			System.out.println(Thread.currentThread().getName() + " : "+ i);
    			try{
    				Thread.sleep(5000);
    			}catch(Exception e){
    			}
    		}
    	}
    }
    private void m4t1(Inner inner){
    	synchronized (inner) {  //使用对象锁
    		inner.m4t1();
		}
    }
    private void m4t2(Inner inner){
    	inner.m4t2();
    }
    public static void main(String[] args) {
		final Thread3 myt3 = new Thread3();
		final Inner inner = myt3.new Inner();
		Thread t1 = new Thread(new Runnable() {public void run() {myt3.m4t1(inner);}}, "t1");
		Thread t2 = new Thread(new Runnable() {public void run() {myt3.m4t2(inner);}}, "t2");
		t1.start();
		t2.start();
	}
}

尽管线程t1获得了对Inner的对象锁，但由于线程t2访问的是通一个Inner中的非同步部分。所以两个线程互不干扰。
t2 : 4
t1 : 4
t2 : 3
t1 : 3
t1 : 2
t2 : 2
t1 : 1
t2 : 1
t1 : 0
t2 : 0

现在在Inner.m4t2()前面加上synchronized：

    	private synchronized void m4t2(){
    		int i = 5 ; 
    		while(i-- >0){
    			System.out.println(Thread.currentThread().getName() + " : "+ i);
    			try{
    				Thread.sleep(500);
    			}catch(Exception e){
    			}
    		}
    	}

尽管线程t1与t2访问了同一个Inner对象中的两个毫不相关的部分，但因为t1先获得了对Inner的对象锁，所以t2对Inner.m4t2()的访问也被阻塞，
因为m4t2()是Inner中的一个同步方法。
t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0