Java：併發不易，先學會用

0一、咱們爲何要學習併發？

個人腦殼沒有被如來佛祖開過光，因此喜歡一件事接着一件事的想，作不到「一腦兩用」。但有些大佬就不同，好比說諸葛亮，就可以一邊想着琴譜一邊談着彈着琴，還能夾帶着盤算出司馬懿退兵後的打算。

諸葛大佬就有着超強的「併發」能力啊。換作是我，面對司馬懿的千萬大軍，不只彈不了琴，弄很差還被嚇得屁滾尿流。

每一個人都只有一個腦子，就像電腦只有一個CPU同樣。但一個腦子並不意味着不能「一腦兩用」，關鍵就在於腦子有沒有「併發」的能力。

腦子要是有了併發能力，那真的是厲害到飛起啊，想一想司馬懿被氣定神閒的諸葛大佬嚇跑的樣子就知道了。

若是想學習Java工程化、高性能及分佈式、深刻淺出。微服務、Spring，MyBatis，Netty源碼分析的朋友能夠加個人Java高級交流：854630135，羣裏有阿里大牛直播講解技術，以及Java大型互聯網技術的視頻免費分享給你們。

對於程序來講，若是具備併發的能力，效率就可以大幅度地提高。你必定註冊過很多網站，收到過很多驗證碼，若是網站的服務器端在發送驗證碼的時候，沒有專門起一個線程來處理（併發），假如網絡很差發生阻塞的話，那服務器端豈不是要從天亮等到天黑才知道你有沒有收到驗證碼？若是就你一個用戶也就算了，但假若有一百個用戶呢？這一百個用戶難道也要在那傻傻地等着，那真要等到花都謝了。

可想而知，併發編程是多麼的重要！何況，懂不懂Java虛擬機和會不會併發編程，幾乎是斷定一個Java開發人員是否是高手的不三法則。因此要想掙得多，還得會併發啊！

0二、併發第一步，建立一個線程

一般，啓動一個程序，就至關於起了一個進程。每一個電腦都會運行不少程序，因此你會在進程管理器中看到不少進程。你會說，這不廢話嗎？

不不不，在我剛學習編程的很長一段時間內，我都想固然地覺得這些進程就是線程；但後來我知道不是那麼回事兒。一個進程裏，可能會有不少線程在運行，也可能只有一個。

main函數其實就是一個主線程。咱們能夠在這個主線程當中建立不少其餘的線程。來看下面這段代碼。

public class Wanger {
 public static void main(String[] args) {
 for (int i = 0; i < 10; i++) {
 Thread t = new Thread(new Runnable() {
 
 @Override
 public void run() {
 System.out.println("我叫" + Thread.currentThread().getName() + "，我超喜歡XX的寫做風格");
 }
 });
 t.start();
 }
 }
}

建立線程最經常使用的方式就是聲明一個實現了Runnable接口的匿名內部類；而後將它做爲建立Thread對象的參數；再而後調用Thread對象的start()方法進行啓動。運行的結果以下。

我叫Thread-1，我超喜歡XX的寫做風格
我叫Thread-3，我超喜歡XX的寫做風格
我叫Thread-2，我超喜歡XX的寫做風格
我叫Thread-0，我超喜歡XX的寫做風格
我叫Thread-5，我超喜歡XX的寫做風格
我叫Thread-4，我超喜歡XX的寫做風格
我叫Thread-6，我超喜歡XX的寫做風格
我叫Thread-7，我超喜歡XX的寫做風格
我叫Thread-8，我超喜歡XX的寫做風格
我叫Thread-9，我超喜歡XX的寫做風格

從運行的結果中能夠看得出來，線程的執行順序不是從0到9的，而是有必定的隨機性。這是由於Java的併發是搶佔式的，線程0雖然建立得最先，但它的「爭寵」能力卻通常，上位得比較艱辛。

0三、併發第二步，建立線程池

java.util.concurrent.Executors類提供了一系列工廠方法用於建立線程池，可把多個線程放在一塊兒進行更高效地管理。示例以下。

public class Wanger {
 public static void main(String[] args) {
 ExecutorService executorService = Executors.newCachedThreadPool();
 for (int i = 0; i < 10; i++) {
 Runnable r = new Runnable() {
 @Override
 public void run() {
 System.out.println("我叫" + Thread.currentThread().getName() + "，我超喜歡沉默王二的寫做風格");
 }
 };
 executorService.execute(r);
 }
 executorService.shutdown();
 }
}

運行的結果以下。

我叫pool-1-thread-2，我超喜歡XX的寫做風格
我叫pool-1-thread-4，我超喜歡XX的寫做風格
我叫pool-1-thread-5，我超喜歡XX的寫做風格
我叫pool-1-thread-3，我超喜歡XX的寫做風格
我叫pool-1-thread-4，我超喜歡XX的寫做風格
我叫pool-1-thread-1，我超喜歡XX的寫做風格
我叫pool-1-thread-7，我超喜歡XX的寫做風格
我叫pool-1-thread-6，我超喜歡XX的寫做風格
我叫pool-1-thread-5，我超喜歡XX的寫做風格
我叫pool-1-thread-6，我超喜歡XX的寫做風格

Executors的newCachedThreadPool()方法用於建立一個可緩存的線程池，調用該線程池的方法execute()能夠重用之前的線程，只要該線程可用；好比說，pool-1-thread-四、pool-1-thread-5和pool-1-thread-6就獲得了重用的機會。我能想到的最佳形象代言人就是女皇武則天。

若是沒有可用的線程，就會建立一個新線程並添加到池中。固然了，那些60秒內尚未被使用的線程也會從緩存中移除。

另外，Executors的newFiexedThreadPool(int num)方法用於建立固定數目線程的線程池；newSingleThreadExecutor()方法用於建立單線程化的線程池（你能想到它應該使用的場合嗎？）。

可是，故事要轉折了。阿里巴巴的Java開發手冊（可在「沉默王二」公衆號的後臺回覆關鍵字「Java」獲取）中明確地指出，不容許使用Executors來建立線程池。

 

不能使用Executors建立線程池，那麼該怎麼建立線程池呢？

直接調用ThreadPoolExecutor的構造函數來建立線程池唄。其實Executors就是這麼作的，只不過沒有對BlockQueue指定容量。咱們須要作的就是在建立的時候指定容量。代碼示例以下。

ExecutorService executor = new ThreadPoolExecutor(10, 10,
 60L, TimeUnit.SECONDS,
 new ArrayBlockingQueue(10));

0四、併發第三步，解決共享資源競爭的問題

有一次，我陪家人在商場裏面逛街，出電梯的時候有一個傻叉非要搶着進電梯。女兒的小推車就壓到了那傻叉的腳上，他居然不依不饒地指着個人鼻子叫囂。我直接一拳就打在他的鼻子上，隨後咱們就糾纏在了一塊兒。

這件事情說明了什麼問題呢？第一，遇到不講文明不知道「先出後進」（LIFO）規則的傻叉真的很麻煩；第二，競爭共享資源的時候，弄很差要拳腳相向。

在Java中，解決共享資源競爭問題的首個解決方案就是使用關鍵字synchronized。當線程執行被synchronized保護的代碼片斷的時候，會對這段代碼進行上鎖，其餘調用這段代碼的線程會被阻塞，直到鎖被釋放。

下面這段代碼使用ThreadPoolExecutor建立了一個線程池，池裏面的每一個線程會對共享資源count進行+1操做。如今，閉上眼想想，當1000個線程執行結束後，count的值會是多少呢？

public class Wanger {
 public static int count = 0;
 
 public static int getCount() {
 return count;
 }
 
 public static void addCount() {
 count++;
 }
 
 public static void main(String[] args) {
 ExecutorService executorService = new ThreadPoolExecutor(10, 1000,
 60L, TimeUnit.SECONDS,
 new ArrayBlockingQueue<Runnable>(10));
 for (int i = 0; i < 1000; i++) {
 Runnable r = new Runnable() {
 @Override
 public void run() {
 Wanger.addCount();
 }
 };
 executorService.execute(r);
 }
 executorService.shutdown();
 System.out.println(Wanger.count);
 }
}

事實上，共享資源count的值頗有多是99六、998，但不多會是1000。爲何呢？

由於一個線程正在寫這個變量的時候，另一個線程可能正在讀這個變量，或者正在寫這個變量。這個變量就變成了一個「不肯定狀態」的數據。這個變量必須被保護起來。

一般的作法就是在改變這個變量的addCount()方法上加上synchronized關鍵字——保證線程在訪問這個變量的時候有序地進行排隊。

示例以下：

public synchronized static void addCount() {
 count++;
}

還有另外的一種經常使用方法——讀寫鎖。分爲讀鎖和寫鎖，多個讀鎖不互斥，讀鎖與寫鎖互斥，由Java虛擬機控制。若是代碼容許不少線程同時讀，但不能同時寫，就上讀鎖；若是代碼不容許同時讀，而且只能有一個線程在寫，就上寫鎖。

讀寫鎖的接口是ReadWriteLock，具體實現類是 ReentrantReadWriteLock。synchronized屬於互斥鎖，任什麼時候候只容許一個線程的讀寫操做，其餘線程必須等待；而ReadWriteLock容許多個線程得到讀鎖，但只容許一個線程得到寫鎖，效率相對較高一些。

咱們先使用枚舉建立一個讀寫鎖的單例。代碼以下：

public enum Locker {
 INSTANCE;
 private static final ReadWriteLock lock = new ReentrantReadWriteLock();
 public Lock writeLock() {
 return lock.writeLock();
 }
}

再在addCount()方法中對count++;上鎖。示例以下。

public static void addCount() {
 // 上鎖
 Lock writeLock = Locker.INSTANCE.writeLock();
 writeLock.lock();
 count++;
 // 釋放鎖
 writeLock.unlock();
}

使用讀寫鎖的時候，切記最後要釋放鎖。

0五、最後

併發編程難學嗎？說實話，真的不太容易。來看一下王寶令老師總結的思惟導圖就能知道。

 

但你也知道，「冰凍三尺非一日之寒」，學習是一件按部就班的事情。只要你學會了怎麼建立一個線程，學會了怎麼建立線程池，學會了怎麼解決共享資源競爭的問題，你已經在併發編程的領域裏邁出去了一大步。

歡迎工做一到八年的Java工程師朋友們加入Java高級交流：854630135

本羣提供免費的學習指導 架構資料 以及免費的解答

不懂得問題均可以在本羣提出來 以後還會有直播平臺和講師直接交流噢