執行緒同步

為了說明白什么是執行緒同步，我們來看一個小故事：

??比如說你賺了點錢，在銀行里存了點錢，不多也不少，剛好3000塊錢，然后銀行給你一個銀行卡和一本存折，

??有一天，你突然有急事想要用錢，你便拿著存折去銀行柜臺取錢，這時候作業人員問你打算取多少錢呀，不多，剛好取2000塊錢，然后作業人員把這要求輸入電腦，這時電腦會去檢查你的賬戶夠不夠2000塊錢，電腦一檢查，誒，你有，正常情況下，作業人員便把錢給你，最后把你賬戶里的錢減為1000塊錢，

??但是，這時當電腦檢查到你有2000塊錢，現在已經準備把錢給你，然后更新賬戶里的錢，正在這個階段，你的老婆拿你的銀行卡去ATM機上取錢，取的也是2000塊錢，然后ATM機也得去檢查你賬戶的錢，結果一檢查，夠2000塊錢（前面你取錢的時候還沒取到，賬戶的資訊也沒更新），接著ATM機就把錢吐出來了，然后賬戶里的錢更新為1000塊錢，

??然后你取錢的程序繼續執行，作業人員給你兩千，電腦更新賬再次更新為1000塊錢，最后你和你老婆都取了2000，賬戶里還有1000，

??這是怎么回事呢？你和你老婆好比是兩個執行緒，現在這兩個執行緒在執行一個取款方法的程序中，這兩個執行緒同時訪問同一個資源，如果協調不好，就會出現上面那種情況，所以，我們對執行緒訪問同一個資源的多個執行緒之間來進行協調的這個東西，叫執行緒同步，

??那我們要如何解決這個問題呢？上面的問題就是，你在取款的時候，被你老婆打斷了，還比你先取完了，所以解決辦法就是，當你在取款的程序中，也就是在呼叫某個方法的程序中，對不起，在這段時間，誰也不能動我的賬戶資訊（資源），這個賬戶歸我獨占，其他執行緒不能訪問，就好比兩個人不能上同一個坑一樣，

我們用一個小例子來看看：
TestSync.java

package Thread;

public class TestSync implements Runnable {
    Timer timer = new Timer();
    public static void main(String[] args) {
        TestSync test = new TestSync();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }
    public void run(){
        timer.add(Thread.currentThread().getName());
        //拿到當前執行緒的名字，并傳給add方法
    }
}

class Timer{
    private static int num = 0;//計數
    public void add(String name){
        num ++;//當add方法被呼叫的時候，num就往上增
        try {
            Thread.sleep(1);//哪個執行緒在執行就睡眠1ms
        }
        catch (InterruptedException e) {}
        System.out.println(name+", 你是第"+num+"個使用timer的執行緒");
    }
}

思考一下，輸出來的結果是怎么樣？是下面那樣嗎

其實不然， 上面程式輸出的結果為：

??這是怎么回事呢？這個執行程序是這樣的，比方說第一個執行緒，已經開始訪問timer物件的add方法了，執行到num++的時候，num原來是0，現在變成1，然后執行到sleep方法時，第一個執行緒睡眠了，
??接著第二個執行緒開始執行，這時候num已經變成1了，當第二個執行緒執行到add方法，訪問的是同一個物件，所以也是同一個num，則num由原來的1變成2，然后第二個執行緒開始睡眠，
??接著第一個執行緒醒了過來，然后他開始列印，“t1，你是第2個使用timer的執行緒”（這時候num變成了2），接著t2醒來，列印的也是第二個，


??問題就出在這，問題就出在，第一個執行緒在執行add方法的程序中，被第二個執行緒給打斷了，上面程式寫了sleep方法，就是為了這個效果（一個執行緒的執行程序中被另外一個執行緒打斷了）被看的更清楚，如果不寫sleep方法，可能列印出來的是正確的結果，但是，以后難免不會出問題，

那對于上述問題怎么解決呢？特別簡單，在這行add方法的程序中，把物件鎖住就行了，怎么鎖呢？看下面代碼：

 public synchronized void add(String name){ 
  	synchronized (this) {
	    num ++;
	    try {Thread.sleep(1);} 
	    catch (InterruptedException e) {}
	    System.out.println(name+", 你是第"+num+"個使用timer的執行緒");
	  }
  }

synchronized (this)鎖定當前物件，意思就是，在執行synchronized下面陳述句的程序之中，一個執行緒的執行程序之中，不會被另外一個執行緒打斷，當一個執行緒已經進入到鎖定的區域里邊了，你放心，不可能有另外一個執行緒也跑進來，

上面的 synchronized (this)是一個非常直接的寫法，還有一種比較簡便的寫法：

 public synchronized void add(String name) {
            num++;
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
            }
            System.out.println(name + ", 你是第" + num + "個使用timer的執行緒");
    }
}

直接將synchronized寫到public后面，意思就是，在執行add方法的程序中，鎖定當前物件，
來分析一下上面程式的執行程序，t1開始執行，呼叫add方法，num++，然后t1睡著了，睡著了沒關系，他睡著了還抱著這把鎖呢，別人進不來，必須等t1執行完了，才能輪到別人執行，

在Java語言中，引入物件互斥鎖的概念，保證共享資料操作的完整性，每個物件都對應于一個可稱為“互斥鎖”的標記，這個標記保證在任一時刻，只能有一個執行緒訪問該物件，

關鍵字synchronized來與物件的互斥鎖聯系，當某個物件synchronized修飾時，表明該物件在任一時刻只能有一個執行緒訪問，關鍵字synchronized鎖定某一段代碼，當執行這段代碼的程序之中，鎖定當前物件，另外一個執行緒也想訪問這段代碼的話，他只能等著，等前面那個執行緒執行這段代碼了，鎖自然而然也就打開了，鎖開了之后才能進的來，

synchronized的使用方法：

synchronize(this){
try {Thread.sleep(1);} 
	    catch (InterruptedException e) {}
	    System.out.println(name+", 你是第"+num+"個使用timer的執行緒");
 }

synchronize還可以放在方法宣告中，表示整個方法為同步方法，例如：

synchronize public void add(String name){...}

死鎖

當我們講了鎖之后，多執行緒還會帶來其他問題，一個典型的問題，就是死鎖，那么死鎖的原理是怎么樣的呢？

當執行緒a執行的程序之中，執行緒a需要鎖定物件c，但是，執行緒a還得要鎖住另外一個物件d才能繼續往下執行，也就是說執行緒a需要鎖定兩個物件，才能夠把整個操作完成，

此時，另外一個執行緒b也需要鎖定兩個物件才能往下執行，他首先鎖定的是物件d，執行緒a鎖住了物件c，他還需要擁有物件d的鎖就能往下執行，而執行緒b首先鎖住了物件d，如果再能擁有物件c的鎖，他就能繼續完成了，可是，最后這兩個執行緒都執行不下去了，因為他們等的東西都被對方給鎖住了，

那什么時候能釋放鎖呢，那就得等其中一個執行緒執行完了，但是這樣就成了悖論了，你得等我執行完了放開鎖，可是你不給我另外一個我也執行不完，我執行不完，你也別想執行完，這就是死鎖，

下面來看一個例子：
TestDeadLock.java

package Thread;

public class TestDeadLock implements Runnable {
    public int flag = 1;
    static Object o1 = new Object(), o2 = new Object();
    public void run() {
        System.out.println("flag=" + flag);
        if(flag == 1) {
            synchronized(o1) {
            //把o1給鎖定
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized(o2) {
                //這要他再能鎖住o2，就能繼續完成了
                    System.out.println("1");
                }
            }
        }
        if(flag == 0) {
            synchronized(o2) {
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized(o1) {
                    System.out.println("0");
                }
            }
        }
    }

    public static void main(String[] args) {
        TestDeadLock td1 = new TestDeadLock();
        TestDeadLock td2 = new TestDeadLock();
        td1.flag = 1;
        td2.flag = 0;
        Thread t1 = new Thread(td1);
        Thread t2 = new Thread(td2);
        t1.start();
        t2.start();

    }
}

上面代碼能完成嗎？完不成
輸出下面這個之后就再也不動了

那我們要怎么解決這個問題呢？怎么避免死鎖？其實很簡單，
執行緒獲取鎖的順序要一致，即嚴格按照先獲取o1，再獲取o2的順序，改寫 if(flag == 0)方法如下：

if(flag == 0) {
            synchronized(o1) {
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                synchronized(o2) {
                    System.out.println("0");
                }
            }
        }

深入了解synchronized

為了深入了解一下synchronized關鍵字，我們來看一個小程式：

public class TT {
    int b = 100;

    public synchronized void m1() throws Exception{
        b = 10000;
        Thread.sleep(5000);
        System.out.println("b = " + b);
    }

    public void m2(){ 
        System.out.println(b);
    }

思考一下一個問題，當m1方法執行的程序之中，m2能夠執行嗎？就是說，比方有一個執行緒在執行m1方法，另外一個執行緒能夠執行m2這個方法嗎？是不是得m1執行完解鎖之后才能執行呢？

那具體是不是呢？我們來把程式補全一下：

package Thread;

public class TT implements Runnable {
    int b = 100;

    public synchronized void m1() throws Exception{
        //Thread.sleep(2000);
        b = 1000;
        Thread.sleep(5000);
        System.out.println("m1方法的b = " + b);
    }

    public void m2(){
        System.out.println("m2方法的b=" + b);
    }

    public void run() {
        try {
            m1();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
        TT tt = new TT();
        Thread t = new Thread(tt);
        t.start();
        //這個執行緒開始執行，然后會睡5s，在這個時間里
        //我們在main主執行緒里邊，我們去訪問一下m2方法
        Thread.sleep(1000);
        tt.m2();
    }
}

如果主執行緒執行出來b=100的話，那就說明在m1方法的執行程序中，m2不可以執行，為什么呢？因為m1方法執行程序中將b的值改成1000了，但是他沒有解鎖，m2不能執行，所以b看到的是100，

問題來了，m2方法中的b輸出是多少呢？真的是100嗎？還是1000呢？我們來看看結果：

注意，synchronized 鎖定當先物件，只是針對m1方法里邊的代碼，也就是說另外一個執行緒絕對不可能執行那段代碼，但是有可能執行其他的代碼，就是說，m1方法被鎖定了，被同步了，他鎖定當前物件；但是另外一個執行緒完完全全訪問那種沒有鎖定的方法（m2），否則的話，m2只能看到100而不是1000.

好好消化一下上面的代碼，消化好了繼續往下看，我把上面的程式改一下：

public class TT implements Runnable {
	int b = 100;
	
	public synchronized void m1() throws Exception{
		b = 1000;
		Thread.sleep(5000);
		System.out.println("m1方法的b = " + b);
	}
	
	public void m2() throws Exception {
		Thread.sleep(2500);
		b = 2000;
	}
	
	public void run() {
		try {
			m1();
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) throws Exception {
		TT tt = new TT();
		Thread t = new Thread(tt);
		t.start();
		
		tt.m2();
		System.out.println("m2方法的b=" + tt.b);
	}
}

思考一下，現在b又是多少呢？1000還是2000

我們先來再次理解一下synchronized關鍵字，他鎖定了一個物件，但不是說完全的鎖定了，不是說其他任何的執行緒，任何的方法都不能訪問，保證同一時間只有一個執行緒進入到方法體里邊，但是不保證其他執行緒會不會進到另外一個方法里邊，，像m2這個方法，他可以執行，好了，我們來看一下結果：

我們來分析一下他的執行程序：

程序：
main方法開始執行，當main方法執行到t.start()；的時候，另外一個執行緒開始執行，這個執行緒執行的是run()方法，也就是m1這個方法，m1拿到這把鎖，把b設定成了1000，可是m2不用得到這把鎖就能執行，所以把b設成了2000，既然m2把b設定成2000了，然后tt.m2()，列印出來的tt.b的值當然是2000.
接著m1繼續執行，然后睡眠，列印b的值，列印出來的也是2000，剛剛m2方法就把b變成了2000，

輸出的是2000，m1里的b被改掉了，所以說，b = 100；是一個資源，這個資源能不能好好地被訪問，能不能正確的上鎖，就好比我們剛開始說的賬戶里的錢，能不能保證前后一致？我們就得把訪問這個資源的所有訪問的方法都考慮到，每個方法是不是該設成同步的都要考慮到，
上面程式，既然m1方法能改b的值，m2方法也能改b的值，兩個方法都改了同一個值，他們就一定會產生沖突，你只給一個方法加了鎖是不行的，必須把m2也加鎖，

public synchronized void m2() throws Exception {...}

那給m2加鎖之后的結果會是怎樣的呢？你放心，這次絕對是1000

為什么m2也是1000呢？不應該是2000嗎？我們來分析一下他執行的程序，

程序：
main方法開始執行，當main方法執行到t.start()；的時候，另外一個執行緒開始執行，這個執行緒執行的是run()方法，也就是m1這個方法，接下來main方法繼續往下執行，執行的是：

tt.m2();
System.out.println("m2方法的b=" + tt.b);

這兩行代碼，首先tt.m2()，就是執行m2方法，當m2這個方法被執行的時候，他就鎖定了當前這個物件，拿到鎖之后自己睡眠2.5s，然后把b設成2000，
接下來，tt.m2()執行完了，m1才有可能執行，因為m2執行完了，那個鎖才會被釋放，這時候m1執行，把b設成1000，然后m1開始睡眠，現在b的值為1000，接下來才列印tt.b，所以m2列印出來的b是1000，
總的來說，這個程式就是，m2執行完了，m1執行一句，然后才開始列印tt.b，所以最后的結果都是1000

在強調一下：加鎖這個東西，你寫一個同步的東西，是挺困難的一件事，因為每一個方法要不要同步，你都需要考慮的非常清楚，如果一個方法做了同步，另外一個方法沒做同步，那么，記住一點，別的執行緒可以自由的訪問沒有同步的方法，并且可能會對你同步的方法產生影響，
如果你要保護好需要同步的物件的話，你必須對訪問這個物件的所以的方法要仔細的考慮加不加同步，加了同步，很有可能效率就會變低；不加同步，有可能產生資料不一致的現象，

現在我們回到最開始那個小程式的問題，當m1方法執行的程序之中，m2能夠執行嗎？答案是：能，但是在m2加了synchronize的話，m2就不能執行了，

多執行緒（二）就先寫到這啦，不寫不知道，一寫嚇一跳，要寫的知識太多了，我還以為兩個板塊就能寫完的，看來我還是太天真了，當然，我也不可能面面俱到，里面沒寫到的知識或者不懂的（不過我感覺應該都懂吧，感覺我已經寫的夠明白了），大家可以在評論區留言，

多執行緒（三）傳送門