java鎖synchronized 解決的問題：
搶資源

關於鎖方法    鎖靜態方法鎖的鎖 class，鎖非靜態方法鎖的是類的例項  this  ，鎖方法相當於鎖程式碼塊，不阻塞其他非鎖部分程式碼塊或者方法的執行

1.靜態方法訪問靜態變數  

2.非靜態方法訪問靜態變數

3.非靜態方法訪問非靜態變數

關於鎖程式碼塊比較好理解，關鍵是理解鎖的物件是什麼 就可以了

以下是測試類

package com.sync;

/**
 * 同步鎖
synchronized

鎖方法
鎖程式碼塊
鎖靜態方法

測試1	(經過測試,鎖方法相當於鎖一個程式碼塊,鎖的物件是this)
鎖普通方法,並且呼叫鎖方法的同時呼叫該物件的其他方法,測試 鎖定該方法是否影響該物件的其他方法

測試2	
鎖靜態程式碼塊


搶資源
關於鎖方法  鎖方法相當於鎖程式碼塊，不影響當前物件的其他方法執行，不阻塞
靜態方法訪問靜態變數
非靜態方法訪問靜態變數
非靜態方法訪問非靜態變數

關於鎖程式碼塊很好理解

 * @author hyz79
 */
public class SyncTest {
	
	private static class SyncTest1{
		public synchronized void sync(){
			System.out.println("我上鎖了");
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("我在執行");
			System.out.println("我執行完成");
		}
		
		public void other(){
			System.out.println("悠悠達達執行其他方法..");
		}
		/***
		 * 測試鎖方法,在執行該方法的時候 是否影響其它方法的執行
		 * 
		 * 結果1.如果  悠悠達達執行其他方法..行的輸出 不在
		 * 我上鎖了
		 * 我在執行
		 * 我執行完成
		 * 這個 中間  ,說明鎖當前這個物件的 所有方法
		 * 結果2.如果在其中輸出 說明,鎖的僅僅是這個方法,相當於鎖程式碼塊
		 * 
		 * 執行結果  結論:鎖非靜態方法相當於鎖一個程式碼塊 ,這個方法做為一個程式碼塊,鎖當前物件
我上鎖了
我在執行
我執行完成
我上鎖了
悠悠達達執行其他方法..
我在執行
我執行完成
悠悠達達執行其他方法..
我上鎖了
我在執行
我執行完成
悠悠達達執行其他方法..
我上鎖了
我在執行
我執行完成
我上鎖了
悠悠達達執行其他方法..
我在執行
我執行完成
悠悠達達執行其他方法..
我上鎖了
我在執行
我執行完成
悠悠達達執行其他方法..
我上鎖了
我在執行
我執行完成
悠悠達達執行其他方法..
我上鎖了
我在執行
我執行完成
我上鎖了
悠悠達達執行其他方法..
我在執行
我執行完成
我上鎖了
悠悠達達執行其他方法..
我在執行
我執行完成
悠悠達達執行其他方法..
		 */
		public static void test(){
			final SyncTest1 t1 = new SyncTest1();
			
			for(int i=0;i<10;i++){
				new Thread(new Runnable() {
					@Override
					public void run() {
						t1.sync();
						t1.other();
					}
				}).start();;
			}
		}
	}
	
	private static class SyncTest2{
		public static int C = 0;
		
		public synchronized static void sync(){
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			C++;
			System.out.println(C);
		}
		
		public static void test1(){
			for(int i=0;i<10;i++){
				new Thread(new Runnable() {
					@Override
					public void run() {
						SyncTest2.sync();
					}
				}).start();
			}
		}
	}
	
	private static class SyncTest3{
		public static int C = 0;
		
		public synchronized void sync(){
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			C++;
			System.out.println(C);
		}
		
		public static void test(){
			for(int i=0;i<1000;i++){
				new Thread(new Runnable() {
					@Override
					public void run() {
						new SyncTest3().sync();
					}
				}).start();
			}
		}
	}
	private static class Obj{
		public int i;
		public void add(){
			System.out.println(i++);
		}
	}
	private static class SyncTest4{
		public static synchronized void test(Obj obj){
			obj.add();
		}
		
		public static void test(){
			final Obj obj = new Obj();
			for(int i=0;i<100;i++){
				new Thread(new Runnable() {
					@Override
					public void run() {
						test(obj);
					}
				}).start();
			}
		}
	}
	
	public static void main(String[] args) {
		//SyncTest1.test();
		//SyncTest2.test1();
		SyncTest3.test();
//		SyncTest4.test();
	}
	
	
}