當前位置：首頁 > 编程语言 > java >内容正文

java

thread.sleep是让哪个线程休眠_Java多线程：多线程基础知识

發布時間：2024/7/19 java 48 豆豆

生活随笔收集整理的這篇文章主要介紹了 thread.sleep是让哪个线程休眠_Java多线程：多线程基础知识小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

點擊上方?SpringForAll社區?輕松關注！及時獲取有趣有料的技術文章

本文來源：https://www.cnblogs.com/ITtangtang/p/7602363.html

一、線程安全性

定義：多個線程之間的操作無論采用何種執行時序或交替方式，都要保證不變性條件不被破壞

“共享”：變量可以由多個線程同時訪問；

“可變”：變量的值在其生命周期內可以發生改變

如果當多個線程訪問同一個可變的狀態變量時，沒有使用合適的同步，那么程序將會出現錯誤。有三種方式可以修復該問題：

不在線程之間共享該變量。
將狀態變量修改為不可變的變量。
在訪問狀態變量時使用同步。

競態條件：

最常見的類型就是“先檢查后執行”操作，即通過一個可能失效的觀測接口來決定下一步的動作。

二、線程啟動

繼承Thread類，重寫里面的run方法，用start方法啟動線程
實現Runnable接口，實現里面的run方法，用new Thread(Runnable target).start()方法來啟動

start()和run()

線程的啟動并不是簡單的調用了run方法,而是由一個線程調度器來分別調用所有線程的run方法,普通的run方法如果沒有執行完是不會返回的,也就是會一直執行下去,這樣run方法下面的方法就不可能會執行了,可是線程里的run方法卻不一樣,它只有一定的CPU時間,執行過后就給別的線程了,這樣反復的把CPU的時間切來切去,因為切換的速度很快,所以我們就感覺是很多線程在同時運行一樣

(01) mythread.run()是在“主線程main”中調用的，該run()方法直接運行在“主線程main”上。

(02) mythread.start()會啟動“線程mythread”，“線程mythread”啟動之后，會調用run()方法；此時的run()方法是運行在“線程mythread”上。

http://blog.csdn.net/xuxurui007/article/details/7685076

三、線程同步

synchronized關鍵字

內置鎖(互斥鎖):

在java中，每一個對象有且僅有一個同步鎖。這也意味著，同步鎖是依賴于對象而存在。線程在進入同步代碼塊之前會自動獲得鎖，并且在退出同步代碼塊時自動釋放鎖。同一時間最多只有一個線程持有該鎖,其他線程必須等待或者阻塞，直到該線程釋放鎖。

如果持有鎖的時間過長，將會帶來性能問題。

實例鎖 -- 鎖在某一個實例對象上。如果該類是單例，那么該鎖也具有全局鎖的概念。

實例鎖對應的就是synchronized關鍵字。

全局鎖 -- 該鎖針對的是類，無論實例多少個對象，那么線程都共享該鎖。

全局鎖對應的就是static synchronized(或者是鎖在該類的class或者classloader對象上)。

volatile變量

volatile相當于synchronized的弱實現，也就是說volatile實現了類似synchronized的語義，卻又沒有鎖機制。它確保對volatile字段的更新以可預見的方式告知其他的線程。

volatile包含以下語義：

　　(1)Java 存儲模型不會對valatile指令的操作進行重排序：這個保證對volatile變量的操作時按照指令的出現順序執行的。

　　(2)volatile變量不會被緩存在寄存器中(只有擁有線程可見)或者其他對CPU不可見的地方，每次總是從主存中讀取volatile變量的結果。也就是說對于volatile變量的修改，其它線程總是可見的，并且不是使用自己線程棧內部的變量。也就是在happens-before法則中，對一個valatile變量的寫操作后，其后的任何讀操作理解可見此寫操作的結果。

盡管volatile變量的特性不錯，但是volatile并不能保證線程安全的，也就是說volatile字段的操作不是原子性的，volatile變量只能保證可見性(一個線程修改后其它線程能夠理解看到此變化后的結果)，要想保證原子性，目前為止只能加鎖！

四、線程協作

線程等待：

等待的原因可能是如下幾種情況：

(1)sleep() 的作用是讓當前線程休眠，即當前線程會從“運行狀態”進入到“休眠(阻塞)狀態”。sleep()會指定休眠時間，線程休眠的時間會大于/等于該休眠時間；在線程重新被喚醒時，它會由“阻塞狀態”變成“就緒狀態”，從而等待cpu的調度執行。

(2)通過調用join()方法使線程掛起，使自己等待另一個線程的結果，直到另一個線程執行完畢為止。

(3)通過調用wait()方法使線程掛起，直到線程得到了notify()和notifyAll()消息，線程才會進入“可執行”狀態。

(4)yield()的作用是讓步。它能讓當前線程由“運行狀態”進入到“就緒狀態”，從而讓其它具有相同優先級的等待線程獲取執行權；但是，并不能保證在當前線程調用yield()之后，其它具有相同優先級的線程就一定能獲得執行權；也有可能是當前線程又進入到“運行狀態”繼續運行！

注意：

　　(01) wait()是讓線程由“運行狀態”進入到“等待(阻塞)狀態”，而yield()是讓線程由“運行狀態”進入到“就緒狀態”。

　　(02) wait()是會讓線程釋放它所持有對象的同步鎖，而yield()方法不會釋放鎖。

　　(03) sleep()使當前線程暫停執行一段時間，從而讓其他線程有機會繼續執行，但它并不釋放對象鎖

wait()：

　　“當前線程”在調用wait()時，必須擁有該對象的同步鎖。該線程調用wait()之后，會釋放該鎖；然后一直等待直到“其它線程”調用對象的同步鎖的notify()或notifyAll()方法。然后，該線程繼續等待直到它重新獲取“該對象的同步鎖”，然后就可以接著運行wait()后面的代碼。wait()的作用是讓“當前線程”等待，而“當前線程”是指正在cpu上運行的線程！因此調用wait()方法必須在同步塊或者同步方法中進行(synchronized塊或者synchronized方法)
　　wait的東西一定要notify嗎？不一定，

notify()：

　　notify() 執行該方法的線程喚醒在對象的等待池中等待的一個線程，JVM從對象的等待池中隨機選擇一個線程，把它轉到對象的鎖池中。使線程由阻塞隊列進入就緒狀態。

notifyAll():

　　當前的線程已經放棄對資源的占有，通知所有的等待線程從wait()方法后的語句開始運行。

這里要注意一點：notify()和notifyAll()方法只是喚醒等待該對象的鎖的線程，并不決定哪個線程能夠獲取到鎖.

　　舉個簡單的例子：

　　假如有三個線程Thread1、Thread2和Thread3都在等待對象objectA的鎖，此時Thread4擁有對象objectA的鎖，當在Thread4中調用objectA.notify()方法之后，Thread1、Thread2和Thread3只有一個能被喚醒。注意，被喚醒不等于立刻就獲取了objectA的鎖，假若在Thread4中調用objectA.notifyAll()方法，則Thread1、Thread2和Thread3三個線程都會被喚醒，至于哪個線程接下來能夠獲取到objectA的鎖就具體依賴于操作系統的調度了。

　　上面尤其要注意一點，一個線程被喚醒不代表立即獲取了對象的鎖，只有等調用完notify()或者notifyAll()并退出synchronized塊，釋放對象鎖后，其余線程才可獲得鎖執行。

首先，wait()和notify(),notifyAll()是Object類的方法，sleep()和yield()是Thread類的方法。

　　當然由于Thread類繼承了Object類，所以Thread也可以調用前面三個方法

　　由于每個對象都擁有鎖，所以讓當前線程等待某個對象的鎖，當然應該通過這個對象來操作了。而不是用當前線程來操作，因為當前線程可能會等待多個對象的鎖，如果通過線程來操作，就非常復雜了。

(1).常用的wait方法有wait()和wait(long timeout):

void wait() 在其他線程調用此對象的 notify() 方法或 notifyAll() 方法前，導致當前線程等待。

void wait(long timeout) 在其他線程調用此對象的 notify() 方法或 notifyAll() 方法，或者超過指定的時間量前，導致當前線程等待。

wait()后，線程會釋放掉它所占有的“鎖標志”，從而使線程所在對象中的其它synchronized數據可被別的線程使用。

wait()和notify()因為會對對象的“鎖標志”進行操作，所以它們必須在synchronized函數或synchronized　 block中進行調用。如果在non-synchronized函數或non-synchronized　block中進行調用，雖然能編譯通過，但在運行時會發生IllegalMonitorStateException的異常。

(2).Thread.sleep(long millis),必須帶有一個時間參數。

sleep(long)使當前線程進入停滯狀態，所以執行sleep()的線程在指定的時間內肯定不會被執行；

sleep(long)可使優先級低的線程得到執行的機會，當然也可以讓同優先級和高優先級的線程有執行的機會；

sleep(long)是不會釋放鎖標志的。

(3).yield()沒有參數。

sleep 方法使當前運行中的線程睡眼一段時間，進入不可運行狀態，這段時間的長短是由程序設定的，yield 方法使當前線程讓出CPU占有權，但讓出的時間是不可設定的。

yield()也不會釋放鎖標志。

實際上，yield()方法對應了如下操作：先檢測當前是否有相同優先級的線程處于同可運行狀態，如有，則把 CPU 的占有權交給此線程，否則繼續運行原來的線程。所以yield()方法稱為“退讓”，它把運行機會讓給了同等優先級的其他線程。

sleep方法允許較低優先級的線程獲得運行機會，但yield()方法執行時，當前線程仍處在可運行狀態，所以不可能讓出較低優先級的線程些時獲得CPU占有權。在一個運行系統中，如果較高優先級的線程沒有調用 sleep 方法，又沒有受到 I/O阻塞，那么較低優先級線程只能等待所有較高優先級的線程運行結束，才有機會運行。

yield()只是使當前線程重新回到可執行狀態，所以執行yield()的線程有可能在進入到可執行狀態后馬上又被執行。所以yield()只能使同優先級的線程有執行的機會。

sleep和yield區別：

　　1、sleep()方法會給其他線程運行的機會，而不考慮其他線程的優先級，因此會給較低線程一個運行的機會；yield()方法只會給相同優先級或者更高優先級的線程一個運行的機會。

　　2、當線程執行了sleep(long millis)方法后，將轉到阻塞狀態，參數millis指定睡眠時間；當線程執行了yield()方法后，將轉到就緒狀態。

　　3、sleep()方法聲明拋出InterruptedException異常，而yield()方法沒有聲明拋出任何異常

為什么notify(), wait()等函數定義在Object中，而不是Thread中?

　　Object中的wait(), notify()等函數，和synchronized一樣，會對“對象的同步鎖”進行操作。

wait()會使“當前線程”等待，因為線程進入等待狀態，所以線程應該釋放它鎖持有的“同步鎖”，否則其它線程獲取不到該“同步鎖”而無法運行！那么：notify()是依據什么喚醒等待線程的？或者說，wait()等待線程和notify()之間是通過什么關聯起來的？答案是：依據“對象的同步鎖”。

　　負責喚醒等待線程的那個線程(我們稱為“喚醒線程”)，它只有在獲取“該對象的同步鎖”(這里的同步鎖必須和等待線程的同步鎖是同一個)，并且調用notify()或notifyAll()方法之后，才能喚醒等待線程。雖然，等待線程被喚醒；但是，它不能立刻執行，因為喚醒線程還持有“該對象的同步鎖”。必須等到喚醒線程釋放了“對象的同步鎖”之后，等待線程才能獲取到“對象的同步鎖”進而繼續運行。

　　總之，notify(), wait()依賴于“同步鎖”，而“同步鎖”是對象鎖持有，并且每個對象有且僅有一個！這就是為什么notify(), wait()等函數定義在Object類，而不是Thread類中的原因。

Condition

Condition是在java 1.5中才出現的，它用來替代傳統的Object的wait()、notify()實現線程間的協作，相比使用Object的wait()、notify()，使用Condition的await()、signal()這種方式實現線程間協作更加安全和高效。因此通常來說比較推薦使用Condition，Java阻塞隊列實際上是使用了Condition來模擬線程間協作。

Condition是個接口，基本的方法就是await()和signal()方法；
Condition依賴于Lock接口，生成一個Condition的基本代碼是lock.newCondition()
調用Condition的await()和signal()方法，都必須在lock保護之內，就是說必須在lock.lock()和lock.unlock之間才可以使用
　　Conditon中的await()對應Object的wait()；
　　Condition中的signal()對應Object的notify()；
　　Condition中的signalAll()對應Object的notifyAll()。

五、線程中斷

http://blog.csdn.net/dlite/article/details/4218105

Java的線程調度不提供搶占式中斷，而采用協作式的中斷。其實，協作式的中斷，原理很簡單，就是輪詢某個表示中斷的標記。

通常，我們通過“標記”方式終止處于“運行狀態”的線程。其中，包括“中斷標記”和“額外添加標記”。

(01) 通過“中斷標記”終止線程。

　　形式如下：

1@Override
2publicvoid?run()?{
3????while?(!isInterrupted())?{
4????????//?執行任務...????}
5}

說明：isInterrupted()是判斷線程的中斷標記是不是為true。當線程處于運行狀態，并且我們需要終止它時；可以調用線程的interrupt()方法，使用線程的中斷標記為true，即isInterrupted()會返回true。此時，就會退出while循環。

注意：interrupt()并不會終止處于“運行狀態”的線程！它會將線程的中斷標記設為true。

(02) 通過“額外添加標記”。

　　形式如下：

1private?volatile?boolean?flag?=?true;
2protected?void?stopTask()?{
3????flag?=?false;
4}
5
6@Override
7public?void?run()?{
8????while?(flag)?{
9????????//?執行任務...????}
10}

說明：線程中有一個flag標記，它的默認值是true；并且我們提供stopTask()來設置flag標記。當我們需要終止該線程時，調用該線程的stopTask()方法就可以讓線程退出while循環。

注意：將flag定義為volatile類型，是為了保證flag的可見性。即其它線程通過stopTask()修改了flag之后，本線程能看到修改后的flag的值。

通常，我們通過“中斷”方式終止處于“阻塞狀態”的線程。

當線程由于被調用了sleep(), wait(), join()等方法而進入阻塞狀態；若此時調用線程的interrupt()將線程的中斷標記設為true。由于處于阻塞狀態，中斷標記會被清除，同時產生一個InterruptedException異常。將InterruptedException放在適當的為止就能終止線程

1@Override
2public?void?run()?{
3????try?{
4????????while?(true)?{
5????????????//?執行任務...????????}
6????}?catch?(InterruptedException?ie)?{??
7????????//?由于產生InterruptedException異常，退出while(true)循環，線程終止！????}
8}

注意：對InterruptedException的捕獲務一般放在while(true)循環體的外面，這樣，在產生異常時就退出了while(true)循環。

參考資料：

http://www.cnblogs.com/jobs/archive/2010/07/29/1788156.html

梁飛：Java并發編程常識.pptx

●?Kafka基本架構及原理

●?JVM：基礎

●?數據倉庫：Mysql大量數據快速導出

●?深入理解Java：注解

●?深入理解Java：類加載機制及反射

●?Java 如何設計 API 接口，實現統一格式返回？

●?圖文：你女朋友也能看懂的 Kubernetes ！

●?打開黑盒：從 MySQL 架構設計出發，看它是如何執行一條 SQL 語句的？

●?記一次神奇的 sql 查詢經歷，group by 慢查詢優化！

●?花了一個月時間梳理了一下公司的微服務核心架構，原來也不是太難.

●?一次900萬+數據量的 SQL 查詢優化分析【上百倍性能優化】

●?緩存穿透、緩存并發、緩存失效之思路變遷