今天就跟大家聊聊有關怎么在java虛擬機中實現(xiàn)多線程，可能很多人都不太了解，為了讓大家更加了解，小編給大家總結了以下內容，希望大家根據(jù)這篇文章可以有所收獲。

專注于為中小企業(yè)提供網(wǎng)站制作、成都網(wǎng)站建設服務,電腦端+手機端+微信端的三站合一,更高效的管理,為中小企業(yè)雙遼免費做網(wǎng)站提供優(yōu)質的服務。我們立足成都，凝聚了一批互聯(lián)網(wǎng)行業(yè)人才，有力地推動了成百上千企業(yè)的穩(wěn)健成長，幫助中小企業(yè)通過網(wǎng)站建設實現(xiàn)規(guī)模擴充和轉變。

1.線程池基本參數(shù)

以Executors.newFixedThreadPool(）這種創(chuàng)建方式為例：

大家想象，假如你創(chuàng)建一個線程池，你想這個池子有些什么參數(shù)呢？首先這個池子必須要有一個最大值；然后還希望這個池子的線程數(shù)量有一個警戒線，到了這個警戒線的位置說明線程池暫時已經(jīng)滿了，如果這個時候還有人過來拿線程，我們就要把這些人抓起來扔到一個地方去讓他們排隊，告訴他們：請稍等，等我們的線程有空閑的時候再來處理你的事；再然后假如人排隊的地方都滿了，瑪?shù)?，好多人，于是線程池就想辦法東拼西湊又多搞出來了幾個線程去處理了；最后，假如那搞出來的這幾個線程還是不夠用，并且排隊的地方總是滿的，于是線程池生氣了，就這么多人可以了，如果還有人過來的趕緊讓它滾蛋；

這里我們需要知道幾個東西：

1這里的警戒線叫做核心線程池大?。╟orePoolSize）；

2.最大值還是叫做線程池線程最大數(shù)量（maximumPoolSize）

3.排隊的地方叫做隊列（BlockingQueue ），這個隊列用于保存我們的線程要做的任務，這個隊列有好幾種類型，我們后面會分析的；

4.還有一個參數(shù)是keepAliveTime：線程存活時間，意思就是當池中總共的線程大于核心線程池數(shù)目，那就關閉池子中的空閑線程，要保證線程總數(shù)維持在核心線程池數(shù)目或者之下；

現(xiàn)在我們來理一下邏輯：

池中當前線程數(shù)量 <= 核心線程池大?。壕€程池直接創(chuàng)建線程處理

池中當前線程數(shù)量 > 核心線程池數(shù)量：將多余的任務放進隊列

隊列滿了，還有任務過來，線程池繼續(xù)創(chuàng)建線程，直到到達線程池最大數(shù)量

還有任務過來，這里會有一個飽和策略，默認是直接丟棄繼續(xù)過來的任務

2.線程池種類

我們上一節(jié)使用的線程池如下所示：

ExecutorService pool = Executors.newFixedThreadPool(3);
pool.execute(new RunnableImpl("玩游戲"));

我們是通過Executors這個類的靜態(tài)方法創(chuàng)建的一個線程池，于是進入這個類我們看看這個類還有沒有創(chuàng)建其他種類線程池的方法，居然還真有。。。

我們先簡單說說這四種分別是干嘛用的；

newFixedThreadPool（int）：這個線程池就是上面說的那種方式，也是我們重點要看源碼的線程池；

newSingThreadExecutor()：這個不能說是線程池了，因為里面這里面只有一個線程，而且自帶一個隊列，只要有任務來了就會把任務保存到隊列中，然后這個線程就慢慢的一個一個執(zhí)行。

newCachedThreadPool()：無限線程的線程池

newScheduledThreadPool(int)：一個定時的線程池，可以讓線程池中的線程延遲指定時間再執(zhí)行任務；

3.Executors繼承結構

我們可以看到實際上實例化的是一個ThreadPoolExecutor對象，這個對象作用是用線程去處理傳進去的任務：

我們看一下這個繼承結構，

Executor接口：只是定義了execute();這個方法，等待子類去實現(xiàn)；

ExecutorService接口：繼承Execute接口，并又聲明了shutdown（）方法和submit（）方法，等待子類去實現(xiàn)

AbstractExecutorService抽象類：初步實現(xiàn)了submit（）方法，但是內部調用的execute（）方法去執(zhí)行任務

ThreadPoolExecutor類：這個類是實現(xiàn)了很多的方法，將shutdown（）和execute（）方法都給實現(xiàn)了；

4.看看execute()方法源碼

下面我們主要就是看看execute（）方法的內部是怎么實現(xiàn)的，知道了這個的實現(xiàn)原理也就差不多了　

 public void execute(Runnable command) {
  if (command == null)
   throw new NullPointerException();
   int c = ctl.get();
　　　　
//workCountOf（c）表示當前線程池中線程的數(shù)量；這里進行一個判斷，當線程池中線程數(shù)目小于核心池子數(shù)目時，
　　就調用addWorker（）方法將我們的任務添加進去，等下可以看到addWorker（）方法內部其實就是創(chuàng)建線程并處理請求，
　　就類似new Thread（xxx）.start()這種方式
 　　　　if (workerCountOf(c) < corePoolSize) {
   if (addWorker(command, true))
    return;
   c = ctl.get();
  }

//如果當前線程數(shù)目大于核心線程并且任務放入一個隊列成功，內部還會再次進行線程池狀態(tài)判斷，這里的&&用得比較精髓（短路作用），好好體會一下，
　　假如不是運行狀態(tài)那就會執(zhí)行remove方法 刪除隊列中的任務，如果是運行狀態(tài)直接進入else if，這里的目的是線程池中已經(jīng)關閉了，我們添加一個null任務
　　表示線程池不再處理任務  
　　　　if (isRunning(c) && workQueue.offer(command)) {
   int recheck = ctl.get();
   if (! isRunning(recheck) && remove(command))
    reject(command);
   else if (workerCountOf(recheck) == 0)
    addWorker(null, false);
  }

//能執(zhí)行到這里，說明上面兩個if中的條件都不滿足，條件應該是：當前線程大于核心線程，并且向隊列中添加任務失敗，換句說說就是對列已經(jīng)滿了，裝不下這么多任務
　　于是我們reject（）方法內部就是對這些多余的任務進行處理的一些策略，默認就是直接丟棄
  else if (!addWorker(command, false))
   reject(command);
 }

對于面這三種情況的判斷還是很清楚的，我們忽略很多細節(jié)，因為我們的目的是要對整個邏輯有個大概的了解，而不是去完全消化這些源碼，這很不現(xiàn)實，要想理解透徹只能慢慢的去研究...

我們來看看最重要的addWorker（）這個方法，這個方法就是線程池將我們傳進來的new Runnable(xxx)進行處理，其實內部就是用new Thread（xxxx）.start()處理，只是出于線程池中會進行很多的條件判斷以及將Runnable（）做進一步的封裝，我們了解就好，代碼如下：

private boolean addWorker(Runnable firstTask, boolean core) {
  //這里刪除很多的條件判斷的代碼
　　　　..........
　　　　
　　　　 boolean workerStarted = false;
  boolean workerAdded = false;
  Worker w = null;
  try {
   final ReentrantLock mainLock = this.mainLock;
   //注意下面這兩行，其實就是將我們傳進來的Runnable（）進行封裝成Worker，在Worker構造器里面會new Thread（）并且保存起來
　　　　　　　這樣做的一個好處就是直接將一個線程和一個Runnable進行綁定，我們隨時可以從Worker中獲取線程然后調用start（）方法就ok了
　　　　　　　w = new Worker(firstTask);
   final Thread t = w.thread;
   if (t != null) {
    mainLock.lock();
    try {
     //此處刪除一些
　　　　　　　　　　　　.........
     if (rs < SHUTDOWN ||
      (rs == SHUTDOWN && firstTask == null)) {
      if (t.isAlive()) // precheck that t is startable
       throw new IllegalThreadStateException();

　　　　　　　　　　　　　　//由于會有很多個Worker，于是我們會創(chuàng)建HashSet workers = new HashSet()，用于保存所有的worker，后續(xù)直接遍歷處理很方便
　　　　　　　　　　　　　　而且我們所說的線程池的本質就是這個workers，也就是一個HashSet
　　　　　　　　　　　　　　workers.add(w); 
　　　　　　　　　　　　　　int s = workers.size();
      if (s > largestPoolSize)
       largestPoolSize = s;
      workerAdded = true;
     }
    } finally {
     mainLock.unlock();
    }
　　　　　　　　　　//下面這個if語句中就是一個無限循環(huán)的去執(zhí)行線程的start（）方法
    if (workerAdded) {
     t.start();
     workerStarted = true;
    }
   }
  }return workerStarted;
 }

說出來你可能不信，我有點沒看懂這里，因為最后的那個start（）方法總感覺有點問題，但是說不上來，你們覺得這個start（）方法之后，CPU來運行這個線程會執(zhí)行哪個run（）方法？是我們傳進去的類的run（）方法？還是worker的run（）方法呢？

我們看看下面這兩行代碼，Worker構造器中的新建線程的代碼就不截圖了，我們把下面這幾行代碼變化一下：

Worker w = new Worker(firstTask);
final Thread t = w.thread;
........
t.start()

變化后：

Worker w = new Worker(firstTask);//firstTask是我們傳進去的實現(xiàn)了Runnable接口的類，但是Worker也實現(xiàn)了Runnable接口　

final Thread t = getThreadFactory().newThread(w

t.start()

看完上述內容，你們對怎么在java虛擬機中實現(xiàn)多線程有進一步的了解嗎？如果還想了解更多知識或者相關內容，請關注創(chuàng)新互聯(lián)行業(yè)資訊頻道，感謝大家的支持。