Java線程：線程的同步與

時間 2019-12-04

標籤 java 線程同步欄目 Java 简体版

原文原文鏈接

本文出自「熔巖」博客，轉載請與做者聯繫！安全

1、同步問題提出併發

線程的同步是爲了防止多個線程訪問一個數據對象時，對數據形成的破壞。this

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

public class Foo {
    private int x = 100;

    public int getX() {
        return x;
    }

    public int fix(int y) {
        x = x - y;
        return x;
    }
}設計

public class MyRunnable implements Runnable {
    private Foo foo = new Foo();

    public static void main(String[] args) {
        MyRunnable r = new MyRunnable();
        Thread ta = new Thread(r, "Thread-A");
        Thread tb = new Thread(r, "Thread-B");
        ta.start();
        tb.start();
    }

    public void run() {
        for (int i = 0; i < 3; i++) {
            this.fix(30);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " : 當前foo對象的x值= " + foo.getX());
        }
    }

    public int fix(int y) {
        return foo.fix(y);
    }
}code

運行結果：對象

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

Process finished with exit code 0blog

從結果發現，這樣的輸出值明顯是不合理的。緣由是兩個線程不加控制的訪問Foo對象並修改其數據所致。事件

若是要保持結果的合理性，只須要達到一個目的，就是將對Foo的訪問加以限制，每次只能有一個線程在訪問。這樣就能保證Foo對象中數據的合理性了。資源

在具體的Java代碼中須要完成一下兩個操做：

把競爭訪問的資源類Foo變量x標識爲private；

同步哪些修改變量的代碼，使用synchronized關鍵字同步方法或代碼。

2、同步和鎖定

一、鎖的原理

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;
        }
    }

效果是徹底同樣的。

3、靜態方法同步

要同步靜態方法，須要一個用於整個類對象的鎖，這個對象是就是這個類（XXX.class)。

例如：

public static synchronized int setName(String name){

Xxx.name = name;

}

等價於
public static int setName(String name){
      synchronized(Xxx.class){
            Xxx.name = name;
      }
}

4、若是線程不能不能得到鎖會怎麼樣

若是線程試圖進入同步方法，而其鎖已經被佔用，則線程在該對象上被阻塞。實質上，線程進入該對象的的一種池中，必須在哪裏等待，直到其鎖被釋放，該線程再次變爲可運行或運行爲止。

當考慮阻塞時，必定要注意哪一個對象正被用於鎖定：

一、調用同一個對象中非靜態同步方法的線程將彼此阻塞。若是是不一樣對象，則每一個線程有本身的對象的鎖，線程間彼此互不干預。

二、調用同一個類中的靜態同步方法的線程將彼此阻塞，它們都是鎖定在相同的Class對象上。

三、靜態同步方法和非靜態同步方法將永遠不會彼此阻塞，由於靜態方法鎖定在Class對象上，非靜態方法鎖定在該類的對象上。

四、對於同步代碼塊，要看清楚什麼對象已經用於鎖定（synchronized後面括號的內容）。在同一個對象上進行同步的線程將彼此阻塞，在不一樣對象上鎖定的線程將永遠不會彼此阻塞。

5、什麼時候須要同步

在多個線程同時訪問互斥（可交換）數據時，應該同步以保護數據，確保兩個線程不會同時修改更改它。

對於非靜態字段中可更改的數據，一般使用非靜態方法訪問。

對於靜態字段中可更改的數據，一般使用靜態方法訪問。

若是須要在非靜態方法中使用靜態字段，或者在靜態字段中調用非靜態方法，問題將變得很是複雜。已經超出SJCP考試範圍了。

6、線程安全類

當一個類已經很好的同步以保護它的數據時，這個類就稱爲「線程安全的」。

即便是線程安全類，也應該特別當心，由於操做的線程是間仍然不必定安全。

舉個形象的例子，好比一個集合是線程安全的，有兩個線程在操做同一個集合對象，當第一個線程查詢集合非空後，刪除集合中全部元素的時候。第二個線程也來執行與第一個線程相同的操做，也許在第一個線程查詢後，第二個線程也查詢出集合非空，可是當第一個執行清除後，第二個再執行刪除顯然是不對的，由於此時集合已經爲空了。

看個代碼：

public class NameList {
    private List nameList = Collections.synchronizedList(new LinkedList());

    public void add(String name) {
        nameList.add(name);
    }

    public String removeFirst() {
        if (nameList.size() > 0) {
            return (String) nameList.remove(0);
        } else {
            return null;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        final NameList nl = new NameList();
        nl.add("aaa");
        class NameDropper extends Thread{
            public void run(){
                String name = nl.removeFirst();
                System.out.println(name);
            }
        }

        Thread t1 = new NameDropper();
        Thread t2 = new NameDropper();
        t1.start();
        t2.start();
    }
}

雖然集合對象

private List nameList = Collections.synchronizedList(new LinkedList());
是同步的，可是程序還不是線程安全的。

出現這種事件的緣由是，上例中一個線程操做列表過程當中沒法阻止另一個線程對列表的其餘操做。

解決上面問題的辦法是，在操做集合對象的NameList上面作一個同步。改寫後的代碼以下：

public class NameList {
    private List nameList = Collections.synchronizedList(new LinkedList());

    public synchronized void add(String name) {
        nameList.add(name);
    }

    public synchronized String removeFirst() {
        if (nameList.size() > 0) {
            return (String) nameList.remove(0);
        } else {
            return null;
        }
    }
}

這樣，當一個線程訪問其中一個同步方法時，其餘線程只有等待。

7、線程死鎖

死鎖對Java程序來講，是很複雜的，也很難發現問題。當兩個線程被阻塞，每一個線程在等待另外一個線程時就發生死鎖。

仍是看一個比較直觀的死鎖例子：

public class DeadlockRisk {
    private static class Resource {
        public int value;
    }

    private Resource resourceA = new Resource();
    private Resource resourceB = new Resource();

    public int read() {
        synchronized (resourceA) {
            synchronized (resourceB) {
                return resourceB.value + resourceA.value;
            }
        }
    }

    public void write(int a, int b) {
        synchronized (resourceB) {
            synchronized (resourceA) {
                resourceA.value = a;
                resourceB.value = b;
            }
        }
    }
}