Java多線程-線程的同步與鎖【轉】

標籤：

出處：http://www.cnblogs.com/linjiqin/p/3208843.html

一、同步問題提出

線程的同步是為了防止多個線程訪問一個資料對象時，對資料造成的破壞。 例如：兩個線程ThreadA、ThreadB都操作同一個對象Foo對象，並修改Foo對象上的資料。

 

例如：兩個線程ThreadA、ThreadB都操作同一個對象Foo對象，並修改Foo對象上的資料。 

package cn.thread;public class Foo {    private int x = 100;    public int getX() {        return x;    }    public int fix(int y) {        x = x - y;        return x;    }}

 1 package cn.thread; 2  3 public class MyRunnable implements Runnable { 4     private Foo foo = new Foo(); 5  6     public static void main(String[] args) { 7         MyRunnable run = new MyRunnable(); 8         Thread ta = new Thread(run, "Thread-A"); 9         Thread tb = new Thread(run, "Thread-B");10         ta.start();11         tb.start();12     }13 14     public void run() {15         for (int i = 0; i < 3; i++) {16             this.fix(30);17             try {18                 Thread.sleep(1);19             } catch (InterruptedException e) {20                 e.printStackTrace();21             }22             System.out.println(Thread.currentThread().getName() + " : 當前foo對象的x值= " + foo.getX());23         }24     }25 26     public int fix(int y) {27         return foo.fix(y);28     }29 30 }

運行結果：

Thread-B : 當前foo對象的x值= 40Thread-A : 當前foo對象的x值= 40Thread-B : 當前foo對象的x值= -20Thread-A : 當前foo對象的x值= -20Thread-B : 當前foo對象的x值= -80Thread-A : 當前foo對象的x值= -80

從結果發現，這樣的輸出值明顯是不合理的。原因是兩個線程不加控制的訪問Foo對象並修改其資料所致。
如果要保持結果的合理性，只需要達到一個目的，就是將對Foo的訪問加以限制，每次只能有一個線程在訪問。這樣就能保證Foo對象中資料的合理性了。
在具體的Java代碼中需要完成一下兩個操作： 把競爭訪問的資源類Foo變數x標識為private； 同步哪些修改變數的代碼，使用synchronized關鍵字同步方法或代碼。

 

package cn.thread;public class Foo2 {    private int x = 100;    public int getX() {        return x;    }    //同步方法    public synchronized int fix(int y) {        x = x - y;        System.out.println("線程"+Thread.currentThread().getName() + "運行結束，減少“" + y                + "”，當前值為：" + x);        return x;    }    //    //同步代碼塊//    public int fix(int y) {//        synchronized (this) {//            x = x - y;//            System.out.println("線程"+Thread.currentThread().getName() + "運行結束，減少“" + y//                    + "”，當前值為：" + x);//        }//        //        return x;//    }}

package cn.thread;public class MyRunnable2  {    public static void main(String[] args) {        MyRunnable2 run = new MyRunnable2();        Foo2 foo2=new Foo2();                MyThread t1 = run.new MyThread("線程A", foo2, 10);        MyThread t2 = run.new MyThread("線程B", foo2, -2);        MyThread t3 = run.new MyThread("線程C", foo2, -3);        MyThread t4 = run.new MyThread("線程D", foo2, 5);                t1.start();        t2.start();        t3.start();        t4.start();    }        class MyThread extends Thread {        private Foo2 foo2;        /**當前值*/        private int y = 0;                MyThread(String name, Foo2 foo2, int y) {            super(name);            this.foo2 = foo2;            this.y = y;        }        public void run() {            foo2.fix(y);        }    }}

線程線程A運行結束，減少“10”，當前值為：90線程線程C運行結束，減少“-3”，當前值為：93線程線程B運行結束，減少“-2”，當前值為：95線程線程D運行結束，減少“5”，當前值為：90

二、同步和鎖定
1、鎖的原理
Java中每個對象都有一個內建鎖。
當程式運行到非靜態synchronized同步方法上時，自動獲得與正在執行代碼類的當前執行個體（this執行個體）有關的鎖。獲得一個對象的鎖也稱為擷取鎖、鎖定對象、在對象上鎖定或在對象上同步。
當程式運行到synchronized同步方法或代碼塊時該對象鎖才起作用。
一個對象只有一個鎖。所以，如果一個線程獲得該鎖，就沒有其他線程可以獲得鎖，直到第一個線程釋放（或返回）鎖。這也意味著任何其他線程都不能進入該對象上的synchronized方法或代碼塊，直到該鎖被釋放。
釋放鎖是指持鎖線程退出了synchronized同步方法或代碼塊。

關於鎖和同步，有一下幾個要點： 1）、只能同步方法，而不能同步變數和類； 2）、每個對象只有一個鎖；當提到同步時，應該清楚在什麼上同步？也就是說，在哪個對象上同步？ 3）、不必同步類中所有的方法，類可以同時擁有同步和非同步方法。 4）、如果兩個線程要執行一個類中的synchronized方法，並且兩個線程使用相同的執行個體來調用方法，那麼一次只能有一個線程能夠執行方法，另一個需要等待，直到鎖被釋放。也就是說：如果一個線程在對象上獲得一個鎖，就沒有任何其他線程可以進入（該對象的）類中的任何一個同步方法。 5）、如果線程擁有同步和非同步方法，則非同步方法可以被多個線程自由訪問而不受鎖的限制。 6）、線程睡眠時，它所持的任何鎖都不會釋放。 7）、線程可以獲得多個鎖。比如，在一個對象的同步方法裡面調用另外一個對象的同步方法，則擷取了兩個對象的同步鎖。 8）、同步損害並發性，應該儘可能縮小同步範圍。同步不但可以同步整個方法，還可以同步方法中一部分代碼塊。 9）、在使用同步代碼塊時候，應該指定在哪個對象上同步，也就是說要擷取哪個對象的鎖。例如： public int fix(int y) {       synchronized (this) {             x = x - y;       }       return x; }

當然，同步方法也可以改寫為非同步方法，但功能完全一樣的，例如： public synchronized int getX() {       return x++; } 與 public int getX() {       synchronized (this) {             return x++;       } } 效果是完全一樣的。

三、靜態方法同步
要同步靜態方法，需要一個用於整個類對象的鎖，這個對象就是這個類（XXX.class)。 例如： public static synchronized int setName(String name){       Xxx.name = name; } 等價於 public static int setName(String name){       synchronized(Xxx.class){             Xxx.name = name;       } }

四、如果線程不能獲得鎖會怎麼樣
如果線程試圖進入同步方法，而其鎖已經被佔用，則線程在該對象上被阻塞。實質上，線程進入該對象的的一種池中，必須在哪裡等待，直到其鎖被釋放，該線程再次變為可運行或運行為止。
當考慮阻塞時，一定要注意哪個對象正被用於鎖定： 1、調用同一個對象中非靜態同步方法的線程將彼此阻塞。如果是不同對象，則每個線程有自己的對象的鎖，線程間彼此互不干預。 2、調用同一個類中的靜態同步方法的線程將彼此阻塞，它們都是鎖定在相同的Class對象上。 3、靜態同步方法和非靜態同步方法將永遠不會彼此阻塞，因為靜態方法鎖定在Class對象上，非靜態方法鎖定在該類的對象上。 4、對於同步代碼塊，要看清楚什麼對象已經用於鎖定（synchronized後面括弧的內容）。在同一個對象上進行同步的線程將彼此阻塞，在不同對象上鎖定的線程將永遠不會彼此阻塞。

五、何時需要同步
在多個線程同時訪問互斥（可交換）資料時，應該同步以保護資料，確保兩個線程不會同時修改更改它。
對於非靜態欄位中可更改的資料，通常使用非靜態方法訪問。 對於靜態欄位中可更改的資料，通常使用靜態方法訪問。
如果需要在非靜態方法中使用靜態欄位，或者在靜態欄位中調用非靜態方法，問題將變得非常複雜。已經超出SJCP考試範圍了。
六、安全執行緒類
當一個類已經很好的同步以保護它的資料時，這個類就稱為“安全執行緒的”。
即使是安全執行緒類，也應該特別小心，因為操作的線程是間仍然不一定安全。

七、線程同步小結
1、線程同步的目的是為了保護多個線程訪問一個資源時對資源的破壞。 2、線程同步方法是通過鎖來實現，每個對象都有切僅有一個鎖，這個鎖與一個特定的對象關聯，線程一旦擷取了對象鎖，其他訪問該對象的線程就無法再訪問該對象的其他同步方法。 3、對於靜態同步方法，鎖是針對這個類的，鎖對象是該類的Class對象。靜態和非靜態方法的鎖互不干預。一個線程獲得鎖，當在一個同步方法中訪問另外對象上的同步方法時，會擷取這兩個對象鎖。 4、對於同步，要時刻清醒在哪個對象上同步，這是關鍵。 5、編寫安全執行緒的類，需要時刻注意對多個線程競爭訪問資源的邏輯和安全做出正確的判斷，對“原子”操作做出分析，並保證原子操作期間別的線程無法訪問競爭資源。 6、當多個線程等待一個對象鎖時，沒有擷取到鎖的線程將發生阻塞。 7、死結是線程間相互等待鎖鎖造成的，在實際中發生的機率非常的小。真讓你寫個死結程式，不一定好使，呵呵。但是，一旦程式發生死結，程式將死掉。

Java多線程-線程的同步與鎖【轉】