Java 併發編程(四)：如何保證對象的線程安全性

本篇來談談 Java 併發編程：如何保證對象的線程安全性。

0一、前言

先讓我吐一句肺腑之言吧，不說出來會憋出內傷的。《Java 併發編程實戰》這本書太特麼枯燥了，儘管它被奉爲併發編程當中的經典之做，但我仍是忍不住。由於第四章「對象的組合」我整整啃了兩週的時間，才啃出來點肉絲。

讀者朋友們見諒啊。要怪只能怪我本身的學習能力有限，真讀不了這種生硬無趣的技術書。可是爲了學習，爲了進步，爲了未來（口號喊得有點大了），只能硬着頭皮上。

請隨我來，我儘可能寫得有趣點。

0二、線程安全類

做者說了啊，設計一個線程安全類須要三個步驟：

1）找出表示對象狀態的全部變量
2）對變量進行有效性約束
3）增長類的併發訪問策略

我在做者說的基礎上作了微調，讀起來更加容易理解。怎麼和代碼對應起來了，先來看一個普通的計數器類 Counter。

public class Counter {
    private int value = 0;

    public int getValue() {
        return value;
    }

    public int increment() {
        return ++value;
    }
}

1）Counter 的狀態變量只有一個，就是 value。

2）value 的有效性是什麼呢，它最大不能超過 Integer.MAX_VALUE，最小隻能爲 0（計數嘛，總不能記成負數）。換句話說就是，value 的有效範圍是 0 ~ Integer.MAX_VALUE。

public int increment() {
    if (value == Integer.MAX_VALUE) {
        throw new IllegalStateException("counter overflow");
    }
    return ++value;
}

3）增長類的併發訪問策略，直接上 synchronized。

public class Counter {
    private int value = 0;

    public synchronized int getValue() {
        return value;
    }

    public synchronized int increment() {
        if (value == Integer.MAX_VALUE) {
            throw new IllegalStateException("counter overflow");
        }
        return ++value;
    }
}

0三、非線程安全的對象

以前咱們談了如何設計一個線程安全的類。若是類是安全的，那麼它做爲對象使用的時候就是線程安全的。但若是一個類不是線程安全的，它做爲對象使用的時候怎麼保證是線程安全的呢？

做者提到了一個名詞叫作「封閉機制」：

1）把對象做爲類的私有成員變量；
2）把對象做爲方法內部的局部變量；
3）線程 A 把對象傳遞到 B 線程，而不是與線程 B 共享這個對象；

你們來看下面這段代碼。

class StringList {
    private List<String> myList = new ArrayList<>();
    
    public synchronized void addString(String s) {
        myList.add(s);
    }
    
    public synchronized void removeString(String s) {
        myList.remove(s);
    }
}

自己 ArrayList 不是線程安全的，但 myList 是私有的，訪問它的兩個方法 addString() 和 removeString() 都加了關鍵字 synchronized，所以 myList 在使用的時候就變成了線程安全的對象，StringList 類就變成了一個線程安全的類——這種方式被稱做 Java 監視器模式：可變的狀態被封裝在一個類中，訪問它們只能經過加上鎖的方法。

查看 Vector 的源碼，你會發現，它之因此是線程安全的，就是採用的這種監視器模式

0四、在已有的線程安全類上追加功能

假如如今有一個線程安全的類，好比以前提到的 StringList，它包含了大多數咱們須要的功能，但還不夠，那麼怎麼確保咱們追加的功能不破壞原有的線程安全性呢？

最直接的方法固然是修改源碼，假如源碼掌握在咱們本身手裏的話。

class StringList {
    private List<String> myList = new ArrayList<>();
    
    public synchronized void addString(String s) {
        myList.add(s);
    }
    
    public synchronized void addIfNotExist(String s) {
        boolean isExist = myList.contains(s);
        if (!isExist) {
            myList.add(s);
        }
    }
}

咱們新增了一個 addIfNotExist() 方法：若是字符串 s 尚未添加到 List 當中，就添加一個。

新增的方法沒有破壞 StringList 的線程安全性，由於當兩個線程同時執行 addIfNotExist() 方法時，須要通過 synchronized 把守的這道大門。

但不少時候，咱們沒法直接修改源碼，這時候就只好在原來的基礎上進行改造。你們聽過以前的「紅芯」瀏覽器嗎？在谷歌瀏覽器的內核上裹了一層層皇帝的新衣。

class StringList {
    protected List<String> myList = new ArrayList<>();
    
    public synchronized void addString(String s) {
        myList.add(s);
    }
}

public class NewStringList extends StringList {
    public synchronized void addIfNotExist(String s) {
        boolean isExist = myList.contains(s);
        if (!isExist) {
            myList.add(s);
        }
    }
}

新建一個類 NewStringList，繼承自 StringList，而後在 NewStringList 中新增一個方法 addIfNotExist()。固然了，這樣作的前提是父類中的 myList 是 protected 而不是 private 的。所以，這種作法不具備普適性。

0五、最後

站在個人角度來看，《Java 併發編程實戰》的第四章「對象的組合」寫得爛透了。致使我在寫這篇文章的時候感受到萬分的痛苦。但願下一章不要寫的這麼爛。

上一篇：如何保證共享變量的可見性？

上上篇：如何保證共享變量的原子性？