JDK成長記10：Thread的基本原理和常見應用場景，你都知道么？

相信你經過集合篇的成長，已經對JDK源碼的學習輕車熟路了。接下來你將一起和我進入后半篇的學習。讓我們開始吧！

在接下來10分鍾，你將學習到thread 的源碼原理、線程的狀態變化、線程的常用場景。

Thread基礎回顧

Thread基礎回顧

什么是Thread?

Thread顧名思義，是線程。你應該知道，一個java程序在操作系統上運行，會啟動一個JVM進程，具有一個進程ID，這個進程可以創建很多個線程。操作系統、程序、進程、線程關系如下圖所示：

運行一個線程其實就是啟動一個執行分支，執行不同的事情，執行分支時可以是阻塞的也可以是異步的。舉一個例子，假如你需要燒開水，還想玩手機。異步就是你燒開水的時候，可以玩手機，阻塞就是你就一直等着水燒開了，再開始玩手機。

創建線程Thread

創建線程的方式一般是2種。一種是繼承Thread重寫run方法，一種是實現Runnable或Callable接口之后,創建Thread。

當然通過線程池也能說算是一種方式，但是底層還是上面的兩種方式之一，沒什么區別。

這里帶你回顧下，代碼如下：

代碼清單: LinkedListDemo創建LinkedList

public static void main(String[] args) {
       //創建線程1
      new Thread(()-> System.out.println(Thread.currentThread().getName()),"demo1").start();
       //創建線程2
      new Thread(new MyThread(),"demo2").start();
       //創建線程3
       ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
.setNameFormat("demo-pool-%d")
.build();
       ExecutorService singleThreadPool = new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(1024),
namedThreadFactory,
new ThreadPoolExecutor.AbortPolicy());
       singleThreadPool.execute(()-> System.out.println(Thread.currentThread().getName()));
       singleThreadPool.shutdown();   
   }

   static class MyThread extends Thread{
       @Override
       public void run() {
          System.out.println(Thread.currentThread().getName());
       }
}

線程Thread的常用方法

相信這些方法你一定很熟悉了,這里就不過多贅述了。我想讓你掌握的重點是剖析線程如何在開源項目中的使用，從而更好的理解原理，更好的運用線程，這個在成長記后面會給大家講解的。

• start() 啟動一個線程

• join() 加入一個線程

• sleep() 線程休眠一陣子

• isAlive() 線程是否存活

• interupted() 標記線程為中斷

• sinterupted() 線程是否中斷

另外還有以下這些方法不經常用，也不建議使用

destroy() 、stop()、 suspend()、 resume()、 yeild()

在開源項目和實際業務系統或者基礎架構系統也是很少使用到的。

線程的狀態

線程中其實最重要的就是它的狀態流轉。這里直接給大家看一個圖，這個圖非常重要，對分析后面的源碼有很大幫助。大家一定要牢記於心，線程狀態圖如下所示：

線程應用場景舉例

線程應用場景舉例

當你回顧了線程的基本知識，這來舉幾個例子。

在各個開源框架中，線程的應用場景非常廣泛，這里給大家舉幾個例子，主要是為了，讓你明白下熟練掌握線程的重要性。之后的相關的成長記你會學到具體是怎么使用線程的細節的。

線程應用舉例1 心跳和監控時使用線程

在微服務系統中，經常使用到的一個服務就是注冊中心。注冊中心簡單的講就是讓一個服務訪問另一個服務的時候，可以知道對方所有實例的地址，可以用來在調用的時候選擇。這就需要每個服務的實例要注冊自己的信息到一個公共的地方，這個地方就是注冊中心。

每個實例有一個客戶端用來和服務端通信，在Spring Cloud實現的微服務技術棧中，Eureka這個組件就充當了注冊中心的作用。它的服務端Eureka-Server大量使用了一些Thread。這里我舉兩個場景，讓大家感受下Thread的應用。

一個是場景，每個服務的實例需要發送心跳，告訴注冊中心自己還在線，服務還存活着。服務端通過一個線程來判斷，某個服務如果在一定時間內不發送心跳了，就認為它故障了，就會把它注冊中心剔除掉。如圖中藍色部分的圓圈所示。

另一個是場景，Eureka server將每個服務實例注冊的信息放到了一個內存map中，為了提高速度和並發能力，它設置了多個緩存，有寫緩存和讀緩存。Eureka client客戶端讀取的是讀緩存。什么時候將寫緩存數據刷入到讀緩存?就是通過一個后台線程，每隔30秒從寫緩存刷新到讀緩存中。

客戶端也有一個后台線程，每隔30秒會發起http請求，從服務端讀取注冊中心的數據。

總之，在這個場景中，線程用於了心跳和監控，是非常常見的場景。因為在很多開源項目中都是這樣做的，比如hdfs，zookeeper等等。

線程應用舉例2 定時更新、保存、刪除數據

在MySQL、Redis、ES、HDFS、Zookeeper等等的開源項目中，都會有線程的概念，來定時保存數據，或者刷新磁盤，清理磁盤等等操作。

它們一般其實都很類似，都是保存到磁盤的一個就是操作日志，一個就是快照數據。

比如hdfs中的checkpoint線程，用來自動合並edit_log為fsImage、自動清除edit_log線程、比如mysql定時刷入bufferPool的數據到磁盤中的線程。比如Zookeeper保存WAL日志、或者mysql定時保存dump文件，redis的快照等等。

線程應用舉例3 多線程提高處理速度和性能

比較典型的就是Storm、Flink、Spark分布式計算就是使用多線程計算提高性能，當然還有MQ的多線程消費，也是典型的多線程提高了處理性能。

這里不就不一一舉例了。有興趣的同學可以在評論區里寫下自己知道的開源項目中如何使用線程。

Thread源碼剖析

Thread源碼剖析

回顧了線程的基本知識使用場景，接下來你需要了解下Thread的源碼，才能更好的理解它，使用它。

下面主要通過創建線程，啟動線程，線程狀態變化操作這幾個場景簡單摸一下Thread的源碼。

第一個場景：創建線程

newThread(

   ()-> System.out.println(Thread.currentThread().getName()),"demo1"

).start();

讓我們分析一下這行代碼,首先是new Thread，會進入構造函數。

public Thread(Runnabletarget) {
 
   init(null, target,"Thread-"+ nextThreadNum(), 0);
 
}

調用了init方法前，調用了nextThreadNum方法，生成了一個自增id，和Thread-+num 作為線程名字。

/* For autonumbering anonymous threads. */

private static intthreadInitNumber;

private static synchronized int nextThreadNum() {

  return threadInitNumber++;

}

上面源碼總結為下圖：

默認生成線程名字之后，調用4個參數的init方法，接着又繼續調用了6個參數的init方法。

private void init(ThreadGroupg, Runnable target,String name,
 
         long stackSize) {
 
   init(g, target, name, stackSize,null, true);
 
 }

這個init是創建線程核心的步驟我們來看下它的脈絡。

private void init(ThreadGroupg, Runnable target,String name,
 
         long stackSize, AccessControlContextacc,
 
         booleaninheritThreadLocals) {
 
   if(name ==null) {
 
     throw newNullPointerException("name cannot be null");
 
   }
 
 
 
   this.name = name;
 
 
 
   Thread parent= currentThread();
 
   SecurityManager security= System.getSecurityManager();
 
   if(g ==null) {
 
     if(security !=null) {
 
       g = security.getThreadGroup();
 
     }
 
     if(g ==null) {
 
       g = parent.getThreadGroup();
 
     }
 
   }
 
   g.checkAccess();
 
   if(security !=null) {
 
     if(isCCLOverridden(getClass())) {
 
       security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
 
     }
 
   }
 
 
 
   g.addUnstarted();
 
 
 
   this.group = g;
 
   this.daemon =parent.isDaemon();
 
   this.priority =parent.getPriority();
 
   if(security ==null || isCCLOverridden(parent.getClass()))
 
     this.contextClassLoader= parent.getContextClassLoader();
 
   else
 
     this.contextClassLoader=parent.contextClassLoader;
 
  this.inheritedAccessControlContext=
 
       acc !=null ? acc : AccessController.getContext();
 
   this.target = target;
 
   setPriority(priority);
 
   if(inheritThreadLocals && parent.inheritableThreadLocals!= null)
 
     this.inheritableThreadLocals=
 
       ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
 
   /* Stash the specified stack size in case the VM cares */
 
   this.stackSize = stackSize;
 
 
 
   /* Set thread ID */
 
   tid= nextThreadID();
 
 }

上面的代碼從脈絡可以分為4點：

1. 設置線程名稱，默認是Thread+全局自增id
2. 設置線程組 父線程默認是當前線程，默認線程所屬組為父線程組
3. 優先級和是否是后台線程 默認和父線程相同
4. 保存傳入的Runnable或Callable的run方法

如下圖所示：

這個線程創建的過程，你需要記住的核心點就是以下幾點：

創建你的線程，就是你的父線程

如果你沒有指定ThreadGroup，你的ThreadGroup就是父線程的ThreadGroup

你的daemon狀態默認是父線程的daemon狀態

你的優先級默認是父線程的優先級

如果你沒有指定線程的名稱，那么默認就是Thread-0格式的名稱

你的線程id是全局遞增的，從1開始

第二個場景：啟動線程

當創建了線程后，接着就是啟動線程了。你一定知道，thread啟動一個線程使用通過start方法。它的底層邏輯很簡單，代碼如下：

public synchronized void start() {
  if(threadStatus !=0)
    throw newIllegalThreadStateException();

  group.add(this);

  boolean started =false;

  try{
    start0();
    started =true;
  } finally{
    try{
      if(!started) {
        group.threadStartFailed(this);
      }
    } catch(Throwable ignore) {


    }
  }
}

還是來看下核心脈絡：

1、判斷線程狀態，不能重復啟動

2、放入線程組

3、調用一個native方法啟動線程，如果失敗從線程組中移除。

這個navive方法是C++實現的，具體我們不去研究了，你只要知道本質是將線程交給CPU線程執行調度器執行，之后CPU會通過時間片的算法來執行各個線程，就可以了。如下圖所示：

啟動完成后，肯定會調用run方法，這里的run方法就是之前構造函數保存的Runnable動的run方法。如果是繼承Thread方式創建的線程，這個run方法被重寫了，所以下面這段邏輯只是適用於Runnalbe或Callable方式創建的Thread。

@Override
 public void run() {
   if(target !=null) {
     target.run();
   }
 }

第三個場景：線程狀態變化操作

了解了創建線程和不知道你還記得之前的線程狀態圖么？怎么進入到其他狀態呢？讓我們一起來看看狀態變化的一些線程操作。

一個線程創建時候是NEW啟動后變為Runnable。之后怎么變為WAITING呢？其實有很多種方法，我們這里講一個常用的方法join()。當然調用Obejct.wait()或LockSupport.part()操作也會實現同樣的效果，這個我們的成長記后面會講到，大家不要着急。

顧名思義，join表示加入的意思。意思就是另一線程加入到執行過程中，當前線程需要等待加入的線程執行完成才能繼續執行。如下圖所示:

接着我們看下如何進入TimeWaiting狀態呢？其實也很簡單。你可以通過使用sleep方法來進入這個狀態。sleep方法支持傳入等待時間。一般有兩種方式一個是直接傳入毫秒值比如 60 * 1000表示60秒，一個是可以通過TimeUnit這個工具傳遞時間。但是大多數開源項目為了靈活，使用的都是第一種方式，因為第二種方式限制了單位，如果需要修改的話，使用起來就不太靈活了。使用sleep的流程如下：

如果你看sleep的源碼，發現就是一個native方法，底層肯定是通過C++代碼，通知CPU線程休眠一陣子。無論在Java線程模型還是CPU的線程模型，其實線程狀態的變化都是一樣的，其實線程的狀態的模型是一個抽象概念。

最后線程如何進入Block狀態？其實是通過syncronized加鎖后，被阻塞的線程就會進入block狀態。后面講到syncronized的時候詳細分析。這里就不過多說明了。

好了到這里，我們通過線程的核心的三個場景分析了thread的源碼原理。相信你對thread有了進一步的認識了，但是更重要的是，你要不斷的積累使用thread的場景，在合適的使用thread的方法。理解線程的狀態變化就顯得更為重要。

本文由博客群發一文多發等運營工具平台 OpenWrite 發布