日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
LockSupport：一個很靈活的線程工具類

LockSupport是一個編程工具類，主要是為了阻塞和喚醒線程用的。使用它我們可以實(shí)現(xiàn)很多功能，今天主要就是對這個工具類的講解，希望對你有幫助：

創(chuàng)新互聯(lián)主營靈臺網(wǎng)站建設(shè)的網(wǎng)絡(luò)公司,主營網(wǎng)站建設(shè)方案,app開發(fā)定制,靈臺h5微信平臺小程序開發(fā)搭建,靈臺網(wǎng)站營銷推廣歡迎靈臺等地區(qū)企業(yè)咨詢

一、LockSupport簡介

1、LockSupport是什么

剛剛開頭提到過，LockSupport是一個線程工具類，所有的方法都是靜態(tài)方法，可以讓線程在任意位置阻塞，也可以在任意位置喚醒。

它的內(nèi)部其實(shí)兩類主要的方法：park(停車阻塞線程)和unpark(啟動喚醒線程)。

 
 
 
 
    
  
  
  
  
  1. //（1）阻塞當(dāng)前線程 
    2. 
  
  
  
  
  2. public static void park(Object blocker);  
    3. 
  
  
  
  
  3. //（2）暫停當(dāng)前線程，有超時時間 
    4. 
  
  
  
  
  4. public static void parkNanos(Object blocker, long nanos);  
    5. 
  
  
  
  
  5. //（3）暫停當(dāng)前線程，直到某個時間 
    6. 
  
  
  
  
  6. public static void parkUntil(Object blocker, long deadline);  
    7. 
  
  
  
  
  7. //（4）無期限暫停當(dāng)前線程 
    8. 
  
  
  
  
  8. public static void park();  
    9. 
  
  
  
  
  9. //（5）暫停當(dāng)前線程，不過有超時時間的限制 
    10. 
  
  
  
  
  10. public static void parkNanos(long nanos);  
    11. 
  
  
  
  
  11. //（6）暫停當(dāng)前線程，直到某個時間 
    12. 
  
  
  
  
  12. public static void parkUntil(long deadline);   
    13. 
  
  
  
  
  13. //（7）恢復(fù)當(dāng)前線程 
    14. 
  
  
  
  
  14. public static void unpark(Thread thread);  
    15. 
  
  
  
  
  15. public static Object getBlocker(Thread t); 
    16.

注意上面的123方法，都有一個blocker，這個blocker是用來記錄線程被阻塞時被誰阻塞的。用于線程監(jiān)控和分析工具來定位原因的。

現(xiàn)在我們知道了LockSupport是用來阻塞和喚醒線程的，而且之前相信我們都知道wait/notify也是用來阻塞和喚醒線程的，那和它相比，LockSupport有什么優(yōu)點(diǎn)呢?

2、與wait/notify對比

這里假設(shè)你已經(jīng)了解了wait/notify的機(jī)制，如果不了解，可以在網(wǎng)上一搜，很簡單。相信你既然學(xué)到了這個LockSupport，相信你已經(jīng)提前已經(jīng)學(xué)了wait/notify。

我們先來舉一個使用案例：

 
 
 
 
    
  
  
  
  
  1. public class LockSupportTest { 
    2. 
  
  
  
  
  2.     public static class MyThread extends Thread { 
    3. 
  
  
  
  
  3.         @Override 
    4. 
  
  
  
  
  4.         public void run() { 
    5. 
  
  
  
  
  5.             System.out.println(getName() + " 進(jìn)入線程"); 
    6. 
  
  
  
  
  6.             LockSupport.park(); 
    7. 
  
  
  
  
  7.             System.out.println("t1線程運(yùn)行結(jié)束"); 
    8. 
  
  
  
  
  8.         } 
    9. 
  
  
  
  
  9.     } 
    10. 
  
  
  
  
  10.     public static void main(String[] args) { 
    11. 
  
  
  
  
  11.         MyThread t1 = new MyThread(); 
    12. 
  
  
  
  
  12.         t1.start(); 
    13. 
  
  
  
  
  13.         System.out.println("t1已經(jīng)啟動，但是在內(nèi)部進(jìn)行了park"); 
    14. 
  
  
  
  
  14.         LockSupport.unpark(t1); 
    15. 
  
  
  
  
  15.         System.out.println("LockSupport進(jìn)行了unpark"); 
    16. 
  
  
  
  
  16.     } 
    17. 
  
  
  
  
  17. } 
    18.

上面這段代碼的意思是，我們定義一個線程，但是在內(nèi)部進(jìn)行了park，因此需要unpark才能喚醒繼續(xù)執(zhí)行，不過上面，我們在MyThread進(jìn)行的park，在main線程進(jìn)行的unpark。

這樣來看，好像和wait/notify沒有什么區(qū)別。那他的區(qū)別到底是什么呢?這個就需要仔細(xì)的觀察了。這里主要有兩點(diǎn)：

(1)wait和notify都是Object中的方法,在調(diào)用這兩個方法前必須先獲得鎖對象，但是park不需要獲取某個對象的鎖就可以鎖住線程。

(2)notify只能隨機(jī)選擇一個線程喚醒，無法喚醒指定的線程，unpark卻可以喚醒一個指定的線程。

區(qū)別就是這倆，還是主要從park和unpark的角度來解釋的。既然這個LockSupport這么強(qiáng)，我們就深入一下他的源碼看看。

二、源碼分析(基于jdk1.8)

1、park方法

 
 
 
 
    
  
  
  
  
  1. public static void park(Object blocker) { 
    2. 
  
  
  
  
  2.         Thread t = Thread.currentThread(); 
    3. 
  
  
  
  
  3.         setBlocker(t, blocker); 
    4. 
  
  
  
  
  4.         UNSAFE.park(false, 0L); 
    5. 
  
  
  
  
  5.         setBlocker(t, null); 
    6. 
  
  
  
  
  6.     } 
    7.

blocker是用來記錄線程被阻塞時被誰阻塞的。用于線程監(jiān)控和分析工具來定位原因的。setBlocker(t, blocker)方法的作用是記錄t線程是被broker阻塞的。因此我們只關(guān)注最核心的方法，也就是UNSAFE.park(false, 0L)。

UNSAFE是一個非常強(qiáng)大的類，他的的操作是基于底層的，也就是可以直接操作內(nèi)存，因此我們從JVM的角度來分析一下：

每個java線程都有一個Parker實(shí)例：

 
 
 
 
    
  
  
  
  
  1. class Parker : public os::PlatformParker { 
    2. 
  
  
  
  
  2. private: 
    3. 
  
  
  
  
  3.   volatile int _counter ; 
    4. 
  
  
  
  
  4.   ... 
    5. 
  
  
  
  
  5. public: 
    6. 
  
  
  
  
  6.   void park(bool isAbsolute, jlong time); 
    7. 
  
  
  
  
  7.   void unpark(); 
    8. 
  
  
  
  
  8.   ... 
    9. 
  
  
  
  
  9. } 
    10. 
  
  
  
  
  10. class PlatformParker : public CHeapObj { 
    11. 
  
  
  
  
  11.   protected: 
    12. 
  
  
  
  
  12.     pthread_mutex_t _mutex [1] ; 
    13. 
  
  
  
  
  13.     pthread_cond_t  _cond  [1] ; 
    14. 
  
  
  
  
  14.     ... 
    15. 
  
  
  
  
  15. } 
    16.

我們換一種角度來理解一下park和unpark，可以想一下，unpark其實(shí)就相當(dāng)于一個許可，告訴特定線程你可以停車，特定線程想要park停車的時候一看到有許可，就可以立馬停車?yán)^續(xù)運(yùn)行了。因此其執(zhí)行順序可以顛倒。

現(xiàn)在有了這個概念，我們體會一下上面JVM層面park的方法，這里面counter字段，就是用來記錄所謂的“許可”的。

本小部分總結(jié)來源于：https://www.jianshu.com/p/1f16b838ccd8

當(dāng)調(diào)用park時，先嘗試直接能否直接拿到“許可”，即_counter>0時，如果成功，則把_counter設(shè)置為0,并返回。

 
 
 
 
    
  
  
  
  
  1. void Parker::park(bool isAbsolute, jlong time) { 
    2. 
  
  
  
  
  2.   // Ideally we'd do something useful while spinning, such 
    3. 
  
  
  
  
  3.   // as calling unpackTime(). 
    4. 
  
  
  
  
  4.   // Optional fast-path check: 
    5. 
  
  
  
  
  5.   // Return immediately if a permit is available. 
    6. 
  
  
  
  
  6.   // We depend on Atomic::xchg() having full barrier semantics 
    7. 
  
  
  
  
  7.   // since we are doing a lock-free update to _counter. 
    8. 
  
  
  
  
  8.   if (Atomic::xchg(0, &_counter) > 0) return; 
    9.

如果不成功，則構(gòu)造一個ThreadBlockInVM，然后檢查_counter是不是>0，如果是，則把_counter設(shè)置為0，unlock mutex并返回:

 
 
 
 
    
  
  
  
  
  1. ThreadBlockInVM tbivm(jt); 
    2. 
  
  
  
  
  2.  // no wait needed 
    3. 
  
  
  
  
  3.  if (_counter > 0)  {  
    4. 
  
  
  
  
  4.    _counter = 0; 
    5. 
  
  
  
  
  5.    status = pthread_mutex_unlock(_mutex); 
    6.

否則，再判斷等待的時間，然后再調(diào)用pthread_cond_wait函數(shù)等待，如果等待返回，則把_counter設(shè)置為0，unlock mutex并返回：

 
 
 
 
    
  
  
  
  
  1. if (time == 0) {   
    2. 
  
  
  
  
  2.   status = pthread_cond_wait (_cond, _mutex) ;   
    3. 
  
  
  
  
  3. }   
    4. 
  
  
  
  
  4. _counter = 0 ;   
    5. 
  
  
  
  
  5. status = pthread_mutex_unlock(_mutex) ;   
    6. 
  
  
  
  
  6. assert_status(status == 0, status, "invariant") ;   
    7. 
  
  
  
  
  7. OrderAccess::fence();  
    8.

這就是整個park的過程，總結(jié)來說就是消耗“許可”的過程。

2、unpark

還是先來看一下JDK源碼：

 
 
 
 
    
  
  
  
  
  1. /** 
    2. 
  
  
  
  
  2.     * Makes available the permit for the given thread, if it 
    3. 
  
  
  
  
  3.     * was not already available.  If the thread was blocked on 
    4. 
  
  
  
  
  4.     * {@code park} then it will unblock.  Otherwise, its next call 
    5. 
  
  
  
  
  5.     * to {@code park} is guaranteed not to block. This operation 
    6. 
  
  
  
  
  6.     * is not guaranteed to have any effect at all if the given 
    7. 
  
  
  
  
  7.     * thread has not been started. 
    8. 
  
  
  
  
  8.     * 
    9. 
  
  
  
  
  9.     * @param thread the thread to unpark, or {@code null}, in which case 
    10. 
  
  
  
  
  10.     *        this operation has no effect 
    11. 
  
  
  
  
  11.     */ 
    12. 
  
  
  
  
  12.    public static void unpark(Thread thread) { 
    13. 
  
  
  
  
  13.        if (thread != null) 
    14. 
  
  
  
  
  14.            UNSAFE.unpark(thread); 
    15. 
  
  
  
  
  15.    } 
    16.

上面注釋的意思是給線程生產(chǎn)許可證。

當(dāng)unpark時，則簡單多了，直接設(shè)置_counter為1，再unlock mutext返回。如果_counter之前的值是0，則還要調(diào)用pthread_cond_signal喚醒在park中等待的線程：

 
 
 
 
    
  
  
  
  
  1. void Parker::unpark() {   
    2. 
  
  
  
  
  2.   int s, status ;   
    3. 
  
  
  
  
  3.   status = pthread_mutex_lock(_mutex);   
    4. 
  
  
  
  
  4.   assert (status == 0, "invariant") ;   
    5. 
  
  
  
  
  5.   s = _counter;   
    6. 
  
  
  
  
  6.   _counter = 1;   
    7. 
  
  
  
  
  7.   if (s < 1) {   
    8. 
  
  
  
  
  8.      if (WorkAroundNPTLTimedWaitHang) {   
    9. 
  
  
  
  
  9.         status = pthread_cond_signal (_cond) ;   
    10. 
  
  
  
  
  10.         assert (status == 0, "invariant") ;   
    11. 
  
  
  
  
  11.         status = pthread_mutex_unlock(_mutex);   
    12. 
  
  
  
  
  12.         assert (status == 0, "invariant") ;   
    13. 
  
  
  
  
  13.      } else {   
    14. 
  
  
  
  
  14.         status = pthread_mutex_unlock(_mutex);   
    15. 
  
  
  
  
  15.         assert (status == 0, "invariant") ;   
    16. 
  
  
  
  
  16.         status = pthread_cond_signal (_cond) ;   
    17. 
  
  
  
  
  17.         assert (status == 0, "invariant") ;   
    18. 
  
  
  
  
  18.      }   
    19. 
  
  
  
  
  19.   } else {   
    20. 
  
  
  
  
  20.     pthread_mutex_unlock(_mutex);   
    21. 
  
  
  
  
  21.     assert (status == 0, "invariant") ;   
    22. 
  
  
  
  
  22.   }   
    23. 
  
  
  
  
  23. }   
    24.

ok，現(xiàn)在我們已經(jīng)對源碼進(jìn)行了分析，整個過程其實(shí)就是生產(chǎn)許可和消費(fèi)許可的過程。而且這個生產(chǎn)過程可以反過來。也就是先生產(chǎn)再消費(fèi)。下面我們使用幾個例子驗(yàn)證一波。

三、LockSupport使用

1、先interrupt再park

 
 
 
 
    
  
  
  
  
  1. public class LockSupportTest { 
    2. 
  
  
  
  
  2.     public static class MyThread extends Thread { 
    3. 
  
  
  
  
  3.         @Override 
    4. 
  
  
  
  
  4.         public void run() { 
    5. 
  
  
  
  
  5.             System.out.println(getName() + " 進(jìn)入線程"); 
    6. 
  
  
  
  
  6.             LockSupport.park(); 
    7. 
  
  
  
  
  7.             System.out.println(" 運(yùn)行結(jié)束"); 
    8. 
  
  
  
  
  8.             System.out.println("是否中斷：" + Thread.currentThread().isInterrupted()); 
    9. 
  
  
  
  
  9.         } 
    10. 
  
  
  
  
  10.     } 
    11. 
  
  
  
  
  11.     public static void main(String[] args) { 
    12. 
  
  
  
  
  12.         MyThread t1 = new MyThread(); 
    13. 
  
  
  
  
  13.         t1.start(); 
    14. 
  
  
  
  
  14.         System.out.println("t1線程已經(jīng)啟動了，但是在內(nèi)部LockSupport進(jìn)行了park"); 
    15. 
  
  
  
  
  15.         t1.interrupt(); 
    16. 
  
  
  
  
  16.         System.out.println("main線程結(jié)束"); 
    17. 
  
  
  
  
  17.     } 
    18. 
  
  
  
  
  18. } 
    19.

我們看一下結(jié)果：

2、先unpark再park

 
 
 
 
    
  
  
  
  
  1. public static class MyThread extends Thread { 
    2. 
  
  
  
  
  2.         @Override 
    3. 
  
  
  
  
  3.         public void run() { 
    4. 
  
  
  
  
  4.             try { 
    5. 
  
  
  
  
  5.                 TimeUnit.SECONDS.sleep(1); 
    6. 
  
  
  
  
  6.             } catch (InterruptedException e) { 
    7. 
  
  
  
  
  7.                 e.printStackTrace(); 
    8. 
  
  
  
  
  8.             } 
    9. 
  
  
  
  
  9.             System.out.println(getName() + " 進(jìn)入線程"); 
    10. 
  
  
  
  
  10.             LockSupport.park(); 
    11. 
  
  
  
  
  11.             System.out.println(" 運(yùn)行結(jié)束"); 
    12. 
  
  
  
  
  12.         } 
    13. 
  
  
  
  
  13.     } 
    14.

我們只需在park之前先休眠1秒鐘，這樣可以確保unpark先執(zhí)行。

本文轉(zhuǎn)載自微信公眾號「愚公要移山」，可以通過以下二維碼關(guān)注。轉(zhuǎn)載本文請聯(lián)系愚公要移山公眾號。


文章名稱：LockSupport：一個很靈活的線程工具類
文章源于：http://m.5511xx.com/article/dhocshg.html