synchronized簡單示例

一、synchronized應用的簡單示例

下面兩段代碼示例，分別用同步塊，同步方法完成兩個線程共同操作的計數器，計數到10。

package concurrency;

public class TwoThreadCounter {

    public static volatile boolean  goon = false;
    public static int nums = 0;

    public static void main(String[] args) {
        Thread counter1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while(goon){
                    synchronized (TwoThreadCounter.class) {
                        nums++;
                        System.out.println(Thread.currentThread().getName() + "\t" + nums);
                        if(nums == 10) {
                            goon = false;
                            TwoThreadCounter.class.notifyAll();
                        }else{
                            try {
                                TwoThreadCounter.class.notifyAll();
                                TwoThreadCounter.class.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }

                    }
                }
            }
        }, "counter1");
        Thread counter2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while(goon) {
                    synchronized (TwoThreadCounter.class) {
                        nums++;
                        System.out.println(Thread.currentThread().getName() + "\t" + nums);
                        if(nums == 10) {
                            goon = false;
                            TwoThreadCounter.class.notifyAll();
                        }else{
                            try {
                                TwoThreadCounter.class.notifyAll();
                                TwoThreadCounter.class.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }

            }
        }, "counter2");

        goon = true;
        counter1.start();
        counter2.start();


        try {
            counter1.join();
            counter2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

看下輸出結果：

counter1	1
counter2	2
counter1	3
counter2	4
counter1	5
counter2	6
counter1	7
counter2	8
counter1	9
counter2	10

sysnchronized也可以用於修飾方法，普通方法和靜態方法都可以，我們現在用普通同步方法改寫上面的代碼，因爲靜態方法術語類對象，而普通方法屬於類的實例，所以如果想用sysnchronized修飾普通方法來實現功能，要在有一個實例，代碼如下：

import java.util.concurrent.atomic.AtomicBoolean;

public class TwoThreadCounterSynNormalMethod {
	public static Integer counter = 0;
	public static AtomicBoolean goon = new AtomicBoolean(false);
	
	public TwoThreadCounterSynNormalMethod() {}
	
	public synchronized void counterIncreace(){
		counter ++;
		System.out.println(Thread.currentThread().getName() + "\t" + counter);
		try {
			this.wait();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		TwoThreadCounterSynNormalMethod ttcsnm = new TwoThreadCounterSynNormalMethod();
		Thread counter1 = new Thread(new Runnable() {
			@Override
			public void run() {
				while(goon.get()){
					ttcsnm.counterIncreace();
					if(counter == 10) {
						goon.set(false);
					}
				}
			}
		}, "counter1");
		Thread counter2 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				while(goon.get()) {
					ttcsnm.counterIncreace();
					if(counter == 10) {
						goon.set(false);
					}
				}
			}
		}, "counter2");
		
		goon.set(true);
		boolean hasStart = false;
		
		while(goon.get()){
			if(!hasStart) {
				counter1.start();
				counter2.start();
				hasStart = true;
			}
			synchronized (ttcsnm) {// 這裏很重要，因爲對普通方法使用synchronized關鍵字修飾，其實是把調用該方法的實例作爲了鎖對象
				ttcsnm.notifyAll(); //所以當需要喚醒時，是調用的ttcsnm.notiffyAll();
			}
		}
	}
}

輸出結果是一樣的。

二、synchronized關鍵字的使用

上面通過類比已經說明了synchronized實現同步時涉及到的方法以及含義，涉及到的幾個方法分別爲：obj.wait()、obj.notify()、obj.notifyAll()，這幾個方法必須在同步塊中調用，synchronized關鍵字只要作用就是指定誰是鎖，在Java中每個對象都可以作爲鎖。

主要有三種形式：

• 對於普通同步方法，鎖是當前的實例對象。在上面的第二個代碼示例中，用synchronized修飾普通方法，調用這個方法的實例是ttcsnm，那麼要進入這個方法，就要取得實例對象ttcsnm對應的鎖，所以我在喚醒時，需要調用ttcsnm

• 對於靜態同步方法，鎖是當前類的Class對象。可以類比普通同步方法，普通同步方法屬於實例，所以要進入同步方法，需要獲得實例對應的鎖，而靜態方法屬於類，調用時也通過類名來調用，所以用synchronized關鍵字修飾靜態方法，那麼要訪問該方法，需要拿到類對象對應的鎖。

• 對於同步塊，synchronized後面括號裏的對象就是鎖，如上面第一個代碼示例所示，用的是類對象TwoThreadCounter.class作爲鎖，要訪問同步塊中的內容就必須拿到這個鎖。

接下來分析實現計數器功能的代碼。

3.1使用同步代碼塊

第一個示例中，使用的是同步塊，同步塊的書寫遵循以下格式：

synchronized (obj) {
	// 執行內容
}	

obj即指定的鎖，任何對象均可以，執行內容即用戶要完成的業務邏輯，再回到代碼示例

synchronized (TwoThreadCounter.class) { //此處指定TwoThreadCouter的類對象爲鎖
	counter++; //這裏是真正要完成的功能，即每次讓計數器的值增加1
	System.out.println(Thread.currentThread().getName() + "\t" + counter);
	if(counter == 10) { // 判斷如果當前技術器增加到10，那就停止，讓線程停止的方式，此處選擇使用atomicBooelan類來作爲一個標誌，如果其值爲false,線程看到後就不再繼續進行
		goon.set(false);
		}else{
		try {
			TwoThreadCounter.class.wait(); // 這裏很關鍵，當一個線程對計數器進行加1操作後，如果沒有累加到10，就需要另外一個線程繼續加
		} catch (InterruptedException e) {     // 所以需要讓當前線程放棄鎖，根據上面分析的，想剝奪鎖，必須在同步塊內部，調用obj.wait()方法
			e.printStackTrace();           // 這個方法會讓當前線程在此方法等待（不是阻塞），直到線程死亡或被喚醒才能從該方法返回
		}
	}
}	// 當線程成功執行完同步代碼塊，出這個"｝"時，會主動調用notifyall()方法。

兩個線程的同步塊內容是一樣的，當前線程拿到鎖，對計數器執行加一操作，然後判斷是否結束，如果沒結束，就需要放棄鎖，原地等待，讓另外一個線程有機會獲得鎖，並執行相同的功能。另外一個線程執行相同的操作後，也在wait()方法處等待，所以此時需要另外在外面喚醒

 

		while(goon.get()){

			if(!hasStart) {
				counter1.start();
				counter2.start();
				hasStart = true;
			}
			synchronized (TwoThreadCounter.class) {
				TwoThreadCounter.class.notify();
			}
		}

這段代碼由主線程來執行，完成對兩個線程的控制，當執行計數器加一操作的兩個線程均運行到TwoThreadCounter.class.wait() 方法時，兩個線程放棄鎖，同時進入等待狀態，所以在主線中，main線程可以順利獲得鎖，進入同步塊

 

			synchronized (TwoThreadCounter.class) {
				TwoThreadCounter.class.notify();
			}// 當主線程執行完同步塊時，纔會釋放鎖，調用notify方法並不釋放鎖

在同步塊中，調用TwoThreadCounter.class.notify()，此時會喚醒等待隊列中的第一個線程，允許該線程擁有獲得鎖的機會，但此時鎖依然在主線程手裏，只有當主線程退出同步塊時，纔會把鎖釋放掉，被喚醒的線程才能獲得鎖。

這樣，處於排隊的線程可重新獲得鎖，從wait()方法返回，繼續執行，再判斷是否結束了，如果沒有結束，重新嘗試獲得鎖。

 

3.1使用同步方法

對於同步方法，注意鎖對象是調用該方法的實例即可，所以在喚醒時，要用實例來調用notifyAll（）方法。

 

		while(goon.get()){
			if(!hasStart) {
				counter1.start();
				counter2.start();
				hasStart = true;
			}
			synchronized (ttcsnm) {// 這裏很重要，因爲對普通方法使用synchronized關鍵字修飾，其實是把調用該方法的實例作爲了鎖對象
				ttcsnm.notifyAll(); //所以當需要喚醒時，是調用的ttcsnm.notiffyAll();
			}
		}