不是線程的安全

面試官問：“什么是線程安全”，如果你不能很好的回答，那就請往下看吧。

論語中有句話叫“學而優(yōu)則仕”，相信很多人都覺得是“學習好了可以做官”。然而，這樣理解卻是錯的。切記望文生義。

同理，“線程安全”也不是指線程的安全，而是指內存的安全。為什么如此說呢?這和操作系統(tǒng)有關。

[[265101]]

在每個進程的內存空間中都會有一塊特殊的公共區(qū)域，通常稱為堆(內存)。進程內的所有線程都可以訪問到該區(qū)域，這就是造成問題的潛在原因。

假設某個線程把數(shù)據(jù)處理到一半，覺得很累，就去休息了一會，回來準備接著處理，卻發(fā)現(xiàn)數(shù)據(jù)已經(jīng)被修改了，不是自己離開時的樣子了?？赡鼙黄渌€程修改了。

比如把你住的小區(qū)看作一個進程，小區(qū)里的道路/綠化等就屬于公共區(qū)域。你拿1萬塊錢往地上一扔，就回家睡覺去了。睡醒后你打算去把它撿回來，發(fā)現(xiàn)錢已經(jīng)不見了?？赡鼙粍e人拿走了。

因為公共區(qū)域人來人往，你放的東西在沒有看管措施時，一定是不安全的。內存中的情況亦然如此。

所以線程安全指的是，在堆內存中的數(shù)據(jù)由于可以被任何線程訪問到，在沒有限制的情況下存在被意外修改的風險。

即堆內存空間在沒有保護機制的情況下，對多線程來說是不安全的地方，因為你放進去的數(shù)據(jù)，可能被別的線程“破壞”。

那我們該怎么辦呢?解決問題的過程其實就是一個取舍的過程，不同的解決方案有不同的側重點。

私有的東西就不該讓別人知道

現(xiàn)實中很多人都會把1萬塊錢藏著掖著，不讓無關的人知道，所以根本不可能扔到大馬路上。因為這錢是你的私有物品。

在程序中也是這樣的，所以操作系統(tǒng)會為每個線程分配屬于它自己的內存空間，通常稱為棧內存，其它線程無權訪問。這也是由操作系統(tǒng)保障的。

如果一些數(shù)據(jù)只有某個線程會使用，其它線程不能操作也不需要操作，這些數(shù)據(jù)就可以放入線程的棧內存中。較為常見的就是局部變量。

double avgScore(double[] scores) { 
 double sum = 0; 
 for (double score : scores) { 
 sum += score; 
 } 
 int count = scores.length; 
 double avg = sum / count; 
 return avg; 
} 

這里的變量sum，count，avg都是局部變量，它們都會被分配在線程棧內存中。

假如現(xiàn)在A線程來執(zhí)行這個方法，這些變量會在A的棧內存分配。與此同時，B線程也來執(zhí)行這個方法，這些變量也會在B的棧內存中分配。

也就是說這些局部變量會在每個線程的棧內存中都分配一份。由于線程的棧內存只能自己訪問，所以棧內存中的變量只屬于自己，其它線程根本就不知道。

就像每個人的家只屬于自己，其他人不能進來。所以你把1萬塊錢放到家里，其他人是不會知道的。且一般還會放到某個房間里，而不是仍在客廳的桌子上。

所以把自己的東西放到自己的私人地盤，是安全的，因為其他人無法知道。而且越隱私的地方越好。

大家不要搶，人人有份

相信聰明的你已經(jīng)發(fā)現(xiàn)，上面的解決方案是基于“位置”的。因為你放東西的“位置”只有你自己知道(或能到達)，所以東西是安全的，因此這份安全是由“位置”來保障的。

在程序里就對應于方法的局部變量。局部變量之所以是安全的，就是因為定義它的“位置”是在方法里。這樣一來安全是達到了，但是它的使用范圍也就被限制在這個方法里了，其它方法想用也不用了啦。

現(xiàn)實中往往會有一個變量需要多個方法都能夠使用的情況，此時定義這個變量的“位置”就不能在方法里面了，而應該在方法外面。即從(方法的)局部變量變?yōu)?類的)成員變量，其實就是“位置”發(fā)生了變化。

那么按照主流編程語言的規(guī)定，類的成員變量不能再分配在線程的棧內存中，而應該分配在公共的堆內存中。其實也就是變量在內存中的“位置”發(fā)生了變化，由一個私有區(qū)域來到了公共區(qū)域。因此潛在的安全風險也隨之而來。

那怎么保證在公共區(qū)域的東西安全呢?答案就是，大家不要搶，人人有份。設想你在街頭免費發(fā)放礦泉水，來了1萬人，你卻只有1千瓶水，結果可想而知，一擁而上，場面失守。但如果你有10萬瓶水，大家一看，水多著呢，不用著急，一個個排著隊來，因為肯定會領到。

東西多了，自然就不值錢了，從另一個角度來說，也就安全了。大街上的共享單車，現(xiàn)在都很安全，因為太多了，到處都是，都長得一樣，所以連搞破壞的人都放棄了。因此要讓一個東西安全，就瘋狂的copy它吧。

回到程序里，要讓公共區(qū)域堆內存中的數(shù)據(jù)對于每個線程都是安全的，那就每個線程都拷貝它一份，每個線程只處理自己的這一份拷貝而不去影響別的線程的，這不就安全了嘛。相信你已經(jīng)猜到了，我要表達的就是ThreadLocal類了。

class StudentAssistant { 
 ThreadLocal<String> realName = new ThreadLocal<>(); 
 ThreadLocal<Double> totalScore = new ThreadLocal<>(); 
 String determineDegree() { 
 double score = totalScore.get(); 
 if (score >= 90) { 
 return "A"; 
 } 
 if (score >= 80) { 
 return "B"; 
 } 
 if (score >= 70) { 
 return "C"; 
 } 
 if (score >= 60) { 
 return "D"; 
 } 
 return "E"; 
 } 
 double determineOptionalcourseScore() { 
 double score = totalScore.get(); 
 if (score >= 90) { 
 return 10; 
 } 
 if (score >= 80) { 
 return 20; 
 } 
 if (score >= 70) { 
 return 30; 
 } 
 if (score >= 60) { 
 return 40; 
 } 
 return 60; 
 } 
} 

這個學生助手類有兩個成員變量，realName和totalScore，都是ThreadLocal類型的。每個線程在運行時都會拷貝一份存儲到自己的本地。

A線程運行的是“張三”和“90”，那么這兩個數(shù)據(jù)“張三”和“90”是存儲到A線程對象(Thread類的實例對象)的成員變量里去了。假設此時B線程也在運行，是“李四”和“85”，那么“李四”和“85”這兩個數(shù)據(jù)是存儲到了B線程對象(Thread類的實例對象)的成員變量里去了。

線程類(Thread)有一個成員變量，類似于Map類型的，專門用于存儲ThreadLocal類型的數(shù)據(jù)。從邏輯從屬關系來講，這些ThreadLocal數(shù)據(jù)是屬于Thread類的成員變量級別的。從所在“位置”的角度來講，這些ThreadLocal數(shù)據(jù)是分配在公共區(qū)域的堆內存中的。

說的直白一些，就是把堆內存中的一個數(shù)據(jù)復制N份，每個線程認領1份，同時規(guī)定好，每個線程只能玩自己的那份，不準影響別人的。

需要說明的是這N份數(shù)據(jù)都還是存儲在公共區(qū)域堆內存里的，經(jīng)常聽到的“線程本地”，是從邏輯從屬關系上來講的，這些數(shù)據(jù)和線程一一對應，仿佛成了線程自己“領地”的東西了。其實從數(shù)據(jù)所在“位置”的角度來講，它們都位于公共的堆內存中，只不過被線程認領了而已。這一點我要特地強調一下。

其實就像大街上的共享單車。原來只有1輛，大家搶著騎，老出問題。現(xiàn)在從這1輛復制出N輛，每人1輛，各騎各的，問題得解。共享單車就是數(shù)據(jù)，你就是線程。騎行期間，這輛單車從邏輯上來講是屬于你的，從所在位置上來講還是在大街上這個公共區(qū)域的，因為你發(fā)現(xiàn)每個小區(qū)大門口都貼著“共享單車，禁止入門”。哈哈哈哈。

共享單車是不是和ThreadLocal很像呀。再重申一遍，ThreadLocal就是，把一個數(shù)據(jù)復制N份，每個線程認領一份，各玩各的，互不影響。

只能看，不能摸

放在公共區(qū)域的東西，只是存在潛在的安全風險，并不是說一定就不安全。有些東西雖然也在公共區(qū)域放著，但也是十分安全的。比如你在大街上放一個上百噸的石頭雕像，就非常安全，因為大家都弄不動它。

再比如你去旅游時，經(jīng)常發(fā)現(xiàn)一些珍貴的東西，會被用鐵柵欄圍起來，上面掛一個牌子，寫著“只能看，不能摸”。當然可以國際化一點，“only look，don't touch”。這也是很安全的，因為光看幾眼是不可能看壞的。

回到程序里，這種情況就屬于，只能讀取，不能修改。其實就是常量或只讀變量，它們對于多線程是安全的，想改也改不了。

class StudentAssistant { 
 final double passScore = 60; 
} 

比如把及格分數(shù)設定為60分，在前面加上一個final，這樣所有線程都動不了它了。這就很安全了。

小節(jié)一下：以上三種解決方案，其實都是在“?；ㄕ?rdquo;。

***種，找個只有自己知道的地方藏起來，當然安全了。

第二種，每人復制1份，各玩各的，互不影響，當然也安全了。

第三種，更狠了，直接規(guī)定，只能讀取，禁止修改，當然也安全了。

是不是都在“避重就輕”呀。如果這三種方法都解決不了，該怎么辦呢?Don't worry，just continue reading。

沒有規(guī)則，那就先入為主

前面給出的三種方案，有點“理想化”了?，F(xiàn)實中的情況其實是非?；靵y嘈雜的，沒有規(guī)則的。

比如在中午高峰期你去飯店吃飯，進門后發(fā)現(xiàn)只剩一個空桌子了，你心想先去點餐吧，回來就坐這里吧。當你點完餐回來后，發(fā)現(xiàn)已經(jīng)被別人捷足先登了。

因為桌子是屬于公共區(qū)域的物品，任何人都可以坐，那就只能誰先搶到誰坐。雖然你在人群中曾多看了它一眼，但它并不會記住你容顏。

解決方法就不用我說了吧，讓一個人在那兒看著座位，其它人去點餐。這樣當別人再來的時候，你就可以理直氣壯的說，“不好意思，這個座位，我，已經(jīng)占了”。

我再次相信聰明的你已經(jīng)猜到了我要說的東西了，沒錯，就是(互斥)鎖。

回到程序里，如果公共區(qū)域(堆內存)的數(shù)據(jù)，要被多個線程操作時，為了確保數(shù)據(jù)的安全(或一致)性，需要在數(shù)據(jù)旁邊放一把鎖，要想操作數(shù)據(jù)，先獲取鎖再說吧。

假設一個線程來到數(shù)據(jù)跟前一看，發(fā)現(xiàn)鎖是空閑的，沒有人持有。于是它就拿到了這把鎖，然后開始操作數(shù)據(jù)，干了一會活，累了，就去休息了。

這時，又來了一個線程，發(fā)現(xiàn)鎖被別人持有著，按照規(guī)定，它不能操作數(shù)據(jù)，因為它無法得到這把鎖。當然，它可以選擇等待，或放棄，轉而去干別的。

***個線程之所以敢大膽的去睡覺，就是因為它手里拿著鎖呢，其它線程是不可能操作數(shù)據(jù)的。當它回來后繼續(xù)把數(shù)據(jù)操作完，就可以把鎖給釋放了。鎖再次回到空閑狀態(tài)，其它線程就可以來搶這把鎖了。還是誰先搶到鎖誰操作數(shù)據(jù)。

class ClassAssistant { 
 double totalScore = 60; 
 final Lock lock = new Lock(); 
 void addScore(double score) { 
 lock.obtain(); 
 totalScore += score; 
 lock.release(); 
 } 
 void subScore(double score) { 
 lock.obtain(); 
 totalScore -= score; 
 lock.release(); 
 } 
} 

假定一個班級的初始分數(shù)是60分，這個班級抽出10名學生來同時參加10個不同的答題節(jié)目，每個學生答對一次為班級加上5分，答錯一次減去5分。因為10個學生一起進行，所以這一定是一個并發(fā)情形。

因此加分和減分這兩個方法被并發(fā)的調用，它們共同操作總分數(shù)。為了保證數(shù)據(jù)的一致性，需要在每次操作前先獲取鎖，操作完成后再釋放鎖。

相信世界充滿愛，即使被傷害

再回到一開始的例子，假如你往地上扔1萬塊錢，是不是一定會丟呢?這要看情況了，如果是在人來人往的都市，可以說肯定會丟的。如果你跑到無人區(qū)扔地上，可以說肯定不會丟。

可以看到，都是把東西無保護的放到公共區(qū)域里，結果卻相差很大。這說明安全問題還和公共區(qū)域的環(huán)境狀況有關系。

比如我把數(shù)據(jù)放到公共區(qū)域的堆內存中，但是始終都只會有1個線程，也就是單線程模型，那這數(shù)據(jù)肯定是安全的。

再者說，2個線程操作同一個數(shù)據(jù)和200個線程操作同一個數(shù)據(jù)，這個數(shù)據(jù)的安全概率是完全不一樣的。肯定線程越多數(shù)據(jù)不安全的概率越大，線程越少數(shù)據(jù)不安全的概率越小。取個極限情況，那就是只有1個線程，那不安全概率就是0，也就是安全的。

可能你又猜到了我想表達的內容了，沒錯，就是CAS?？赡艽蠹矣X得既然鎖可以解決問題，那就用鎖得了，為啥又冒出了個CAS呢?

那是因為鎖的獲取和釋放是要花費一定代價的，如果在線程數(shù)目特別少的時候，可能根本就不會有別的線程來操作數(shù)據(jù)，此時你還要獲取鎖和釋放鎖，可以說是一種浪費。

針對這種“地廣人稀”的情況，專門提出了一種方法，叫CAS(Compare And Swap)。就是在并發(fā)很小的情況下，數(shù)據(jù)被意外修改的概率很低，但是又存在這種可能性，此時就用CAS。

假如一個線程操作數(shù)據(jù)，干了一半活，累了，想要去休息。(貌似今天的線程體質都不太好)。于是它記錄下當前數(shù)據(jù)的狀態(tài)(就是數(shù)據(jù)的值)，回家睡覺了。

醒來后打算繼續(xù)接著干活，但是又擔心數(shù)據(jù)可能被修改了，于是就把睡覺前保存的數(shù)據(jù)狀態(tài)拿出來和現(xiàn)在的數(shù)據(jù)狀態(tài)比較一下，如果一樣，說明自己在睡覺期間，數(shù)據(jù)沒有被人動過(當然也有可能是先被改成了其它，然后又改回來了，這就是ABA問題了)，那就接著繼續(xù)干。如果不一樣，說明數(shù)據(jù)已經(jīng)被修改了，那之前做的那些操作其實都白瞎了，就干脆放棄，從頭再重新開始處理一遍。

所以CAS這種方式適用于并發(fā)量不高的情況，也就是數(shù)據(jù)被意外修改的可能性較小的情況。如果并發(fā)量很高的話，你的數(shù)據(jù)一定會被修改，每次都要放棄，然后從頭再來，這樣反而花費的代價更大了，還不如直接加鎖呢。

這里再解釋下ABA問題，假如你睡覺前數(shù)據(jù)是5，醒來后數(shù)據(jù)還是5，并不能肯定數(shù)據(jù)沒有被修改過。可能數(shù)據(jù)先被修改成8然后又改回到5，只是你不知道罷了。對于這個問題，其實也很好解決，再加一個版本號字段就行了，并規(guī)定只要修改數(shù)據(jù)，必須使版本號加1。

這樣你睡覺前數(shù)據(jù)是5版本號是0，醒來后數(shù)據(jù)是5版本號是0，表明數(shù)據(jù)沒有被修改。如果數(shù)據(jù)是5版本號是2，表明數(shù)據(jù)被改動了2次，先改為其它，然后又改回到5。

我再次相信聰明的你已經(jīng)發(fā)現(xiàn)了，這里的CAS其實就是樂觀鎖，上一種方案里的獲取鎖和釋放鎖其實就是悲觀鎖。樂觀鎖持樂觀態(tài)度，就是假設我的數(shù)據(jù)不會被意外修改，如果修改了，就放棄，從頭再來。悲觀鎖持悲觀態(tài)度，就是假設我的數(shù)據(jù)一定會被意外修改，那干脆直接加鎖得了。