摘要:什么時候會出現線程不安全操作并非原子。只有單個組件,且它是線程安全的。這種情況下,就是的線程安全實際是委托給了整個表現出了線程安全。
當多個線程去訪問某個類時,如果類會表現出我們預期出現的行為,那么可以稱這個類是線程安全的。
什么時候會出現線程不安全?
操作并非原子。多個線程執行某段代碼,如果這段代碼產生的結果受不同線程之間的執行時序影響,而產生非預期的結果,即發生了競態條件,就會出現線程不安全;
常見場景:
count++。它本身包含三個操作,讀取、修改、寫入,多線程時,由于線程執行的時序不同,有可能導致兩個線程執行后count只加了1,而原有的目標確實希望每次執行都加1;
單例。多個線程可能同時執行到instance == null成立,然后新建了兩個對象,而原有目標是希望這個對象永遠只有一個;
public MyObj getInstance(){ if (instance == null){ instance = new MyObj(); } return instance }解決方式是:當前線程在操作這段代碼時,其它線程不能對進行操作
常見方案:
單個狀態使用 java.util.concurrent.atomic包中的一些原子變量類,注意如果是多個狀態就算每個操作是原子的,復合使用的時候并不是原子的;
加鎖。比如使用 synchronized 包圍對應代碼塊,保證多線程之間是互斥的,注意應盡可能的只包含在需要作為原子處理的代碼塊上;
synchronized的可重入性當線程要去獲取它自己已經持有的鎖是會成功的,這樣的鎖是可重入的,synchronized是可重入的
class Paxi { public synchronized void sayHello(){ System.out.println("hello"); } } class MyClass extends Paxi{ public synchronized void dosomething(){ System.out.println("do thing .."); super.sayHello(); System.out.println("over"); } }它的輸出為
do thing .. hello over
修改不可見。讀線程無法感知到其它線程寫入的值
常見場景:
重排序。在沒有同步的情況下,編譯器、處理器以及運行時等都有可能對操作的執行順序進行調整,即寫的代碼順序和真正的執行順序不一樣,導致讀到的是一個失效的值
讀取long、double等類型的變量。JVM允許將一個64位的操作分解成兩個32位的操作,讀寫在不同的線程中時,可能讀到錯誤的高低位組合
常見方案:
不同步的情況下如何做到線程安全?加鎖。所有線程都能看到共享變量的最新值;
使用Volatile關鍵字聲明變量。只要對這個變量產生了寫操作,那么所有的讀操作都會看到這個修改;
注意:Volatile并不能保證操作的原子性,比如count++操作同樣有風險,它僅保證讀取時返回最新的值。使用的好處在于訪問Volatile變量并不會執行加鎖操作,也就不會阻塞線程。
線程封閉。即僅在單線程內訪問數據,線程封閉技術有以下幾種:
Ad-hoc線程封閉。即靠自己寫程序來實現,比如保證程序只在單線程上對volatile進行 讀取-修改-寫入
棧封閉。所有的操作都反生執行線程的棧中,比如在方法中的一個局部變量
ThreadLocal類。內部維護了每個線程和變量的一個獨立副本
只讀共享。即使用不可變的對象。
使用final去修飾字段,這樣這個字段的“值”是不可改變的
注意final如果修飾的是一個對象引用,比如set,它本身包含的值是可變的
創建一個不可變的類,來包含多個可變的數據。
class OneValue{ //創建不可變對象,創建之后無法修改,事實上這里也沒有提供修改的方法 private final BigInteger last; private final BigInteger[] lastfactor; public OneValue(BigInteger i,BigInteger[] lastfactor){ this.last=i; this.lastfactor=Arrays.copy(lastfactor,lastfactor.length); } public BigInteger[] getF(BigInteger i){ if(last==null || !last.equals(i)){ return null; }else{ return Arrays.copy(lastfactor,lastfactor.length) } } } class MyService { //volatile使得cache一經更改,就能被所有線程感知到 private volatile OneValue cache=new OneValue(null,null); public void handle(BigInteger i){ BigInteger[] lastfactor=cache.getF(i); if(lastfactor==null){ lastfactor=factor(i); //每次都封裝最新的值 cache=new OneValue(i,lastfactor) } nextHandle(lastfactor) } }如何構造線程安全的類?
實例封閉。將一個對象封裝到另一個對象中,這樣能夠訪問被封裝對象的所有代碼路徑都是已知的,通過合適的加鎖策略可以確保被封裝對象的訪問是線程安全的。
java中的Collections.synchronizedList使用的原理就是這樣。部分代碼為
public staticList synchronizedList(List list) { return (list instanceof RandomAccess ? new SynchronizedRandomAccessList<>(list) : new SynchronizedList<>(list)); }
SynchronizedList的實現,注意此處用到的mutex是內置鎖
static class SynchronizedListextends SynchronizedCollection implements List { private static final long serialVersionUID = -7754090372962971524L; final List list; public E get(int index) { synchronized (mutex) {return list.get(index);} } public E set(int index, E element) { synchronized (mutex) {return list.set(index, element);} } public void add(int index, E element) { synchronized (mutex) {list.add(index, element);} } public E remove(int index) { synchronized (mutex) {return list.remove(index);} } }
mutex的實現
static class SynchronizedCollectionimplements Collection , >Serializable { private static final long serialVersionUID = 3053995032091335093L; final Collection c; // Backing Collection final Object mutex; // Object on which to synchronize SynchronizedCollection(Collection c) { if (c==null) throw new NullPointerException(); this.c = c; mutex = this; // mutex實際上就是對象本身 }
把線程安全性委托給線程安全的類
什么是監視器模式java的監視器模式,將對象所有可變狀態都封裝起來,并由對象自己的內置鎖來保護,即是一種實例封閉。比如HashTable就是運用的監視器模式。它的get操作就是用的synchronized,內置鎖,來實現的線程安全
public synchronized V get(Object key) { Entry tab[] = table; int hash = hash(key); int index = (hash & 0x7FFFFFFF) % tab.length; for (Entrye = tab[index] ; e != null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { return e.value; } } return null; }
內置鎖
每個對象都有內置鎖。內置鎖也稱為監視器鎖。或者可以簡稱為監視器
線程執行一個對象的用synchronized修飾的方法時,會自動的獲取這個對象的內置鎖,方法返回時自動釋放內置鎖,執行過程中就算拋出異常也會自動釋放。
以下兩種寫法等效:
synchronized void myMethdo(){ //do something } void myMethdo(){ synchronized(this){ //do somthding } }
> [官方文檔](https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html)
私有鎖
public class PrivateLock{ private Object mylock = new Object(); //私有鎖 void myMethod(){ synchronized(mylock){ //do something } } }
它也可以用來保護對象,相對內置鎖,優勢在于私有鎖可以有多個,同時可以讓客戶端代碼顯示的獲取私有鎖
類鎖
在staic方法上修飾的,一個類的所有對象共用一把鎖
視情況而定。
只有單個組件,且它是線程安全的。
public class DVT{ private final ConcurrentMaplocations; private final Map unmodifiableMap; public DVT(Map points){ locations=new ConcurrentHashMap (points); unmodifiableMap=Collections.unmodifiableMap(locations); } public Map getLocations(){ return unmodifiableMap; } public Point getLocation(String id){ return locations.get(id); } public void setLocation(String id,int x,int y){ if(locations.replace(id,new Point(x,y))==null){ throw new IllegalArgumentException("invalid "+id); } } } public class Point{ public final int x,y; public Point(int x,int y){ this.x=x; this.y=y; } }
線程安全性分析
Point類本身是無法更改的,所以它是線程安全的,DVT返回的Point方法也是線程安全的
DVT的方法getLocations返回的對象是不可修改的,是線程安全的
setLocation實際操作的是ConcurrentHashMap它也是線程安全的
綜上,DVT的安全交給了‘locations’,它本身是線程安全的,DVT本身雖沒有任何顯示的同步,也是線程安全。這種情況下,就是DVT的線程安全實際是委托給了‘locations’,整個DVT表現出了線程安全。
線程安全性委托給了多個狀態變量
只要多個狀態變量之間彼此獨立,組合的類并不會在其包含的多個狀態變量上增加不變性。依賴的增加則無法保證線程安全
public class NumberRange{ private final AtomicInteger lower = new AtomicInteger(0); private final AtomicInteger upper = new AtomicInteger(0); public void setLower(int i){ //先檢查后執行,存在隱患 if (i>upper.get(i)){ throw new IllegalArgumentException("can not .."); } lower.set(i); } public void setUpper(int i){ //先檢查后執行,存在隱患 if(i setLower和setUpper都是‘先檢查后執行’的操作,但是沒有足夠的加鎖機制保證操作的原子性。假設原始范圍是(0,10),一個線程調用 setLower(5),一個設置setUpper(4)錯誤的執行時序將可能導致結果為(5,4)如何對現有的線程安全類進行擴展?假設需要擴展的功能為 ‘沒有就添加’。直接修改原有的代碼。但通常沒有辦法修改源代碼
繼承。繼承原有的代碼,添加新的功能。但是同步策略保存在兩份文件中,如果底層同步策略變更,很容易出問題
組合。將類放入一個輔助類中,通過輔助類的操作代碼。
比如擴展 Collections.synchronizedList。期間需要注意鎖的機制,錯誤方式為public class ListHelper{ public List list=Collections.synchronizedList(new ArrayList ()); ... public synchronized boolean putIfAbsent(E x){ boolean absent = !list.contains(x); if(absent){ list.add(x); } return absent; } } 這里的putIfAbsent并不能帶來線程安全,原因是list的內置鎖并不是ListHelper,也就是putIfAbsent相對list的其它方法并不是原子的。Collections.synchronizedList是鎖在list本身的,正確方式為
public boolean putIfAbsent(E x){ synchronized(list){ boolean absent = !list.contains(x); if(absent){ list.add(x); } return absent; } }另外可以不管要操作的類是否是線程安全,對類統一添加一層額外的鎖。 實現參考Collections.synchronizedList方法
文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。
轉載請注明本文地址:http://specialneedsforspecialkids.com/yun/72400.html
摘要:又是金三銀四的時候,我希望這份面試題能夠祝你一臂之力自我和項目相關自我介紹你覺得自己的優點是你覺得自己有啥缺點你有哪些你為什么要離開上家公司你上家公司在,我們公司在,離這么遠為什么要選擇我們這里上家公司的同事和領導是怎么評價你的介紹下你的上 又是金三銀四的時候,我希望這份面試題能夠祝你一臂之力! 自我和項目相關 1、自我介紹 2、你覺得自己的優點是?你覺得自己有啥缺點? 3、你有哪些 ...
摘要:以下為大家整理了阿里巴巴史上最全的面試題,涉及大量面試知識點和相關試題。的內存結構,和比例。多線程多線程的幾種實現方式,什么是線程安全。點擊這里有一套答案版的多線程試題。線上系統突然變得異常緩慢,你如何查找問題。 以下為大家整理了阿里巴巴史上最全的 Java 面試題,涉及大量 Java 面試知識點和相關試題。 JAVA基礎 JAVA中的幾種基本數據類型是什么,各自占用多少字節。 S...
摘要:線程安全的概念什么時候線程不安全怎樣做到線程安全怎么擴展線程安全的類對線程安全的支持對線程安全支持有哪些中的線程池的使用與中線程池的生命周期與線程中斷中的鎖中常見死鎖與活鎖的實例線程同步機制顯示鎖使用與原理原理剖析原理中的與原理偏向鎖狀態 showImg(https://segmentfault.com/img/bVblUE9?w=1354&h=1660); 線程安全的概念 showI...
摘要:但是單核我們還是要應用多線程,就是為了防止阻塞。多線程可以防止這個問題,多條線程同時運行,哪怕一條線程的代碼執行讀取數據阻塞,也不會影響其它任務的執行。 1、多線程有什么用?一個可能在很多人看來很扯淡的一個問題:我會用多線程就好了,還管它有什么用?在我看來,這個回答更扯淡。所謂知其然知其所以然,會用只是知其然,為什么用才是知其所以然,只有達到知其然知其所以然的程度才可以說是把一個知識點...
摘要:目錄介紹問題匯總具體問題好消息博客筆記大匯總年月到至今,包括基礎及深入知識點,技術博客,學習筆記等等,還包括平時開發中遇到的匯總,當然也在工作之余收集了大量的面試題,長期更新維護并且修正,持續完善開源的文件是格式的同時也開源了生活博客,從年 目錄介紹 00.Java問題匯總 01.具體問題 好消息 博客筆記大匯總【16年3月到至今】,包括Java基礎及深入知識點,Android技...
閱讀 3017·2023-04-26 00:32
閱讀 498·2019-08-30 15:52
閱讀 2105·2019-08-30 15:52
閱讀 3347·2019-08-30 15:44
閱讀 3280·2019-08-30 14:09
閱讀 1416·2019-08-29 15:15
閱讀 3390·2019-08-28 18:12
閱讀 1074·2019-08-26 13:55