2. 程式人生 > >Java基礎知識回顧之五 ----- 多線程

Java基礎知識回顧之五 ----- 多線程

阿新 • • 發佈：2018-11-28
結束 tin tails 進程和線程 ali 而不是 理由 run 博客園

前言

在上一篇文章中，回顧了Java的集合。而在本篇文章中主要介紹多線程的相關知識。主要介紹的知識點為線程的介紹、多線程的使用、以及在多線程中使用的一些方法。

線程和進程

線程

表示進程中負責程序執行的執行單元，依靠程序進行運行。線程是程序中的順序控制流，只能使用分配給程序的資源和環境。

進程

表示資源的分配和調度的一個獨立單元，通常表示為執行中的程序。一個進程至少包含一個線程。

進程和線程的區別

  1. 進程至少有一個線程;它們共享進程的地址空間;而進程有自己獨立的地址空間；
  2. 進程是資源分配和擁有的單位,而同一個進程內的線程共享進程的資源；
  3. 線程是處理器調度的基本單位,但進程不是；

生命周期

線程和進程一樣分為五個階段：創建

、就緒、運行、阻塞和終止。

  • 新建狀態:使用 new 關鍵字和 Thread 類或其子類建立一個線程對象後，該線程對象就處於新建狀態。它保持這個狀態直到程序start() 這個線程。
  • 就緒狀態:當線程對象調用了start()方法之後，該線程就進入就緒狀態。就緒狀態的線程處於就緒隊列中，要等待JVM裏線程調度器的調度。
  • 運行狀態:如果就緒狀態的線程獲取 CPU 資源，就可以執行 run()，此時線程便處於運行狀態。處於運行狀態的線程最為復雜，它可以變為阻塞狀態、就緒狀態和死亡狀態。
  • 阻塞狀態:如果一個線程執行了sleep（睡眠）、suspend（掛起）等方法，失去所占用資源之後，該線程就從運行狀態進入阻塞狀態。在睡眠時間已到或獲得設備資源後可以重新進入就緒狀態。可以分為三種：
    • 等待阻塞：運行狀態中的線程執行 wait() 方法，使線程進入到等待阻塞狀態。
    • 同步阻塞：線程在獲取 synchronized 同步鎖失敗(因為同步鎖被其他線程占用)。
    • 其他阻塞：通過調用線程的 sleep() 或 join() 發出了 I/O 請求時，線程就會進入到阻塞狀態。當sleep() 狀態超時，join() 等待線程終止或超時，或者 I/O 處理完畢，線程重新轉入就緒狀態。
  • 死亡狀態:一個運行狀態的線程完成任務或者其他終止條件發生時，該線程就切換到終止狀態。

可以用下述圖來進行理解線程的生命周期:
　技術分享圖片
註:上述圖來自http://www.runoob.com/wp-content/uploads/2014/01/java-thread.jpg。

在了解了線程和進程之後，我們再來簡單的了解下單線程和多線程。

單線程
程序中只存在一個線程，實際上主方法就是一個主線程。

多線程
多線程是指在同一程序中有多個順序流在執行。 簡單的說就是在一個程序中有多個任務運行。

那麽在什麽情況下用多線程呢?

一般來說，程序中有兩個以上的子系統需要並發執行的，這時候就需要利用多線程編程。通過對多線程的使用，可以編寫出高效的程序。

那麽是不是使用很多線程就能提高效率呢？

不一定的。因為程序中上下文的切換開銷也很重要，如果創建了太多的線程，CPU
花費在上下文的切換的時間將多於執行程序的時間！這時是會降低程序執行效率的。

所以有效利用多線程的關鍵是理解程序是並發執行而不是串行執行的。

線程的創建

一般來說，我們在對線程進行創建的時候，一般是繼承Thread 類或實現Runnable 接口。其實還有一種方式是實現 Callable接口，然後與Future 或線程池結合使用， 類似於Runnable接口，但是就功能上來說更為強大一些，也就是被執行之後，可以拿到返回值。

這裏我們分別一個例子使用繼承Thread 類、實現Runnable 接口和實現Callable接口與Future結合來進行創建線程。
代碼示例:
註：線程啟動的方法是start而不是run。因為使用start方法整個線程處於就緒狀態，等待虛擬機來進行調度。而使用run，也就是當作了一個普通的方法進行啟動，這樣虛擬機不會進行線程調度，虛擬機會執行這個方法直到結束後自動退出。

代碼示例:

public class Test {
    public static void main(String[] args) {
        ThreadTest threadTest=new ThreadTest();
        threadTest.start();

        RunalbeTest runalbeTest=new RunalbeTest();
        Thread thread=new Thread(runalbeTest);
        thread.start();

        CallableTest callableTest=new CallableTest();
        FutureTask<Integer> ft = new FutureTask<Integer>(callableTest);  
        Thread thread2=new Thread(ft);
        thread2.start();
        try {
            System.out.println("返回值:"+ft.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

class ThreadTest extends Thread{
     @Override
     public void run() {
        System.out.println("這是一個Thread的線程!");
    }
}

class RunalbeTest implements Runnable{
     @Override
     public void run() {
        System.out.println("這是一個Runnable的線程!");
    }
}

class CallableTest implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
         System.out.println("這是一個Callable的線程!");  
        return 2;
    }
}

運行結果:

    這是一個Thread的線程!
    這是一個Runnable的線程!
    這是一個Callable的線程!
    返回值:2

通過上述示例代碼中，我們發現使用繼承 Thread 類的方式創建線程時，編寫最為簡單。而使用Runnable、Callable 接口的方式創建線程的時候，需要通過Thread類的構造方法Thread(Runnable target) 構造出對象，然後調用start方法來運行線程代碼。順便說下，其實Thread類實際上也是實現了Runnable接口的一個類。

但是在這裏，我推薦大家創建單線程的時候使用繼承 Thread 類方式創建，多線線程的時候使用Runnable、Callable 接口的方式來創建創建線程。
至於為什麽呢?在下面中的描述已給出理由。

  • 繼承 Thread 類創建的線程，可以直接使用Thread類中的方法，比如休眠直接就可以使用sleep方法，而不必在前面加個Thread；獲取當前線程Id，只需調用getId就行，而不必使用Thread.currentThread().getId() 這麽一長串的代碼。但是使用Thread 類創建的線程，也有其局限性。比如資源不能共享，無法放入線程池中等等。

  • 使用Runnable、Callable 接口的方式創建的線程，可以實現資源共享，增強代碼的復用性，並且可以避免單繼承的局限性，可以和線程池完美結合。但是也有不好的，就是寫起來不太方便，使用其中的方法不夠簡介。

    總的來說就是，單線程建議用繼承 Thread 類創建，多線程建議- 使用Runnable、Callable 接口的方式創建。

線程的一些常用方法

yield

使用yield方法表示暫停當前正在執行的線程對象，並執行其他線程。

代碼示例:

public class YieldTest {
    public static void main(String[] args) {
        Test1 t1 = new Test1("張三");
        Test1 t2 = new Test1("李四");
        new Thread(t1).start();
        new Thread(t2).start();
    }
}

class Test1 implements Runnable {
    private String name;
    public Test1(String name) {
        this.name=name;
    }
    @Override
    public void run() {
        System.out.println(this.name + " 線程運行開始!");  
        for (int i = 1; i <= 5; i++) {
            System.out.println(""+this.name + "-----" + i);  
            // 當為3的時候，讓出資源
            if (i == 3) {
                Thread.yield();
            }
        }
        System.out.println(this.name + " 線程運行結束!");  
    }
}

執行結果一:

    張三 線程運行開始!
    張三-----1
    張三-----2
    張三-----3
    李四 線程運行開始!
    李四-----1
    李四-----2
    李四-----3
    張三-----4
    張三-----5
    張三 線程運行結束!
    李四-----4
    李四-----5
    李四 線程運行結束!

執行結果二:

張三 線程運行開始!
李四 線程運行開始!
李四-----1
李四-----2
李四-----3
張三-----1
張三-----2
張三-----3
李四-----4
李四-----5
李四 線程運行結束!
張三-----4
張三-----5
張三 線程運行結束!

上述中的例子我們可以看到，啟動兩個線程之後，哪個線程先執行到3，就會讓出資源，讓另一個線程執行。
在這裏順便說下，yield和sleep的區別。

  • yield： yield只是使當前線程重新回到可執行狀態，所以執行yield()的線程有可能在進入到可執行狀態後馬上又被執行。
  • sleep：sleep使當前線程進入停滯狀態，所以執行sleep()的線程在指定的時間內肯定不會被執行；

join

使用join方法指等待某個線程終止。也就是說當子線程調用了join方法之後，後面的代碼只有等待該線程執行完畢之後才會執行。

如果不好理解，這裏依舊使用一段代碼來進行說明。
這裏我們創建兩個線程，並使用main方法執行。順便提一下，其實main方法也是個線程。如果直接執行的話，可能main方法執行完畢了，子線程還沒執行完畢，這裏我們就讓子線程使用join方法使main方法最後執行。

代碼示例:

public class JoinTest {
    public static void main(String[] args) {
         System.out.println(Thread.currentThread().getName()+ "主線程開始運行!");  
         Test2 t1=new Test2("A");  
         Test2 t2=new Test2("B");  
         t1.start();  
         t2.start();  
          try {  
              t1.join();  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            try {  
                t2.join();  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }    
         System.out.println(Thread.currentThread().getName()+ "主線程運行結束!");  
    }

}

class Test2 extends Thread{  
    public Test2(String name) {  
        super(name);  
    }  
    public void run() {  
         System.out.println(this.getName() + " 線程運行開始!");  
       for (int i = 0; i < 5; i++) {  
           System.out.println("子線程"+this.getName() + "運行 : " + i);  
           try {  
               sleep(new Random().nextInt(10));  
           } catch (InterruptedException e) {  
               e.printStackTrace();  
           }  
       }  
       System.out.println(this.getName() + " 線程運行結束!");  
   }
}

執行結果:

    main主線程開始運行!
    B 線程運行開始!
    子線程B運行 : 0
    A 線程運行開始!
    子線程A運行 : 0
    子線程A運行 : 1
    子線程B運行 : 1
    子線程B運行 : 2
    子線程B運行 : 3
    子線程B運行 : 4
    B 線程運行結束!
    子線程A運行 : 2
    子線程A運行 : 3
    子線程A運行 : 4
    A 線程運行結束!
    main主線程運行結束!

上述示例中的結果顯然符合我們的預期。

priority

使用setPriority表示設置線程的優先級。
每個線程都有默認的優先級。主線程的默認優先級為Thread.NORM_PRIORITY。
線程的優先級有繼承關系，比如A線程中創建了B線程，那麽B將和A具有相同的優先級。
JVM提供了10個線程優先級，但與常見的操作系統都不能很好的映射。如果希望程序能移植到各個操作系統中，應該僅僅使用Thread類有以下三個靜態常量作為優先級，這樣能保證同樣的優先級采用了同樣的調度方式

  • static int MAX_PRIORITY 線程可以具有的最高優先級，取值為10。
  • static int MIN_PRIORITY 線程可以具有的最低優先級，取值為1。
  • static int NORM_PRIORITY 分配給線程的默認優先級，取值為5。

但是設置優先級並不能保證線程一定先執行。我們可以通過一下代碼來驗證。

代碼示例:

public class PriorityTest {
  public static void main(String[] args) {
        Test3 t1 = new Test3("張三");
        Test3 t2 = new Test3("李四");
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }
}

class Test3 extends Thread {
    public Test3(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.getName() + " 線程運行開始!");  
        for (int i = 1; i <= 5; i++) {
            System.out.println("子線程"+this.getName() + "運行 : " + i); 
            try {  
                sleep(new Random().nextInt(10));  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            } 
        }
        System.out.println(this.getName() + " 線程運行結束!");  
    }
}

執行結果一:

李四 線程運行開始!
子線程李四運行 : 1
張三 線程運行開始!
子線程張三運行 : 1
子線程張三運行 : 2
子線程李四運行 : 2
子線程李四運行 : 3
子線程李四運行 : 4
子線程張三運行 : 3
子線程李四運行 : 5
李四 線程運行結束!
子線程張三運行 : 4
子線程張三運行 : 5
張三 線程運行結束!

執行結果二:

張三 線程運行開始!
子線程張三運行 : 1
李四 線程運行開始!
子線程李四運行 : 1
子線程張三運行 : 2
子線程張三運行 : 3
子線程李四運行 : 2
子線程張三運行 : 4
子線程李四運行 : 3
子線程張三運行 : 5
子線程李四運行 : 4
張三 線程運行結束!
子線程李四運行 : 5
李四 線程運行結束!

執行結果三:

李四 線程運行開始!
子線程李四運行 : 1
張三 線程運行開始!
子線程張三運行 : 1
子線程李四運行 : 2
子線程李四運行 : 3
子線程李四運行 : 4
子線程張三運行 : 2
子線程張三運行 : 3
子線程張三運行 : 4
子線程李四運行 : 5
子線程張三運行 : 5
李四 線程運行結束!
張三 線程運行結束!

線程中一些常用的方法

線程中還有許多方法，但是這裏並不會全部細說。只簡單的列舉了幾個方法使用。更多的方法使用可以查看相關的API文檔。這裏我也順便總結了一些關於這些方法的描述。

  1. sleep：在指定的毫秒數內讓當前正在執行的線程休眠（暫停執行）;不會釋放對象鎖。
  2. join：指等待t線程終止。
  3. yield：暫停當前正在執行的線程對象，並執行其他線程。
  4. setPriority：設置一個線程的優先級。
  5. interrupt：一個線程是否為守護線程。
  6. wait：強迫一個線程等待。它是Object的方法，也常常和sleep作為比較。需要註意的是wait會釋放對象鎖，讓其它的線程可以訪問；使用wait必須要進行異常捕獲，並且要對當前所調用，即必須采用synchronized中的對象。
  7. isAlive: 判斷一個線程是否存活。
  8. activeCount: 程序中活躍的線程數。
  9. enumerate: 枚舉程序中的線程。
  10. currentThread: 得到當前線程。
  11. setDaemon: 設置一個線程為守護線程。(用戶線程和守護線程的區別在於，是否等待主線程依賴於主線程結束而結束)。
  12. setName: 為線程設置一個名稱。
  13. notify(): 通知一個線程繼續運行。它也是Object的一個方法，經常和wait方法一起使用。

結語

其實這篇文章很久之前都已經打好草稿了，但是由於各種原因，只到今天才寫完。雖然也只是簡單的介紹了一下多線程的相關知識，也只能算個入門級的教程吧。不過寫完之後，感覺自己又重新復習了一遍多線程，對多線程的理解又加深了一些。
話已盡此，不在多說。
原創不易，如果感覺不錯，希望給個推薦！您的支持是我寫作的最大動力！

參考:https://blog.csdn.net/evankaka/article/details/44153709#t1

版權聲明:
作者：虛無境
博客園出處：http://www.cnblogs.com/xuwujing
CSDN出處：http://blog.csdn.net/qazwsxpcm　　　　
個人博客出處：http://www.panchengming.com

Java基礎知識回顧之五 ----- 多線程

相關推薦

Java基礎知識回顧之五 ----- 多線程

結束 tin tails 進程和線程 ali 而不是 理由 run 博客園 前言 在上一篇文章中，回顧了Java的集合。而在本篇文章中主要介紹多線程的相關知識。主要介紹的知識點為線程的介紹、多線程的使用、以及在多線程中使用的一些方法。 線程和進程 線程 表示進程中負責程序執

Java基礎知識回顧之五 ----- 多執行緒

前言 在上一篇文章中，回顧了Java的集合。而在本篇文章中主要介紹多執行緒的相關知識。主要介紹的知識點為執行緒的介紹、多執行緒的使用、以及在多執行緒中使用的一些方法。 執行緒和程序 執行緒 表示程序中負責程式執行的執行單元，依靠程式進行執行。執行緒是程式中的順序控制流，只能使用分配給程式的資源和環境。 程序

JAVA基礎知識總結12（多線程）

必須 對象 存放位置 垃圾 java基礎知識 current syn 原理 運行 進程：正在進行中的程序。其實進程就是一個應用程序運行時的內存分配空間。 線程：其實就是進程中一個程序執行控制單元，一條執行路徑。進程負責的是應用程序的空間的標示。線程負責的是應用程序的執行順序

Java基礎知識回顧之三 ----- 封裝、繼承和多態

get flex 防止 應用 需要 當前 nim lex aging 前言 在上一篇中回顧了java的修飾符和String類，這篇就來回顧下Java的三大特性:封裝、繼承、多態。 封裝 什麽是封裝 在面向對象程式設計方法中，封裝是指一種將抽象性函式接口的實現細節部份包裝、

Java基礎知識回顧之多型性

Java基礎知識回顧之封裝性 Java基礎知識回顧之繼承性 Java基礎知識回顧之多型性 簡介 多型的核心就是型別的一致性。物件上的每一個引用和靜態的型別檢查器都要確認這樣的依附（多個子類繼承一個父類）。 多型性嚴格來講有兩種描述形式 方法的多型性

Java基礎知識回顧之六 ----- IO流

.net 是否 簡單 取數據 高效 它的 .cn 回顧 們的 前言 在上一篇文章中，回顧了Java的多線程。而在本篇文章中主要介紹Java IO的相關知識。 IO的介紹 什麽是IO？ IO的名稱又來是Input與Output的縮寫，也就是輸入流和輸出流。輸入流用於從源讀取

Java基礎知識回顧之七 ----- 總結篇

停止 pub mina 特定 文本 定義 們的 value 鍵值 前言 在之前Java基礎知識回顧中，我們回顧了基礎數據類型、修飾符和String、三大特性、集合、多線程和IO。本篇文章則對之前學過的知識進行總結。除了簡單的復習之外，還會增加一些相應的理解。 基礎數據類型

Java基礎知識回顧之四 ----- 集合List、Map和Set

linked 訪問速度 因此 比較 foreach循環 代碼示例 的區別 不同的 寫法 前言 在上一篇中回顧了Java的三大特性：封裝、繼承和多態。本篇則來介紹下集合。 集合介紹 我們在進行Java程序開發的時候，除了最常用的基礎數據類型和String對象外，也經常會用到集

Java基礎知識回顧之二 ----- 修飾符和String

表達式 概述 xxx 實驗 有時 原則 得到 私有 ali 前言 在上一篇中，回顧了Java的基本數據類型 ，這篇就來回顧下Java中的一些修飾符以及String。 修飾符介紹 Java修飾符主要分為兩類: 訪問修飾符 非訪問修飾符 其中訪問修飾符主要包括 privat

Java基礎知識回顧之介面

抽象類與介面的區別： No. 區別 抽象類 介面 1 關鍵字 abstract class interface 2

Java基礎知識回顧之抽象類

簡介 如果是需要了解抽象類，就需要知道什麼普通類。對於普通類，可以直接產生例項化物件，並且在普通類之中可以包含有構造方法、普通方法、static 方法、常量、變數等內容。而所謂的抽象類就是指在普通類的結構中增加抽象方法的組成部分。 在所有的普通方法上都會有一個“{}”，這個表示方

Java基礎知識回顧之物件比較

說明 如果是需要判斷兩個數字是否相等，可以使用" == "，如果是判斷字串是否相等，是使用 “equals()”。如果是現在判斷一個自定義的類，要想判斷兩個物件是否相等，那麼應該是需要比較在類物件之中所有屬性內容的比較，只有所有屬性內容相等，才算相等。 直接比較屬性 如果我們

Java基礎知識回顧之Object類

簡介 類Object是類層次結構的根類。每個類都使用Object作為超類。所有物件(包括陣列)都實現這個類的所有方法。我們接觸到的元素有：物件、陣列、介面等，這麼多的元素為了方便統一，就可以使用 Object。 任何一個類在定義的時候如果沒有明確的繼承一個父類的話，那麼他就是Ob

Java基礎知識回顧之static應用與總結

相關關鍵字的說明： this關鍵字 final關鍵字 static關鍵字修飾屬性 static關鍵字修飾方法 static關鍵字應用與總結 前面兩篇分別介紹了static的屬性以及方法。本篇就做一個收尾，介紹下剩下的。 在之前的總結： 不管多少個物件，都使用同一個 s

Java基礎知識回顧之static修飾方法

相關關鍵字的說明： this關鍵字 final關鍵字 static關鍵字修飾屬性 static關鍵字修飾方法 static關鍵字應用與總結 前面一篇已經介紹了部分關於 static 的用法，主要是介紹的是 static 修飾變數的一些知識。現在的這篇介紹下 static 修飾方法。

Java基礎知識回顧之static修飾屬性

相關關鍵字的說明： this關鍵字 final關鍵字 static關鍵字修飾屬性 static關鍵字修飾方法 static關鍵字應用與總結 static 關鍵字，我們在開發用的還是比較多的。在《Java程式設計思想》有下面一段話 static 方法就是沒有 this 的方

Java基礎知識回顧之final關鍵字

相關關鍵字的說明： this關鍵字 final關鍵字 static關鍵字修飾屬性 static關鍵字修飾方法 static關鍵字應用與總結 簡介 在 Java 中我們把 final 稱為終結器，在 Java 中可以使用 final 定義類、方法、屬性。通過 final 修飾以後，

Java基礎知識回顧之this關鍵字

相關關鍵字的說明： this關鍵字 final關鍵字 static關鍵字修飾屬性 static關鍵字修飾方法 static關鍵字應用與總結 具體內容 在 Java 程式中，當區域性變數和全域性變數資料型別和名稱都相同的時，此時全域性變數會被隱藏而變得不能使用。即：區域性變數會覆蓋

Java基礎知識回顧之可變引數

簡介 從 JDK 1.5 中，引入了可變引數的新特性。如果說要設計一個方法，這個方法可以接收任意多個整型資料。可以直接用（資料型別 ...屬性名）來解決。 使用可變引數時要注意，一個方法只能有一個可變引數，當方法含有多個引數時，可變引數要放在最後面。 public int a

Java基礎知識回顧之方法過載

定義 方法過載（Overloading）的定義：如果有兩個方法的方法名相同，但引數不一致，哪麼可以說一個方法是另一個方法的過載。 具體說明如下： 方法名相同 方法的引數型別，引數個不一樣 方法的返回型別可以不相同 方法的修飾符可以不相同 main