Java多線程Thread類的使用及註意事項

Posted on 2022-06-20 by WalkonNet

Thread類的基本用法

創建子類，繼承自Thread並且重寫run方法：

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("hello thread");
    }
}
public class Demo1 {
    public static void main(String[] args) {
        // 最基本的創建線程的辦法.
        Thread t = new MyThread();
        //調用瞭start方法才是真正的在系統中創建瞭線程，執行run方法
        t.start();
    }
}

創建一個類，實現Runnable接口再創建Runnable是實例傳給Thread

class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("hello");
    }
}
public class Demo3 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
    }
}

匿名內部類:

創建瞭一個匿名內部類，繼承自Thread類，同時重寫run方法，再new出匿名內部類的實例

public class Demo4 {
    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println("hello");
            }
        };
        t.start();
    }
}

new的Runnable，針對這個創建的匿名內部類，同時new出的Runnable實例傳給Thread的構造方法

public class Demo5 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        });
        t.start();
    }
}

lambda表達式 lambda代替Runnable

public class Demo6 {
    public static void main(String[] args) {
        Thread t = new Thread(() ->{
            System.out.println("hello");
        });
        t.start();
    }
}

線程指標

1.isDaemon();是否後臺線程後臺線程不影響進程退出，不是後臺線程會影響進程退出
2.isAlive();是否存活在調用start前系統中是沒有對應線程的，run方法執行完後線程就銷毀瞭，t對象可能還存在
3.isinterrupted();是否被中斷

run和start的區別:run單純的隻是一個普通方法描述瞭任務的內容 start則是一個特殊的方法，內部會在系統中創建線程

中斷線程

線程停下來的關鍵是要讓對應run方法執行完，對於main線程來說main方法執行完瞭才會終止

1.手動設置標志位

在線程中控制這個標志位就能影響到這個線程結束，但是此處多個線程共用一片虛擬空間，因此main線程修改的isQuit和t線程判斷的isQuit是同一個值

public class Demo10 {
    // 通過這個變量來控制線程是否結束.
    private static boolean isQuit = false;
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!isQuit) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();

        // 就可以在 main 線程中通過修改 isQuit 的值, 來影響到線程是否退出
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // main 線程在 5s 之後, 修改 isQuit 的狀態.
        isQuit = true;
    }
}

2.使用Thread中內置的一個標志位來判定

Thread.interruted()這是一個靜態方法 Thread.currentThread().isInterrupted()這是一個實例方法，其中currentThread能夠獲取到當前線程的實例

public class Demo7 {
    public static void main(String[] args)  {
        Thread t = new Thread(() -> {
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("hello");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    // 當觸發異常之後, 立即就退出循環~
                    System.out.println("這是收尾工作");
                    break;
                }
            }
        });
        t.start();
        try{
            Thread.sleep(5000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        // 在主線程中, 調用 interrupt 方法, 來中斷這個線程.
        // t.interrupt 的意思就是讓 t 線程被中斷!!
        t.interrupt();
    }
}

需要註意的是調用這個方法t.interrupt()可能會產生兩種情況：

1）如果t線程處在就緒就設置線程的標志位為true
2）如果t線程處在阻塞狀態(sleep)，就會觸發一個InterruptExeception

線程等待

多個線程之間調度順序是不確定的，有時候我們需要控制線程之間的順序，線程等待就是一種控制線程執行順序的手段，此處的線程等待隻要是控制線程結束的先後順序。
哪個線程中的join，哪個線程就會阻塞等待直到對應的線程執行完畢為止。

t.join();調用這個方法的線程是main線程，針對t這個對象調用的此時就是讓main等待t。代碼執行到join這一行就停下瞭，讓t先結束然後main繼續。
t.join(10000);join提供瞭另一個版本為帶一個參數的，參數為等待時間10s之後join直接返回不再等待

Thread.currentThread()

能夠獲取當前線程的應用，哪個線程調用的currentThread就獲取到哪個線程的實例對比this如下：

對於這個代碼來說，通過繼承Thread的方法來創建線程。此時run方法中直接通過this拿到的就是當前Thread的實例

public class Demo4 {
    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
                System.out.println(this.getName());
            }
        };
        t.start();
    }
}

然而此處this不是指向Thread類型，而是指向Runnable，Runnable隻是一個單純的任務沒有name屬性，要想拿到線程名字隻能通過Thread.currentThread()

public class Demo5 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                //err
                //System.out.println(this.getName());
                //right
                System.out.println(Thread.currentThread().getName());
            }
        });
        t.start();
    }
}

進程狀態

針對系統層面：

就緒
阻塞

java中Thread類進一步細化：

NEW：把Thread對象創建好瞭但是還沒有調用start
TERMINATED:操作系統中的線程已執行完畢銷毀，但是Thread對象還在獲取到的狀態
RUNNABLE：就緒狀態，處在該狀態的線程就是在就緒隊列中，隨時可以調度到CPU上
TIME_WAITING:調用瞭sleep就會進入到該狀態，join(超時時間) BLOCKED:當前線程在等待鎖導致瞭阻塞
WAITING:當前線程在等待喚醒

狀態轉換圖：

線程安全問題

定義：操作系統中線程調度是隨機的，導致程序的執行可能會出現一些bug。如果因為調度隨機性引入瞭bug線程就是不安全的，反之則是安全的。
解決方法：加鎖，給方法直接加上synchronized關鍵字，此時進入方法就會自動加鎖，離開方法就會自動解鎖。當一個線程加鎖成功的時候，其他線程嘗試加鎖就會觸發阻塞等待，阻塞會一直持續到占用鎖的線程把鎖釋放為止。

synchronized public void increase() {
        count++;
}

線程不安全產生的原因：

1.線程是搶占式執行，線程間的調度充滿隨機性。
2.多個線程對同一個變量進行修改操作
3.針對變量的操作不是原子的
4.內存可見性也會影響線程安全（針對同一個變量t1線程循環進行多次讀操作，t2線程少次修改操作，t1就不會從內存讀數據瞭而是從寄存器裡讀）
5.指令重排序，也是編譯器優化的一種操作，保證邏輯不變的情況下調整順序，解決方法synchronized。

內存可見性解決方法：

1.使用synchronized關鍵字使用synchronized不光能保證指令的原子性，同時也能保證內存的可見性。被synchronized包裹起來的代碼編譯器就不會從寄存器裡讀。
2.使用volatile關鍵字能夠保證內存可見性，禁止編譯器作出上述優化，編譯器每次執行判定相等都會重新從內存讀取。

synchronized用法

在java中每個類都是繼承自Object，每個new出來的實例裡面一方面包含自己安排的屬性，另一方面包含瞭“對象頭”即對象的一些元數據。加鎖操作就是在這個對象頭裡面設置一個標志位。

1.直接修飾普通的方法

使用synchronized的時候本質上是對某個“對象”進行加鎖，此時的鎖對象就是this。加鎖操作就是在設置this的對象頭的標志位，當兩個線程同時嘗試對同一個對象加鎖的時候才有競爭，如果是兩個線程在針對兩個不同對象加鎖就沒有競爭。

class Counter{
	public int count;
	synchronized public void increase(){
	count++;
	}
}

2.修飾一個代碼塊

需要顯示制定針對那個對象加鎖（java中的任意對象都可以作為鎖對象）

public void increase(){
    synchronized(this){
    count++;
    }
}

3.修飾一個靜態方法

相當於針對當前類的類對象加鎖,類對象就是運行程序的時候。class文件被加載到JVM內存中的模樣。

synchronized public static void func(){
}

或者

public static void func(){
    synchronized(Counter.class){

    }
}

監視器鎖monitor lock

可重入鎖就是同一個線程針對同一個鎖，連續加鎖兩次，如果出現死鎖就是不可重入鎖，如果不會死鎖就是可重入的。因此就把synchronized實現為可重入鎖，下面的例子裡啊連續加鎖操作不會導致死鎖。可重入鎖內部會記錄所被哪個線程占用也會記錄加鎖次數，因此後續再加鎖就不是真的加鎖而是單純地把技術給自增。

synchronized public void increase(){
    synchronized(this){
        count++;
    }
}

死鎖的其他場景

1.一個線程一把鎖
2.兩個線程兩把鎖
3.N個線程M把鎖（哲學傢就餐問題，解決方法：先拿編號小的筷子）

死鎖的四個必要條件（前三個都是鎖本身的特點）

1.互斥使用，一個鎖被另一個線程占用後其他線程就用不瞭（鎖的本質，保證原子性）
2.不可搶占，一個鎖被一個線程占用後其他線程不可把這個鎖給挖走
3.請求和保持，當一個線程占據瞭多把鎖之後，除非顯示的釋放否則這些鎖中都是該線程持有的
4.環路等待，等待關系成環（解決：遵循固定的順序加鎖就不會出現環路等待）

java線程類：

不安全的：ArrayList，LinkedList，HashMap，TreeMap，HashSet，TreeSet，StringBuilder
安全的：Vector，HashTable，ConcurrentHashMap，StringBuffer，String

volatile

禁止編譯器優化保證內存可見性，產生原因：計算機想執行一些計算就需要把內存的數據讀到CPU寄存器中，然後再從寄存器中計算寫回到內存中，因為CPU訪問寄存器的速度比訪問內存快很多，當CPU連續多次訪問內存結果都一樣，CPU就會選擇訪問寄存器。

JMM（Java Memory Model）Java內存模型

就是把硬件結構在java中用專業的術語又重新抽象封裝瞭一遍。

工作內存（work memory）其實指的不是內存，而是CPU寄存器。
主內存（main memeory）這才是主內存。
原因：java作為一個跨平臺編程語言要把硬件細節封裝起來，假設某個計算機沒有CPU或者內存同樣可以套到上述模型中。

寄存器，緩存和內存之間的關系

CPU從內存取數據太慢，因此把數據直接放到寄存器裡來讀，但寄存器空間太緊張於是又搞瞭一個存儲空間，比寄存器大比內存小速度比寄存器慢比內存快稱為緩存。寄存器和緩存統稱為工作內存。

寄存器，緩存和內存之間的關系圖

存儲空間：CPU<L1<L2<L3<內存
速度：CPU>L1>L2>L3>內存
成本：CPU>L1>L2>L3>內存

volatile和synchronized的區別

volatile隻是保證可見性不保證原子性，隻是處理一個線程讀和一個線程寫的過程。
synchronized都能處理

wait和notify

等待和通知處理線程調度隨機性問題的，join也是一種控制順序的方式更傾向於控制線程結束。wait和notify都是Object對象的方法，調用wait方法的線程就會陷入阻塞，阻塞到有線程通過notify來通知。

public class Demo9 {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        System.out.println("wait前");
        object.wait();
        System.out.println("wait後");
    }
}

wait內部會做三件事;

1.先釋放鎖
2.等待其他線程的通知
3.收到通知後重新獲得鎖並繼續往下執行

因此想用wait/notify就得搭配synchronized

public class Demo9 {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        synchronized (object){
            System.out.println("wait前");
            object.wait();
            System.out.println("wait後");
        }
    }
}

註意：wait notify都是針對同一對象來操作的，例如現在有一個對象o，有10個線程都調用瞭o.wait，此時10個線程都是阻塞狀態。如果調用瞭o.notify就會把10個線程中的一個線程喚醒。而notifyAll就會把所有10個線程全都給喚醒，此時就會競爭鎖。

到此這篇關於Java多線程Thread類的使用及註意事項的文章就介紹到這瞭,更多相關Java Thread 內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

Java多線程Thread類的使用及註意事項

目錄

Thread類的基本用法

線程指標

中斷線程

1.手動設置標志位

2.使用Thread中內置的一個標志位來判定

線程等待

進程狀態

線程安全問題

synchronized用法

1.直接修飾普通的方法

2.修飾一個代碼塊

3.修飾一個靜態方法

監視器鎖monitor lock

死鎖的其他場景

volatile

推薦閱讀：

發佈留言取消回覆

近期文章

目錄

Thread類的基本用法

線程指標

中斷線程

1.手動設置標志位

2.使用Thread中內置的一個標志位來判定

線程等待

進程狀態

線程安全問題

synchronized用法

1.直接修飾普通的方法

2.修飾一個代碼塊

3.修飾一個靜態方法

監視器鎖monitor lock

死鎖的其他場景

volatile

推薦閱讀：

發佈留言 取消回覆

近期文章

標籤

發佈留言取消回覆