线程中这么调用类_这些线程知识总结是真的到位！java开发两年的我看的目瞪口呆
前言
什么是線程：程序中負責執行的那個東東就叫做線程(執行路線，進程內部的執行序列)，或著說是進程的子任務。
Java中實現多線程有幾種方法
繼承Thread類；
實現Runnable接口；
實現Callable接口通過FutureTask包裝器來創建Thread線程；
使用ExecutorService、Callable、Future實現有返回結果的多線程(也就是使用了ExecutorService來管理前面的三種方式)。
如何停止一個正在運行的線程
- 使用退出標志，使線程正常退出，也就是當run方法完成后線程終止。
- 使用stop方法強行終止，但是不推薦這個方法，因為stop和suspend及resume一樣都是過期作廢的方法。
- 使用interrupt方法中斷線程。
notify()和notifyAll()有什么區別？
notify可能會導致死鎖，而notifyAll則不會
任何時候只有一個線程可以獲得鎖，也就是說只有一個線程可以運行synchronized 中的代碼
使用notifyall,可以喚醒
所有處于wait狀態的線程，使其重新進入鎖的爭奪隊列中，而notify只能喚醒一個。
wait() 應配合while循環使用，不應使用if，務必在wait()調用前后都檢查條件，如果不滿足，必須調用notify()喚醒另外的線程來處理，自己繼續wait()直至條件滿足再往下執行。
notify() 是對notifyAll()的一個優化，但它有很精確的應用場景，并且要求正確使用。不然可能導致死鎖。正確的場景應該是 WaitSet中等待的是相同的條件，喚醒任一個都能正確處理接下來的事項，如果喚醒的線程無法正確處理，務必確保繼續notify()下一個線程，并且自身需要重新回到WaitSet中.
sleep()和wait() 有什么區別？
對于sleep()方法，我們首先要知道該方法是屬于Thread類中的。而wait()方法，則是屬于Object類中的。
sleep()方法導致了程序暫停執行指定的時間，讓出cpu該其他線程，但是他的監控狀態依然保持者，當指定的時間到了又會自動恢復運行狀態。在調用sleep()方法的過程中，線程不會釋放對象鎖。
當調用wait()方法的時候，線程會放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象調用notify()方法后本線程才進入對象鎖定池準備，獲取對象鎖進入運行狀態。
volatile 是什么?可以保證有序性嗎?
一旦一個共享變量(類的成員變量、類的靜態成員變量)被volatile修飾之后，那么就具備了兩層語義：
1)保證了不同線程對這個變量進行操作時的可見性，即一個線程修改了某個變量的值，這新值對其他線程來說是立即可見的,volatile關鍵字會強制將修改的值立即寫入主存。
2)禁止進行指令重排序。
volatile 不是原子性操作
什么叫保證部分有序性?
當程序執行到volatile變量的讀操作或者寫操作時，在其前面的操作的更改肯定全部已經進行，且結果已經對后面的操作可見；在其后面的操作肯定還沒有進行；
x = 2; //語句1y = 0; //語句2flag = true; //語句3x = 4; //語句4y = -1; //語句5由于flag變量為volatile變量，那么在進行指令重排序的過程的時候，不會將語句3放到語句1、語句2前面，也不會將語句3放到語句4、語句5后面。但是要注意語句1和語句2的順序、語句4和語句5的順序是不作任何保證的。
使用 Volatile 一般用于 狀態標記量 和 單例模式的雙檢鎖
Thread 類中的start() 和 run() 方法有什么區別？
start()方法被用來啟動新創建的線程，而且start()內部調用了run()方法，這和直接調用run()方法的效果不一樣。當你調用run()方法的時候，只會是在原來的線程中調用，沒有新的線程啟動，start()方法才會啟動新線程。
為什么wait, notify 和 notifyAll這些方法不在thread類里面？
明顯的原因是JAVA提供的鎖是對象級的而不是線程級的，每個對象都有鎖，通過線程獲得。如果線程需要等待某些鎖那么調用對象中的wait()方法就有意義了。如果wait()方法定義在Thread類中，線程正在等待的是哪個鎖就不明顯了。簡單的說，由于wait，notify和notifyAll都是鎖級別的操作，所以把他們定義在Object類中因為鎖屬于對象。
為什么wait和notify方法要在同步塊中調用？
wait()方法強制當前線程釋放對象鎖。這意味著在調用某對象的wait()方法之前，當前線程必須已經獲得該對象的鎖。因此，線程必須在某個對象的同步方法或同步代碼塊中才能調用該對象的wait()方法。
在調用對象的notify()和notifyAll()方法之前，調用線程必須已經得到該對象的鎖。因此，必須在某個對象的同步方法或同步代碼塊中才能調用該對象的notify()或notifyAll()方法。
調用wait()方法的原因通常是，調用線程希望某個特殊的狀態(或變量)被設置之后再繼續執行。調用notify()或notifyAll()方法的原因通常是，調用線程希望告訴其他等待中的線程:“特殊狀態已經被設置”。這個狀態作為線程間通信的通道，它必須是一個可變的共享狀態(或變量)。
Java中interrupted 和 isInterruptedd方法的區別？
interrupted() 和 isInterrupted()的主要區別是前者會將中斷狀態清除而后者不會。Java多線程的中斷機制是用內部標識來實現的，調用Thread.interrupt()來中斷一個線程就會設置中斷標識為true。當中斷線程調用靜態方法Thread.interrupted()來檢查中斷狀態時，中斷狀態會被清零。而非靜態方法isInterrupted()用來查詢其它線程的中斷狀態且不會改變中斷狀態標識。簡單的說就是任何拋出InterruptedException異常的方法都會將中斷狀態清零。無論如何，一個線程的中斷狀態有有可能被其它線程調用中斷來改變。
Java中synchronized 和 ReentrantLock 有什么不同？
相似點：
這兩種同步方式有很多相似之處，它們都是加鎖方式同步，而且都是阻塞式的同步，也就是說當如果一個線程獲得了對象鎖，進入了同步塊，其他訪問該同步塊的線程都必須阻塞在同步塊外面等待，而進行線程阻塞和喚醒的代價是比較高的.
區別：
這兩種方式最大區別就是對于Synchronized來說，它是java語言的關鍵字，是原生語法層面的互斥，需要jvm實現。而ReentrantLock它是JDK 1.5之后提供的API層面的互斥鎖，需要lock()和unlock()方法配合try/finally語句塊來完成。
Synchronized進過編譯，會在同步塊的前后分別形成monitorenter和monitorexit這個兩個字節碼指令。在執行monitorenter指令時，首先要嘗試獲取對象鎖。如果這個對象沒被鎖定，或者當前線程已經擁有了那個對象鎖，把鎖的計算器加1，相應的，在執行monitorexit指令時會將鎖計算器就減1，當計算器為0時，鎖就被釋放了。如果獲取對象鎖失敗，那當前線程就要阻塞，直到對象鎖被另一個線程釋放為止。
由于ReentrantLock是java.util.concurrent包下提供的一套互斥鎖，相比Synchronized，ReentrantLock類提供了一些高級功能，主要有以下3項：
1.等待可中斷，持有鎖的線程長期不釋放的時候，正在等待的線程可以選擇放棄等待，這相當于Synchronized來說可以避免出現死鎖的情況。
2.公平鎖，多個線程等待同一個鎖時，必須按照申請鎖的時間順序獲得鎖，Synchronized鎖非公平鎖，ReentrantLock默認的構造函數是創建的非公平鎖，可以通過參數true設為公平鎖，但公平鎖表現的性能不是很好。
3.鎖綁定多個條件，一個ReentrantLock對象可以同時綁定對個對象。
有三個線程T1,T2,T3,如何保證順序執行？
在多線程中有多種方法讓線程按特定順序執行，你可以用線程類的join()方法在一個線程中啟動另一個線程，另外一個線程完成該線程繼續執行。為了確保三個線程的順序你應該先啟動最后一個(T3調用T2，T2調用T1)，這樣T1就會先完成而T3最后完成。
實際上先啟動三個線程中哪一個都行，
因為在每個線程的run方法中用join方法限定了三個線程的執行順序。
SynchronizedMap和ConcurrentHashMap有什么區別？**
SynchronizedMap()和Hashtable一樣，實現上在調用map所有方法時，都對整個map進行同步。而ConcurrentHashMap的實現卻更加精細，它對map中的所有桶加了鎖。所以，只要有一個線程訪問map，其他線程就無法進入map，而如果一個線程在訪問ConcurrentHashMap某個同時，其他線程，仍然可以對map執行某些操作。
所以，ConcurrentHashMap在性能以及安全性方面，明顯比Collections.synchronizedMap()更加有優勢。同時，同步操作精確控制到桶，這樣，即使在遍歷map時，如果其他線程試圖對map進行數據修改，也不會拋出ConcurrentModificationException。
什么是線程安全
線程安全就是說多線程訪問同一代碼，不會產生不確定的結果。
在多線程環境中，當各線程不共享數據的時候，即都是私有(private)成員，那么一定是線程安全的。但這種情況并不多見，在多數情況下需要共享數據，這時就需要進行適當的同步控制了。
線程安全一般都涉及到synchronized， 就是一段代碼同時只能有一個線程來操作 不然中間過程可能會產生不可預制的結果。
如果你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。如果每次運行結果和單線程運行的結果是一樣的，而且其他的變量的值也和預期的是一樣的，就是線程安全的。
Thread類中的yield方法有什么作用？
Yield方法可以暫停當前正在執行的線程對象，讓其它有相同優先級的線程執行。它是一個靜態方法而且只保證當前線程放棄CPU占用而不能保證使其它線程一定能占用CPU，執行yield()的線程有可能在進入到暫停狀態后馬上又被執行。
Java線程池中submit() 和 execute()方法有什么區別？
兩個方法都可以向線程池提交任務，execute()方法的返回類型是void，它定義在Executor接口中, 而submit()方法可以返回持有計算結果的Future對象，它定義在ExecutorService接口中，它擴展了Executor接口，其它線程池類像ThreadPoolExecutor和ScheduledThreadPoolExecutor都有這些方法。
說一說自己對于 synchronized 關鍵字的了解
synchronized關鍵字解決的是多個線程之間訪問資源的同步性，synchronized關鍵字可以保證被它修飾的方法或者代碼塊在任意時刻只能有一個線程執行。
另外，在 Java 早期版本中，synchronized屬于重量級鎖，效率低下，因為監視器鎖(monitor)是依賴于底層的操作系統的 Mutex Lock 來實現的，Java 的線程是映射到操作系統的原生線程之上的。如果要掛起或者喚醒一個線程，都需要操作系統幫忙完成，而操作系統實現線程之間的切換時需要從用戶態轉換到內核態，這個狀態之間的轉換需要相對比較長的時間，時間成本相對較高，這也是為什么早期的 synchronized 效率低的原因。慶幸的是在 Java 6 之后 Java 官方對從 JVM 層面對synchronized 較大優化，所以現在的 synchronized 鎖效率也優化得很不錯了。JDK1.6對鎖的實現引入了大量的優化，如自旋鎖、適應性自旋鎖、鎖消除、鎖粗化、偏向鎖、輕量級鎖等技術來減少鎖操作的開銷。
說說自己是怎么使用 synchronized 關鍵字，在項目中用到了嗎synchronized關鍵字最主要的三種使用方式：
- 修飾實例方法: 作用于當前對象實例加鎖，進入同步代碼前要獲得當前對象實例的鎖
- 修飾靜態方法: 也就是給當前類加鎖，會作用于類的所有對象實例，因為靜態成員不屬于任何一個實例對象，是類成員( static 表明這是該類的一個靜態資源，不管new了多少個對象，只有一份)。所以如果一個線程A調用一個實例對象的非靜態 synchronized 方法，而線程B需要調用這個實例對象所屬類的靜態 synchronized 方法，是允許的，不會發生互斥現象，因為訪問靜態 synchronized 方法占用的鎖是當前類的鎖，而訪問非靜態 synchronized 方法占用的鎖是當前實例對象鎖。
- 修飾代碼塊: 指定加鎖對象，對給定對象加鎖，進入同步代碼庫前要獲得給定對象的鎖。
- 總結： synchronized 關鍵字加到 static 靜態方法和 synchronized(class)代碼塊上都是是給 Class 類上鎖。synchronized 關鍵字加到實例方法上是給對象實例上鎖。盡量不要使用 synchronized(String a) 因為JVM中，字符串常量池具有緩存功能！
什么是線程安全？Vector是一個線程安全類嗎？
如果你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。如果每次運行結果和單線程運行的結果是一樣的，而且其他的變量 的值也和預期的是一樣的，就是線程安全的。一個線程安全的計數器類的同一個實例對象在被多個線程使用的情況下也不會出現計算失誤。很顯然你可以將集合類分 成兩組，線程安全和非線程安全的。Vector 是用同步方法來實現線程安全的, 而和它相似的ArrayList不是線程安全的。
volatile關鍵字的作用？
一旦一個共享變量(類的成員變量、類的靜態成員變量)被volatile修飾之后，那么就具備了兩層語義：
- 保證了不同線程對這個變量進行操作時的可見性，即一個線程修改了某個變量的值，這新值對其他線程來說是立即可見的。
- 禁止進行指令重排序。
- volatile本質是在告訴jvm當前變量在寄存器(工作內存)中的值是不確定的，需要從主存中讀取；synchronized則是鎖定當前變量，只有當前線程可以訪問該變量，其他線程被阻塞住。
- volatile僅能使用在變量級別；synchronized則可以使用在變量、方法、和類級別的。
- volatile僅能實現變量的修改可見性，并不能保證原子性；synchronized則可以保證變量的修改可見性和原子性。
- volatile不會造成線程的阻塞；synchronized可能會造成線程的阻塞。
volatile標記的變量不會被編譯器優化；synchronized標記的變量可以被編譯器優化。
常用的線程池有哪些？
- newSingleThreadExecutor：創建一個單線程的線程池，此線程池保證所有任務的執行順序按照任務的提交順序執行。
- newFixedThreadPool：創建固定大小的線程池，每次提交一個任務就創建一個線程，直到線程達到線程池的最大大小。
- newCachedThreadPool：創建一個可緩存的線程池，此線程池不會對線程池大小做限制，線程池大小完全依賴于操作系統(或者說JVM)能夠創建的最大線程大小。
- newScheduledThreadPool：創建一個大小無限的線程池，此線程池支持定時以及周期性執行任務的需求。
- newSingleThreadExecutor：創建一個單線程的線程池。此線程池支持定時以及周期性執行任務的需求。
簡述一下你對線程池的理解
(如果問到了這樣的問題，可以展開的說一下線程池如何用、線程池的好處、線程池的啟動策略)合理利用線程池能夠帶來三個好處。
第一：降低資源消耗。通過重復利用已創建的線程降低線程創建和銷毀造成的消耗。
第二：提高響應速度。當任務到達時，任務可以不需要等到線程創建就能立即執行。
第三：提高線程的可管理性。線程是稀缺資源，如果無限制的創建，不僅會消耗系統資源，還會降低系統的穩定性，使用線程池可以進行統一的分配，調優和監控。
Java程序是如何執行的
我們日常的工作中都使用開發工具(IntelliJ IDEA 或 Eclipse 等)可以很方便的調試程序，或者是通過打包工具把項目打包成 jar 包或者 war 包，放入 Tomcat 等 Web 容器中就可以正常運行了，但你有沒有想過 Java 程序內部是如何執行的？其實不論是在開發工具中運行還是在 Tomcat 中運行，Java 程序的執行流程基本都是相同的，它的執行流程如下：
- 先把 Java 代碼編譯成字節碼，也就是把 .java 類型的文件編譯成 .class 類型的文件。這個過程的大致執行流程：Java 源代碼 -> 詞法分析器 -> 語法分析器 -> 語義分析器 -> 字符碼生成器 -> 最終生成字節碼，其中任何一個節點執行失敗就會造成編譯失敗；
- 把 class 文件放置到 Java 虛擬機，這個虛擬機通常指的是 Oracle 官方自帶的 Hotspot JVM；
- Java 虛擬機使用類加載器(Class Loader)裝載 class 文件；
- 類加載完成之后，會進行字節碼校驗，字節碼校驗通過之后 JVM 解釋器會把字節碼翻譯成機器碼交由操作系統執行。但不是所有代碼都是解釋執行的，JVM 對此做了優化，比如，以 Hotspot 虛擬機來說，它本身提供了 JIT(Just In Time)也就是我們通常所說的動態編譯器，它能夠在運行時將熱點代碼編譯為機器碼，這個時候字節碼就變成了編譯執行。
說一說自己對于 synchronized 關鍵字的了解
synchronized關鍵字解決的是多個線程之間訪問資源的同步性，synchronized關鍵字可以保證被它修飾的方法或者代碼塊在任意時刻只能有一個線程執行。
另外，在 Java 早期版本中，synchronized屬于重量級鎖，效率低下，因為監視器鎖(monitor)是依賴于底層的操作系統的 Mutex Lock 來實現的，Java 的線程是映射到操作系統的原生線程之上的。如果要掛起或者喚醒一個線程，都需要操作系統幫忙完成，而操作系統實現線程之間的切換時需要從用戶態轉換到內核態，這個狀態之間的轉換需要相對比較長的時間，時間成本相對較高，這也是為什么早期的 synchronized 效率低的原因。慶幸的是在 Java 6 之后 Java 官方對從 JVM 層面對synchronized 較大優化，所以現在的 synchronized 鎖效率也優化得很不錯了。JDK1.6對鎖的實現引入了大量的優化，如自旋鎖、適應性自旋鎖、鎖消除、鎖粗化、偏向鎖、輕量級鎖等技術來減少鎖操作的開銷。
說說自己是怎么使用 synchronized 關鍵字，在項目中用到了嗎
synchronized關鍵字最主要的三種使用方式：
- 修飾實例方法，作用于當前對象實例加鎖，進入同步代碼前要獲得當前對象實例的鎖
- 修飾靜態方法，作用于當前類對象加鎖，進入同步代碼前要獲得當前類對象的鎖 。也就是給當前類加鎖，會作用于類的所有對象實例，因為靜態成員不屬于任何一個實例對象，是類成員( static 表明這是該類的一個靜態資源，不管new了多少個對象，只有一份，所以對該類的所有對象都加了鎖)。所以如果一個線程A調用一個實例對象的非靜態 synchronized 方法，而線程B需要調用這個實例對象所屬類的靜態 synchronized 方法，是允許的，不會發生互斥現象，因為訪問靜態 synchronized 方法占用的鎖是當前類的鎖，而訪問非靜態 synchronized 方法占用的鎖是當前實例對象鎖。
- 修飾代碼塊，指定加鎖對象，對給定對象加鎖，進入同步代碼庫前要獲得給定對象的鎖。 和 synchronized 方法一樣，synchronized(this)代碼塊也是鎖定當前對象的。synchronized 關鍵字加到 static 靜態方法和 synchronized(class)代碼塊上都是是給 Class 類上鎖。這里再提一下：synchronized關鍵字加到非 static 靜態方法上是給對象實例上鎖。另外需要注意的是：盡量不要使用 synchronized(String a) 因為JVM中，字符串常量池具有緩沖功能！
下面我已一個常見的面試題為例講解一下 synchronized 關鍵字的具體使用。
面試中面試官經常會說：“單例模式了解嗎？來給我手寫一下！給我解釋一下雙重檢驗鎖方式實現單利模式的原理唄！”
雙重校驗鎖實現對象單例(線程安全)
public class Singleton { private volatile static Singleton uniqueInstance; private Singleton() { } public static Singleton getUniqueInstance() { //先判斷對象是否已經實例過，沒有實例化過才進入加鎖代碼 if (uniqueInstance == null) { //類對象加鎖 synchronized (Singleton.class) { if (uniqueInstance == null) { uniqueInstance = new Singleton(); } } } return uniqueInstance; }}另外，需要注意 uniqueInstance 采用 volatile 關鍵字修飾也是很有必要。
uniqueInstance 采用 volatile 關鍵字修飾也是很有必要的， uniqueInstance = new Singleton(); 這段代碼其實是分為三步執行：
但是由于 JVM 具有指令重排的特性，執行順序有可能變成 1->3->2。指令重排在單線程環境下不會出現問題，但是在多線程環境下會導致一個線程獲得還沒有初始化的實例。例如，線程 T1 執行了 1 和 3，此時 T2 調用 getUniqueInstance() 后發現 uniqueInstance 不為空，因此返回 uniqueInstance，但此時 uniqueInstance 還未被初始化。
使用 volatile 可以禁止 JVM 的指令重排，保證在多線程環境下也能正常運行。
講一下 synchronized 關鍵字的底層原理
synchronized 關鍵字底層原理屬于 JVM 層面。
① synchronized 同步語句塊的情況
public class SynchronizedDemo { public void method() { synchronized (this) { System.out.println("synchronized 代碼塊"); } }}復制代碼通過 JDK 自帶的 javap 命令查看 SynchronizedDemo 類的相關字節碼信息：首先切換到類的對應目錄執行 javac SynchronizedDemo.java 命令生成編譯后的 .class 文件，然后執行javap -c -s -v -l SynchronizedDemo.class。
從上面我們可以看出：
synchronized 同步語句塊的實現使用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步代碼塊的開始位置，monitorexit 指令則指明同步代碼塊的結束位置。 當執行 monitorenter 指令時，線程試圖獲取鎖也就是獲取 monitor(monitor對象存在于每個Java對象的對象頭中，synchronized 鎖便是通過這種方式獲取鎖的，也是為什么Java中任意對象可以作為鎖的原因) 的持有權.當計數器為0則可以成功獲取，獲取后將鎖計數器設為1也就是加1。相應的在執行 monitorexit 指令后，將鎖計數器設為0，表明鎖被釋放。如果獲取對象鎖失敗，那當前線程就要阻塞等待，直到鎖被另外一個線程釋放為止。
② synchronized 修飾方法的的情況
public class SynchronizedDemo2 { public synchronized void method() { System.out.println("synchronized 方法"); }}synchronized 修飾的方法并沒有 monitorenter 指令和 monitorexit 指令，取而代之的確實是 ACC_SYNCHRONIZED 標識，該標識指明了該方法是一個同步方法，JVM 通過該 ACC_SYNCHRONIZED 訪問標志來辨別一個方法是否聲明為同步方法，從而執行相應的同步調用。
為什么要用線程池？
線程池提供了一種限制和管理資源(包括執行一個任務)。 每個線程池還維護一些基本統計信息，例如已完成任務的數量。
這里借用《Java并發編程的藝術》提到的來說一下使用線程池的好處：
- 降低資源消耗。 通過重復利用已創建的線程降低線程創建和銷毀造成的消耗。
- 提高響應速度。 當任務到達時，任務可以不需要的等到線程創建就能立即執行。
- 提高線程的可管理性。 線程是稀缺資源，如果無限制的創建，不僅會消耗系統資源，還會降低系統的穩定性，使用線程池可以進行統一的分配，調優和監控。
實現Runnable接口和Callable接口的區別
如果想讓線程池執行任務的話需要實現的Runnable接口或Callable接口。 Runnable接口或Callable接口實現類都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor執行。兩者的區別在于 Runnable 接口不會返回結果但是 Callable 接口可以返回結果。
備注： 工具類Executors可以實現Runnable對象和Callable對象之間的相互轉換。(Executors.callable(Runnable task)或Executors.callable(Runnable task，Object resule))。
執行execute()方法和submit()方法的區別是什么呢？
1)execute() 方法用于提交不需要返回值的任務，所以無法判斷任務是否被線程池執行成功與否；
2)submit()方法用于提交需要返回值的任務。線程池會返回一個future類型的對象，通過這個future對象可以判斷任務是否執行成功，并且可以通過future的get()方法來獲取返回值，get()方法會阻塞當前線程直到任務完成，而使用 get(long timeout，TimeUnit unit)方法則會阻塞當前線程一段時間后立即返回，這時候有可能任務沒有執行完。
如何創建線程池
《阿里巴巴Java開發手冊》中強制線程池不允許使用 Executors 去創建，而是通過 ThreadPoolExecutor 的方式，這樣的處理方式讓寫的同學更加明確線程池的運行規則，規避資源耗盡的風險**
Executors 返回線程池對象的弊端如下：
FixedThreadPool 和 SingleThreadExecutor ： 允許請求的隊列長度為 Integer.MAX_VALUE,可能堆積大量的請求，從而導致OOM。CachedThreadPool 和 ScheduledThreadPool ： 允許創建的線程數量為 Integer.MAX_VALUE ，可能會創建大量線程，從而導致OOM。
方式一：通過構造方法實現
方式二：通過Executor 框架的工具類Executors來實現 我們可以創建三種類型的ThreadPoolExecutor：
- FixedThreadPool ： 該方法返回一個固定線程數量的線程池。該線程池中的線程數量始終不變。當有一個新的任務提交時，線程池中若有空閑線程，則立即執行。若沒有，則新的任務會被暫存在一個任務隊列中，待有線程空閑時，便處理在任務隊列中的任務。
- SingleThreadExecutor： 方法返回一個只有一個線程的線程池。若多余一個任務被提交到該線程池，任務會被保存在一個任務隊列中，待線程空閑，按先入先出的順序執行隊列中的任務。
- CachedThreadPool： 該方法返回一個可根據實際情況調整線程數量的線程池。線程池的線程數量不確定，但若有空閑線程可以復用，則會優先使用可復用的線程。若所有線程均在工作，又有新的任務提交，則會創建新的線程處理任務。所有線程在當前任務執行完畢后，將返回線程池進行復用。
對應Executors工具類中的方法如圖所示：
最后
感謝你看到這里，文章有什么不足還請指正，覺得文章對你有幫助的話記得給我點個贊，每天都會分享java相關技術文章或行業資訊，歡迎大家關注和轉發文章！
總結
以上是生活随笔為你收集整理的线程中这么调用类_这些线程知识总结是真的到位！java开发两年的我看的目瞪口呆的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 内存之争：Kingston vs Cor
- 下一篇： 内存卡揭秘：你选对了吗？