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

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

01、前言

先讓我吐一句肺腑之言吧，不說出來會憋出內傷的。《Java 并發編程實戰》這本書太特么枯燥了，盡管它被奉為并發編程當中的經典之作，但我還是忍不住。因為第四章“對象的組合”我整整啃了兩周的時間，才啃出來點肉絲。

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

請隨我來，我盡量寫得有趣點。

02、線程安全類

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

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

03、非線程安全的對象

之前我們談了如何設計一個線程安全的類。如果類是安全的，那么它作為對象使用的時候就是線程安全的。但如果一個類不是線程安全的，它作為對象使用的時候怎么保證是線程安全的呢？

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

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 的源碼，你會發現，它之所以是線程安全的，就是采用的這種監視器模式

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

假如現在有一個線程安全的類，比如之前提到的 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 的。因此，這種做法不具有普適性。

05、最后

站在我的角度來看，《Java 并發編程實戰》的第四章“對象的組合”寫得爛透了。導致我在寫這篇文章的時候感覺到萬分的痛苦。希望下一章不要寫的這么爛。

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

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

微信搜索「*沉默王×××Java 并發編程實戰**」即可獲取該書的電子版（推薦購買紙質書）。