2. 程式人生 > >Java並發編程（一）Thread詳解

Java並發編程（一）Thread詳解

阿新 • • 發佈：2018-10-10
能夠 lds readn 暫停 正在執行 思考 基本 進程 -c

一、概述

在開始學習Thread之前，我們先來了解一下 線程和進程之間的關系：

線程(Thread)是進程的一個實體，是CPU調度和分派的基本單位。 線程不能夠獨立執行，必須依存在應用程序中，由應用程序提供多個線程執行控制。 線程和進程的關系是：線程是屬於進程的，線程運行在進程空間內，同一進程所產生的線程共享同一內存空間，當進程退出時該進程所產生的線程都會被強制退出並清除。

由上描述，可以得知線程作為cpu的基本調度單位，只有把多線程用好，才能充分利用cpu的多核資源。

本文基於JDK 8（也可以叫JDK 1.8）。

二、線程使用

2.1 啟動線程

創建線程有四種方式：

  • 實現Runnable接口
  • 繼承Thread類
  • 使用JDK 8 的Lambda
  • 使用Callable和Future

2.1.1 Runnable創建方式

public class MyThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
Thread thread = new Thread(new MyThread());
thread.start();

2.1.2 繼承Thread創建方式

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

以上代碼有更簡單的寫法，如下：

Thread thread = new Thread(){
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
};
thread.start();

2.1.3 Lambda創建方式

new Thread(()-> System.out.println(Thread.currentThread().getName())).start();

2.1.4 使用Callable和Future

看源碼可以知道Thread的父類是Runnable是JDK1.0提供的，而Callable和Runnable類似，是JDK1.5提供的，彌補了調用線程沒有返回值的情況，可以看做是Runnable的一個補充，下面看看Callable的實現。

public class MyThread implements Callable<String> {

    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        return Thread.currentThread().getName();
    }
}
Callable<String> callable = new MyThread();
FutureTask<String> ft = new FutureTask<>(callable);
new Thread(ft,"threadName").start();
System.out.println(ft.get());

2.1.5 run()和start()的區別

真正啟動線程的是start()方法而不是run()，run()和普通的成員方法一樣，可以重復使用，但不能啟動一個新線程。

2.2 Thread的常用方法

Thread類方法

方法 說明
start() 啟動線程
setName(String name) 設置線程名稱
setPriority(int priority) 設置線程優先級，默認5，取值1-10
join(long millisec) 掛起線程xx毫秒，參數可以不傳
interrupt() 終止線程
isAlive() 測試線程是否處於活動狀態

Thread靜態（static）方法

方法 說明
yield() 暫停當前正在執行的線程對象，並執行其他線程。
sleep(long millisec)/sleep(long millis, int nanos) 掛起線程xx秒，參數不可省略
currentThread() 返回對當前正在執行的線程對象的引用
holdsLock(Object x) 當前線程是否擁有鎖

2.3 sleep()和wait()的區別

sleep為線程的方法，而wait為Object的方法，他們的功能相似，最大本質的區別是：sleep不釋放鎖，wait釋放鎖。

用法上的不同：sleep(milliseconds)可以用時間指定來使他自動醒過來，如果時間不到你只能調用interreput()來終止線程；wait()可以用notify()/notifyAll()直接喚起。

重點： 測試wait和sleep釋放鎖的代碼如下：

public class SynchronizedTest extends Thread {
    int number = 10;
    public synchronized void first(){
        System.out.println("this is first!");
        number = number+1;
    }
    public synchronized void secord() throws InterruptedException {
        System.out.println("this is secord!!");
        Thread.sleep(1000);
//        this.wait(1000);
        number = number*100;
    }
    @Override
    public void run() {
        first();
    }
}
SynchronizedTest synchronizedTest = new SynchronizedTest();
synchronizedTest.start();
synchronizedTest.secord();
// 主線程稍等10毫秒
Thread.sleep(10);
System.out.println(synchronizedTest.number);

根據結果可以得知：

  • 執行sleep(1000)運行的結果是：1001
  • 執行wait(1000)運行的結果是：1100

總結： 使用 sleep(1000)不釋放同步鎖，執行的是10*100+1=1001，wait(1000)釋放了鎖，執行的順序是(10+1)x100=1100，所以sleep不釋放鎖，wait釋放鎖。

三、線程狀態

3.1 線程狀態概覽

線程狀態：

  • NEW 尚未啟動
  • RUNNABLE 正在執行中
  • BLOCKED 阻塞的（被同步鎖或者IO鎖阻塞）
  • WAITING 永久等待狀態
  • TIMED_WAITING 等待指定的時間重新被喚醒的狀態
  • TERMINATED 執行完成

線程的狀態可以使用getState()查看，更多狀態詳情，查看Thread源碼，如下圖：

技術分享圖片

3.2 線程的狀態代碼實現

3.2.1 NEW 尚未啟動狀態

Thread thread = new Thread() {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
};
// 只聲明不調用start()方法，得到的狀態是NEW
System.out.println(thread.getState()); // NEW

3.2.2 RUNNABLE 運行狀態

Thread thread = new Thread() {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
};
thread.start();
System.out.println(thread.getState()); // RUNNABLE

3.2.3 BLOCKED 阻塞狀態

使用synchronized同步阻塞實現，代碼如下：

public class MyCounter {
    int counter;
    public synchronized void increase()  {
        counter++;
        try {
            Thread.sleep(10*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
MyCounter myCounter = new MyCounter();
// 線程1調用同步線程，模擬阻塞
new Thread(()-> myCounter.increase()).start();
// 線程2繼續調用同步阻塞方法
Thread thread = new Thread(()-> myCounter.increase());
thread.start();

// 讓主線程等10毫秒
Thread.currentThread().sleep(10);
// 打印線程2，為阻塞狀態：BLOCKED
System.out.println(thread.getState());

3.2.4 WAITING 永久等待狀態

public class MyThread extends Thread{
    @Override
    public void run() {
        synchronized (MyThread.class){
            try {
                MyThread.class.wait();
                System.out.println(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
Thread thread = new Thread(new MyThread());
thread.start();
// 主線程掛起200毫秒，等thread執行完成
Thread.sleep(200);
// 輸出WAITING，線程thread一直處於被掛起狀態
System.out.println(thread.getState());

喚醒線程： 可使用 notify/notifyAll 方法，代碼如下：

synchronized (MyThread.class) {
    MyThread.class.notify();
}

使線程WAITING的方法：

  • Object的wait() 不設置超時時間
  • Thread.join()不設置超時時間
  • LockSupport的park()

查看Thread源碼可以知道Thread的join方法，底層使用的是Object的wait實現的，如下圖：

技術分享圖片

註意： 查看Object的源碼可知wait()，不傳遞參數，等同於wait(0)，設置的“0”不是立即執行，而是無限的等待，不執行，如下圖：

技術分享圖片

3.2.5 TIMED_WAITING 超時等待狀態

TIMED_WAITING狀態，只需要給wait設置上時間即可，代碼如下：

public class MyThread extends Thread{
    @Override
    public void run() {
        synchronized (MyThread.class){
            try {
                MyThread.class.wait(1000);
                System.out.println(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

調用代碼還是一樣的，如下：

Thread thread = new Thread(new MyThread());
thread.start();
// 主線程掛起200毫秒，等thread執行完成
Thread.sleep(200);
// 輸出TIMED_WAITING
System.out.println(thread.getState());
synchronized (MyThread.class) {
    MyThread.class.notify();
}

3.2.6 TERMINATED 完成狀態

Thread thread = new Thread(()-> System.out.println(Thread.currentThread().getName()));
thread.start();
// 讓主線程等10毫秒
Thread.currentThread().sleep(10);
System.out.println(thread.getState());

四、死鎖

根據前面的知識，我們知道使用sleep的時候是不釋放鎖的，所以利用這個特性我們可以很輕易的寫出死鎖的代碼，具體的流程如圖（圖片來源於楊曉峰老師文章）：

技術分享圖片

代碼如下：

static  Object object1 = new Object();
static  Object object2 = new Object();

public static void main(String[] args) {

    Thread thread = new Thread(){
        @Override
        public void run() {
            synchronized (object1){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (object2){
                    System.out.println(Thread.currentThread().getName());
                }
            }
        }
    };

    Thread thread2 = new Thread(){
        @Override
        public void run() {
            synchronized (object2){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (object1){
                    System.out.println(Thread.currentThread().getName());
                }
            }
        }
    };

    thread.start();
    thread2.start();

運行上面的代碼，程序會處於無限等待之中。

五、總結

根據上面的內容，我們已經系統的學習Thread的使用了，然而學而不思則罔，最後留一個思考題：根據本文介紹的知識，怎麽能避免死鎖？（哈哈，賣個關子，根據文章的知識點組合可以得出答案）

×××：https://github.com/vipstone/java-core-example.git

推薦部分

本人最近看了前Oracle首席工程師楊曉峰的課程，也是第四部分引用的流程圖的主人，感覺很不錯，推薦給你，一起來系統的學習Java核心吧。

技術分享圖片

參考文檔

https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.State.html

Java並發編程（一）Thread詳解

相關推薦

Java並發編程（一）Thread詳解

能夠 lds readn 暫停 正在執行 思考 基本 進程 -c 一、概述 在開始學習Thread之前，我們先來了解一下 線程和進程之間的關系： 線程(Thread)是進程的一個實體，是CPU調度和分派的基本單位。 線程不能夠獨立執行，必須依存在應用程序中，由應用程序提供

Java並發編程（一）

implement 返回 tile 對象 not seconds dex note 系統調用 1、定義

Java並發編程（一）-為什麽要並發

是否 退出 line 但是 英雄聯盟 編程 ati 效果 執行順序 並發所帶來的好處 1. 並發在某些情況（並不是所有情況）下可以帶來性能上的提升 1） 提升對CPU的使用效率 　　提升多核CPU的利用率：一般來說一臺主機上的會有多個CPU核心，我們可以創建多個線程，理論上

java並發編程（8）原子變量和非阻塞的同步機制

turn 判斷 變量 ntp 機制 tail values 添加 get 原子變量和非阻塞的同步機制 一、鎖的劣勢 　　1.在多線程下：鎖的掛起和恢復等過程存在著很大的開銷（及時現代的jvm會判斷何時使用掛起，何時自旋等待） 　　2.volatile：輕量級別的同步機制，

Java 並發編程（二）對象的不變性和安全的公布對象

不一致 字段 更新 要求 nts ava 然而 caching mut 一、不變性 滿足同步需求的還有一種方法是使用不可變對象（Immutable Object）。到眼下為止，我們介紹了很多與原子性和可見性相關的問題，比如得到失效數據。丟失更新操作

Java並發編程（三）概念介紹

ava cnblogs 內置 並且 變化 red sha 周期 圖片 在構建穩健的並發程序時，必須正確使用線程和鎖。但是這終歸只是一些機制。要編寫線程安全的代碼，其核心在於要對狀態訪問操作進行管理，特別是對共享的（Shared）和可變的（Mutable）狀態的訪問。 對象的

Go語言並發編程（一）

另一個 spa 輪換 main c語言 nbsp 成了 自動 返回 　Go語言的特色不得不提的就是並發機制，在C語言中編寫非常繁瑣復雜的並發程序在Go語言中可以非常便捷。 　　這幾天寫並發測試腳本的時候，結合代碼和其他大牛的文章學習了一下。把自己的理解寫下來。如有錯誤，請指

Java並發編程（八）線程間協作（上）

lse 依賴關系 文章 sign finally style new 關系 service 多線程並發執行時，不同的線程執行的內容之間可能存在一些依賴關系，比如線程一執行a()方法和c()方法，線程二執行b()方法，方法a()必須在方法b()之前執行，而方法c()必須在方法

Java並發編程（十）死鎖

相同 左面 總結 read ++ 毫秒 共享 方法 IV 哲學家進餐問題 並發執行帶來的最棘手的問題莫過於死鎖了，死鎖問題中最經典的案例就是哲學家進餐問題：5個哲學家坐在一個桌子上，桌子上有5根筷子，每個哲學家的左手邊和右手邊各有一根筷子。示意圖如下： 哲學家進餐問題 並發

Java並發編程（二）-- 創建、運行線程

內部 ack rdquo 必須 獲得 call() pool start array Java線程 Java線程類也是一個object類,它的實例都繼承自java.lang.Thread或其子類。 Java可以用如下方式創建一個線程： Tread thread =

Java並發編程（四）-- Java內存模型

ron 展示 共享內存模型 article oid 示意圖 緩沖 訪問共享 解決 Java內存模型 前面講到了Java線程之間的通信采用的是共享內存模型，這裏提到的共享內存模型指的就是Java內存模型(簡稱JMM)，JMM決定一個線程對共享變量的寫入何時對另一個線程可見。

Java並發編程（5）- J.U.C之AQS及其相關組件詳解

cached 數字0 f11 一個 就會 interrupt 同步器 long 告訴 J.U.C之AQS-介紹 Java並發包（JUC）中提供了很多並發工具，這其中，很多我們耳熟能詳的並發工具，譬如ReentrangLock、Semaphore，而它們的實現都用到了一個共同

Java並發編程（6）- J.U.C組件拓展

實現 oss 減少 left 處理 start pty res 屬於 J.U.C-FutureTask 在Java中一般通過繼承Thread類或者實現Runnable接口這兩種方式來創建線程，但是這兩種方式都有個缺陷，就是不能在執行完成後獲取執行的結果，因此Java 1.5

Java並發編程（7）- 線程調度 - 線程池

car 並且執行 創建線程 atomic 介紹 狀態 edr 關閉 imp 線程池 平時有接觸過多線程開發的小夥伴們應該都或多或少都有了解、使用過線程池，而《阿裏巴巴 Java 手冊》裏也有一條規範： 由此可見線程池的重要性，線程池對於限制應用程序中同一時刻運行的線程數很有

Java並發編程（8）- 應用限流及其常見算法

grant 服務器 timeunit 基於 cond str 通過 拼接 inter 應用限流 在開發高並發系統時，有三把利器用來保護系統：緩存、降級和限流： 緩存：緩存的目的是提升系統訪問速度和增大系統處理容量 降級：降級是當服務出現問題或者影響到核心流程時，需要暫時屏

Java並發編程（8）- 應用限流大發×××北京PK10×××及其常見算法

ret ole 次數 ++ 影響 interval 最大 計數器 設定 應用限流大發×××北京PK10×××Q--2947702644在開發高並發系統時，有三把利器用來保護系統：緩存、降級和限流： 緩存：緩存的目的是提升系統訪問速度和增大系統處理容量降級：降級是當服務出現問

Java並發編程（1）：可重入內置鎖

自己 如果 監視器 退出 進一步 自動 其他 實例 () 每個Java對象都可以用做一個實現同步的鎖，這些鎖被稱為內置鎖或監視器鎖。線程在進入同步代碼塊之前會自動獲取鎖，並且在退出同步代碼塊時會自動釋放鎖。獲得內置鎖的唯一途徑就是進入由這個鎖保護的同步代碼塊或方法。 當某個

Java並發編程（4）：守護線程與線程阻塞的四種情況

編寫程序 後臺 用戶線程 如果 指定 情況 運行 java並發編程 reads 守護線程Java中有兩類線程：User Thread(用戶線程)、Daemon Thread(守護線程) 用戶線程即運行在前臺的線程，而守護線程是運行在後臺的線程。 守護線程作用是為其他前臺線程

Java並發編程（6）:Runnable和Thread實現多線程的區別(含代碼)

線程休眠 ket out dde 可能 休眠 stat for oid Java中實現多線程有兩種方法：繼承Thread類、實現Runnable接口，在程序開發中只要是多線程，肯定永遠以實現Runnable接口為主，因為實現Runnable接口相比繼承Thread類有如下優

Java並發編程（7）：使用synchronized獲取互斥鎖的幾點說明

防止 ron 互斥鎖 成員變量 線程 繼續 enter 交換 規範 在並發編程中，多線程同時並發訪問的資源叫做臨界資源，當多個線程同時訪問對象並要求操作相同資源時，分割了原子操作就有可能出現數據的不一致或數據不完整的情況，為避免這種情況的發生，我們會采取同步機制，以確保在某