併發程式設計的優缺點

你聽___發表於2018-04-30
程式設計

併發程式設計的優缺點

一直以來併發程式設計對於剛入行的小白來說總是覺得高深莫測，於是乎，就誕生了想寫點東西記錄下，以提升理解和堆併發程式設計的認知。為什麼需要用的併發？凡事總有好壞兩面，之間的trade-off是什麼，也就是說併發程式設計具有哪些缺點？以及在進行併發程式設計時應該瞭解和掌握的概念是什麼？這篇文章主要以這三個問題來談一談。

1. 為什麼要用到併發

一直以來，硬體的發展極其迅速，也有一個很著名的"摩爾定律"，可能會奇怪明明討論的是併發程式設計為什麼會扯到了硬體的發展，這其中的關係應該是多核CPU的發展為併發程式設計提供的硬體基礎。摩爾定律並不是一種自然法則或者是物理定律，它只是基於認為觀測資料後，對未來的一種預測。按照所預測的速度，我們的計算能力會按照指數級別的速度增長，不久以後會擁有超強的計算能力，正是在暢想未來的時候，2004年，Intel宣佈4GHz晶片的計劃推遲到2005年，然後在2004年秋季，Intel宣佈徹底取消4GHz的計劃，也就是說摩爾定律的有效性超過了半個世紀戛然而止。但是，聰明的硬體工程師並沒有停止研發的腳步，他們為了進一步提升計算速度，而不是再追求單獨的計算單元，而是將多個計算單元整合到了一起，也就是形成了多核CPU。短短十幾年的時間，家用型CPU,比如Intel i7就可以達到4核心甚至8核心。而專業伺服器則通常可以達到幾個獨立的CPU，每一個CPU甚至擁有多達8個以上的核心。因此，摩爾定律似乎在CPU核心擴充套件上繼續得到體驗。因此，多核的CPU的背景下，催生了併發程式設計的趨勢，通過併發程式設計的形式可以將多核CPU的計算能力發揮到極致，效能得到提升。

頂級電腦科學家Donald Ervin Knuth如此評價這種情況：在我看來，這種現象（併發）或多或少是由於硬體設計者無計可施了導致的，他們將摩爾定律的責任推給了軟體開發者。

另外，在特殊的業務場景下先天的就適合於併發程式設計。比如在影象處理領域，一張1024X768畫素的圖片，包含達到78萬6千多個畫素。即時將所有的畫素遍歷一邊都需要很長的時間，面對如此複雜的計算量就需要充分利用多核的計算的能力。又比如當我們在網上購物時，為了提升響應速度，需要拆分，減庫存，生成訂單等等這些操作，就可以進行拆分利用多執行緒的技術完成。面對複雜業務模型，並行程式會比序列程式更適應業務需求，而併發程式設計更能吻合這種業務拆分 。正是因為這些優點，使得多執行緒技術能夠得到重視，也是一名CS學習者應該掌握的：

  • 充分利用多核CPU的計算能力；
  • 方便進行業務拆分，提升應用效能

2. 併發程式設計有哪些缺點

多執行緒技術有這麼多的好處，難道就沒有一點缺點麼，就在任何場景下就一定適用麼？很顯然不是。

2.1 頻繁的上下文切換

時間片是CPU分配給各個執行緒的時間，因為時間非常短，所以CPU不斷通過切換執行緒，讓我們覺得多個執行緒是同時執行的，時間片一般是幾十毫秒。而每次切換時，需要儲存當前的狀態起來，以便能夠進行恢復先前狀態，而這個切換時非常損耗效能，過於頻繁反而無法發揮出多執行緒程式設計的優勢。通常減少上下文切換可以採用無鎖併發程式設計，CAS演算法，使用最少的執行緒和使用協程。

  • 無鎖併發程式設計：可以參照concurrentHashMap鎖分段的思想，不同的執行緒處理不同段的資料，這樣在多執行緒競爭的條件下，可以減少上下文切換的時間。

  • CAS演算法，利用Atomic下使用CAS演算法來更新資料，使用了樂觀鎖，可以有效的減少一部分不必要的鎖競爭帶來的上下文切換

  • 使用最少執行緒：避免建立不需要的執行緒，比如任務很少，但是建立了很多的執行緒，這樣會造成大量的執行緒都處於等待狀態

  • 協程：在單執行緒裡實現多工的排程，並在單執行緒裡維持多個任務間的切換

由於上下文切換也是個相對比較耗時的操作，所以在"java併發程式設計的藝術"一書中有過一個實驗，併發累加未必會比序列累加速度要快。 可以使用Lmbench3測量上下文切換的時長 vmstat測量上下文切換次數

2.2 執行緒安全

多執行緒程式設計中最難以把握的就是臨界區執行緒安全問題，稍微不注意就會出現死鎖的情況，一旦產生死鎖就會造成系統功能不可用。

public class DeadLockDemo {
    private static String resource_a = "A";
    private static String resource_b = "B";

    public static void main(String[] args) {
        deadLock();
    }

    public static void deadLock() {
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (resource_a) {
                    System.out.println("get resource a");
                    try {
                        Thread.sleep(3000);
                        synchronized (resource_b) {
                            System.out.println("get resource b");
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (resource_b) {
                    System.out.println("get resource b");
                    synchronized (resource_a) {
                        System.out.println("get resource a");
                    }
                }
            }
        });
        threadA.start();
        threadB.start();

    }
}
複製程式碼

在上面的這個demo中，開啟了兩個執行緒threadA, threadB,其中threadA佔用了resource_a, 並等待被threadB釋放的resource _b。threadB佔用了resource _b正在等待被threadA釋放的resource _a。因此threadA,threadB出現執行緒安全的問題，形成死鎖。同樣可以通過jps,jstack證明這種推論：

"Thread-1":
  waiting to lock monitor 0x000000000b695360 (object 0x00000007d5ff53a8, a java.lang.String),
  which is held by "Thread-0"
"Thread-0":
  waiting to lock monitor 0x000000000b697c10 (object 0x00000007d5ff53d8, a java.lang.String),
  which is held by "Thread-1"

Java stack information for the threads listed above:
===================================================
"Thread-1":
        at learn.DeadLockDemo$2.run(DeadLockDemo.java:34)
        - waiting to lock <0x00000007d5ff53a8(a java.lang.String)
        - locked <0x00000007d5ff53d8(a java.lang.String)
        at java.lang.Thread.run(Thread.java:722)
"Thread-0":
        at learn.DeadLockDemo$1.run(DeadLockDemo.java:20)
        - waiting to lock <0x00000007d5ff53d8(a java.lang.String)
        - locked <0x00000007d5ff53a8(a java.lang.String)
        at java.lang.Thread.run(Thread.java:722)

Found 1 deadlock.
複製程式碼

如上所述，完全可以看出當前死鎖的情況。

那麼，通常可以用如下方式避免死鎖的情況：

  1. 避免一個執行緒同時獲得多個鎖；
  2. 避免一個執行緒在鎖內部佔有多個資源，儘量保證每個鎖只佔用一個資源；
  3. 嘗試使用定時鎖，使用lock.tryLock(timeOut)，當超時等待時當前執行緒不會阻塞；
  4. 對於資料庫鎖，加鎖和解鎖必須在一個資料庫連線裡，否則會出現解鎖失敗的情況

所以，如何正確的使用多執行緒程式設計技術有很大的學問，比如如何保證執行緒安全，如何正確理解由於JMM記憶體模型在原子性，有序性，可見性帶來的問題，比如資料髒讀，DCL等這些問題（在後續篇幅會講述）。而在學習多執行緒程式設計技術的過程中也會讓你收穫頗豐。

3. 應該瞭解的概念

3.1 同步VS非同步

同步和非同步通常用來形容一次方法呼叫。同步方法呼叫一開始，呼叫者必須等待被呼叫的方法結束後，呼叫者後面的程式碼才能執行。而非同步呼叫，指的是，呼叫者不用管被呼叫方法是否完成，都會繼續執行後面的程式碼，當被呼叫的方法完成後會通知呼叫者。比如，在超時購物，如果一件物品沒了，你得等倉庫人員跟你調貨，直到倉庫人員跟你把貨物送過來，你才能繼續去收銀臺付款，這就類似同步呼叫。而非同步呼叫了，就像網購，你在網上付款下單後，什麼事就不用管了，該幹嘛就幹嘛去了，當貨物到達後你收到通知去取就好。

3.2 併發與並行

併發和並行是十分容易混淆的概念。併發指的是多個任務交替進行，而並行則是指真正意義上的“同時進行”。實際上，如果系統內只有一個CPU，而使用多執行緒時，那麼真實系統環境下不能並行，只能通過切換時間片的方式交替進行，而成為併發執行任務。真正的並行也只能出現在擁有多個CPU的系統中。

3.3 阻塞和非阻塞

阻塞和非阻塞通常用來形容多執行緒間的相互影響，比如一個執行緒佔有了臨界區資源，那麼其他執行緒需要這個資源就必須進行等待該資源的釋放，會導致等待的執行緒掛起，這種情況就是阻塞，而非阻塞就恰好相反，它強調沒有一個執行緒可以阻塞其他執行緒，所有的執行緒都會嘗試地往前執行。

3.4 臨界區

臨界區用來表示一種公共資源或者說是共享資料，可以被多個執行緒使用。但是每個執行緒使用時，一旦臨界區資源被一個執行緒佔有，那麼其他執行緒必須等待。

相關文章