先如下程式碼：

public class ListHelper<Integer> {
    public List<Integer> list = Collections
            .synchronizedList(new ArrayList<Integer>());

    // private List<E> list = Collections.synchronizedList(new ArrayList<E>());
    public synchronized boolean put(Integer i) {

        list.add(i);
        System.out.println(Thread.currentThread().getName() + " --- " + i);
        return true;
    }
}
 

程式碼說明1）變數list用Collections.synchronizedList的作用是把本身不是執行緒安全的容器ArrayList變成執行緒安全的

                2）ListHepler的方法都用了synchronized來進行加鎖，用來同步。

                3)注意list變數的訪問許可權是public！

現在提供兩個執行緒類來提供模擬這個同步：

執行緒A和執行緒B的程式碼如下（兩個程式碼除了類名字完全一樣，所以在此僅貼出來A的)

public class A extends Thread {
    private ListHelper<Integer> lh;

    public A(ListHelper<Integer> lh) {
        super("A");
        this.lh = lh;
    }

    public void run() {
        synchronized (lh) {
            for (int i = 0; i < 9; i++) {
                lh.put(i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }
}


 

客戶端的程式碼：

public class Client {
  public static void main(String args[]) throws InterruptedException{
	  ListHelper<Integer> lh = new ListHelper<Integer>();
	  A a = new A(lh);
	  B b = new B(lh);	
	  a.start();	
	  b.start();
  }
}

執行結果如下：
A --- 0
A --- 1
A --- 2
A --- 3
A --- 4
A --- 5
A --- 6
A --- 7
A --- 8
B --- 0
B --- 1
B --- 2
B --- 3
B --- 4
B --- 5
B --- 6
B --- 7
B --- 8

從執行結果來看，一切都是那麼順利，當執行緒A執行的時候，B阻塞；然後A執行完畢釋放鎖，B獲取鎖並執行。看起來很安全的樣子。

但是下面在提供一個thread C:

public class C extends Thread {
   private ListHelper<Integer> lh;
   public C(ListHelper<Integer> lh){
	  super("C");
	  this.lh = lh;  
   }
   
  

public void run() {
		synchronized (lh.list) {//添加了list鎖
			for (int i = 0; i < 9; i++) {
				System.out.println(Thread.currentThread().getName() + "------" + i);
				lh.list.add(i);
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}

		}
		
	}

}

修改客戶端程式碼如下：

  public static void main(String args[]) throws InterruptedException{
	  ListHelper<Integer> lh = new ListHelper<Integer>();
	  A a = new A(lh);
	  B b = new B(lh);	
	  C c = new C(lh);
	  a.start();	
	  b.start();
	  c.start();
  }

執行結果如下：

A --- 0
C------0
C------1
C------2
C------3
C------4
C------5
C------6
C------7
C------8
A --- 1
A --- 2
A --- 3
A --- 4
A --- 5
A --- 6
A --- 7
A --- 8
B --- 0
B --- 1
B --- 2
B --- 3
B --- 4
B --- 5
B --- 6
B --- 7
B --- 8

發現執行緒A在執行的時候，由於A獲取了ListHelper的鎖，導致B執行緒的阻塞，當執行緒A在執行完的時候釋放鎖，然後B獲取鎖得到執行。但是有如下問題出現了

1）變數list不是被Collectoion.synchronizedList加過鎖了麼？

2）在A獲取鎖並執行的時候C怎麼可以執行呢？

3)並且A只執行了一次put方法之後等著C執行完畢後才得到執行呢？

解答：

   A獲取的是ListHelper物件鎖，而Collection.synchronizedList為list新增的鎖是另外一個鎖，也就是說兩個鎖不是一回事兒。所以問題3就可以迎刃而解了：

 1）A執行一次put方法，釋放了list鎖。此時A仍然擁有ListHelper鎖，B在等待獲取ListHelper鎖，所以B仍然阻塞

2）C獲取到了list鎖執行完for迴圈並釋放list鎖，A得到list鎖並執行完for迴圈，釋放ListHelper鎖。

3）B得到ListHelper鎖，並執行完畢,程式退出

所以A執行緒獲取ListHelper物件鎖執行的並執行的時候是沒法阻塞C執行緒的執行的，除非A執行緒也獲取了list上的鎖！！！

所以可以把A和B的run方法程式碼改成：

public void run() {
		synchronized (lh) {
			synchronized (lh.list) {//添加了list鎖
				for (int i = 0; i < 9; i++) {
					lh.put(i);
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
			
		}

	}

再次執行獲得結果：

A --- 0
A --- 1
A --- 2
A --- 3
A --- 4
A --- 5
A --- 6
A --- 7
A --- 8
C------0
C------1
C------2
C------3
C------4
C------5
C------6
C------7
C------8
B --- 0
B --- 1
B --- 2
B --- 3
B --- 4
B --- 5
B --- 6
B --- 7
B --- 8

當然要把ListHelper設定成執行緒安全的類，最簡單的是不釋出list變數，可以把list的改成private同時不提供getList()方法，不過這樣的話Collection.synchronizedList就失去了它的作用。怎麼在public訪問許可權不變的情況下，只利用Collection.synchronizedList提供的鎖來控制執行緒同步的呢？上面的程式碼A和B明顯用到了兩個鎖，一個是ListHelper鎖，另一個是Collection.synchronizedList提供的鎖，其實完全可以利用後者而不用ListHelper鎖來完成上述的更能。

修改ListHelper程式碼如下：

public class ListHelper<Integer> {
	public List<Integer> list = Collections.synchronizedList(new ArrayList<Integer>());

	// private List<E> list = Collections.synchronizedList(new ArrayList<E>());
	public  boolean put(Integer i) {
		synchronized(list){//在list上加鎖
			list.add(i);
			System.out.println(Thread.currentThread().getName() + " --- " + i);
			return true;
		}
		
	}
}

這樣的話上面的A和B的run方法就可以去掉synchronized (lh) 而只用synchronized (lh.list) 使得程式安全併發的運行了

public void run() {
		//synchronized (lh) {
			synchronized (lh.list) {
				for (int i = 0; i < 9; i++) {
					lh.putIfAbsent(i);
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
			
		}

	//}
}