2. 程式人生 > >深入理解Java多執行緒（一）

深入理解Java多執行緒（一）

阿新 • • 發佈：2018-11-28

關於java多執行緒的概念以及基本用法：java多執行緒基礎

1，停止執行緒

停止執行緒意味著線上程執行完之前停止正在做的操作，即立刻放棄當前的操作，這並不容易。停止執行緒可以用Thread.stop()方法，但是這個方法不安全，所以不建議使用，還有一個方法就是Thread.interrupt()方法，但是這個方法不會終止一個正在執行的執行緒，需要新增一個判斷才可以完成執行緒的停止

1.1，停不下來的執行緒

  • public void interrupt()
    將呼叫者執行緒的中斷狀態設為true

Thread.interrupt()方法只是在當前執行緒中打了一個停止的標記，並不是直接將執行緒停止

class MyThread_1 extends Thread{

    @Override
    public void run() {
        super.run();
        for(int i=0;i<10000;i++) {
            System.out.println("i="+(i+1));
        }
    }

}

public class Demo1_7_1 {
    public static void main(String[] args) {
        try {
            MyThread_1 thread = new
 
  MyThread_1();
            thread.start();
            Thread.sleep(200);
            thread.interrupt();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

結果：
這裡寫圖片描述
從結果可以看到，使用thread.interrupt()執行緒並未停止

1.2，判斷執行緒是否是停止狀態

  • public static boolean interrupted
    只能通過Thread.interrupted()呼叫
class MyThread_2 extends Thread{
    @Override
    public void run() {
        super.run();
        for(int i=0;i<10000;i++) {
            System.out.println("i="+(i+1));
        }
    }
}

public class Demo1_7_2 {
    public static void main(String[] args) {
        try {
            MyThread_2 thread = new  MyThread_2();
            thread.start();
            Thread.sleep(2000);
            thread.interrupt();
            System.out.println("是否停止1？="+thread.interrupted());
            System.out.println("是否停止2？="+thread.interrupted());
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("end");
    }
}

執行結果：
這裡寫圖片描述
當前執行緒是main並沒有中斷過，所以列印結果都是false

將main函式程式碼改為

        Thread.currentThread().interrupt();
        System.out.println("是否停止1？="+Thread.interrupted());
        System.out.println("是否停止2？="+Thread.interrupted());
        System.out.println("end");

結果為

是否停止1？=true
是否停止2？=false
end

為什麼第二個值是false?這是因為第一次呼叫Thread.interrupted()返回當前執行緒中斷狀態，然後會將執行緒的中斷狀態設為false

  • public boolean isInterrupted()
    判斷呼叫者執行緒的中斷狀態

講main函式修改

        try {
        MyThread_2 thread = new  MyThread_2();
        thread.start();
        Thread.sleep(2000);
        thread.interrupt();
        System.out.println("是否停止1？="+thread.isInterrupted());
        System.out.println("是否停止2？="+thread.isInterrupted());
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("end");

執行結果是：

。。。
。。。。
i=9997
i=9998
i=9999
i=10000
是否停止1？=false
是否停止2？=false
end

很神奇這裡返回結果都是false，想了半天，後來在網上查了資料明白是sleep函式的原因Thread.sleep(2000);休眠的是主執行緒，這裡休眠的就是main函式，在這段時間裡thread可能已經執行完了，所以thread.interrupt();也就起不到作用了，修改sleep函式時間，返回結果就都是true了

此方法作用：測試執行緒是否已經是中斷狀態，但是不會執行一次後將中斷狀態設定為false

1.3，停止執行緒–異常法

使用if語句判斷執行緒是否是停止狀態來控制後面的程式碼是否繼續執行，但是無論是否停止執行緒，for迴圈外run方法裡的程式碼都會執行，這裡用throw new InterruptedException();來產生異常，從而結束執行緒，執行緒其餘程式碼也不會執行了

class MyThread_3 extends Thread{

    @Override
    public void run() {
        super.run();
        try {
        for(int i=0;i<500000;i++) {
            if(this.isInterrupted()) {
            System.out.println("已經是停止狀態了，我要退出");
            throw new InterruptedException();

            }
            System.out.println("i="+(i+1));
        }
        System.out.println("for下面");
        }catch(InterruptedException e) {
            System.out.println("進Mythread類run方法中的catch");
            e.printStackTrace();
        }

    }
}

public class Demo1_7_3 {
    public static void main(String[] args) {
        try {
            MyThread_3 thread = new MyThread_3();
            thread.start();
            Thread.sleep(2000);
            thread.interrupt();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("end");
    }
}

結果：

。。。。
。。。。。
i=366068
i=366069
i=366070
end
已經是停止狀態了，我要退出
進Mythread類run方法中的catch
java.lang.InterruptedException
    at chapter_1.MyThread_3.run(Demo1_7_3.java:12)

1.4，停止執行緒–在Sleep狀態

在sleep狀態下停止某一執行緒會進入catch語句，並且清除停止狀態值，使之變成false

class MyThread_4 extends Thread{

    @Override
    public void run() {
        super.run();
        try {
            System.out.println("run begin");
            Thread.sleep(200000);
            System.out.println("run end");
        } catch (Exception e) {
            // TODO: handle exception
            System.out.println("在沉睡中被停止進入catch"+this.isInterrupted());
            e.printStackTrace();
        }
    }
}

public class Demo1_7_4 {
    public static void main(String[] args) {
        try {
            MyThread_4 thread = new MyThread_4();
            thread.start();
            Thread.sleep(200);
            thread.interrupt();
        } catch (Exception e) {
            // TODO: handle exception
            System.out.println("main catch");
            e.printStackTrace();
        }
        System.out.println("end");
    }

}

結果：

run begin
end
在沉睡中被停止進入catchfalse
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at chapter_1.MyThread_4.run(Demo1_7_4.java:10)

1.5，停止執行緒–暴力停止

所謂暴力停止就是最直接的方法了–stop(),這種方法直接讓執行緒停止，但是這也會引來一些問題，比如執行緒的安全問題，不建議使用

1.6，停止執行緒–使用return

將方法interrupt()與return結合使用也可以實現停止執行緒

class MyThread_8 extends Thread{

    @Override
    public void run() {
        super.run();
        while(true) {
            if(this.isInterrupted()) {
                System.out.println("停止了！");
                return;
            }
            System.out.println("timer="+System.currentTimeMillis());
        }
    }
}

public class Demo1_7_8 {
    public static void main(String[] args) throws InterruptedException{
        MyThread_8 t = new MyThread_8();
        t.start();
        Thread.sleep(2000);
        t.interrupt();
    }
}

結果：

。。。
。。。
timer=1533907137644
timer=1533907137644
timer=1533907137644
timer=1533907137644
timer=1533907137644
timer=1533907137644
停止了！

1.7，yield方法

yield()方法作用是放棄當前CPU資源，讓給其他執行緒去使用，但是放棄時間不確定

1.8，執行緒優先順序

作業系統會對執行緒進行劃分優先順序，優先順序高的執行緒會優先分配到資源，類似於現實中的VIP，Java將執行緒從1到10劃分十個等級，預設優先順序為NORM_PRIORITY，設定優先順序用setPriority()
setPriority()原始碼：

    public final void setPriority(int i)
    {
        checkAccess();
        if(i > 10 || i < 1)
            throw new IllegalArgumentException();
        ThreadGroup threadgroup;
        if((threadgroup = getThreadGroup()) != null)
        {
            if(i > threadgroup.getMaxPriority())
                i = threadgroup.getMaxPriority();
            setPriority0(priority = i);
        }
    }
  • public final static int MIN_PRIORITY=1;
  • public final static int NORM_PRIORITY=5;
  • public final static int MAX_PRIORITY=10;

此外執行緒還具有繼承性，若執行緒A啟動執行緒B，則B具有A的優先順序

1.9，守護執行緒

在Java執行緒中有兩種執行緒，一種是使用者執行緒一種是守護執行緒，我們常說的作業系統中並沒有守護執行緒這一說，原因是Java是構建在JVM之上的。顧名思義，守護執行緒具有陪伴的意思，當程序中不存在非守護執行緒時，守護執行緒就會自動銷燬。
Daemon作用是為了其他執行緒的執行提供便利服務，只有當最後一個非守護執行緒結束時，守護執行緒才會隨著JVM一同結束工作，守護執行緒典型的例子就是GC

class MyThread_11 extends Thread{
    private int i=0;
    @Override
    public void run() {
        super.run();
        try {
            while(true) {
                i++;
                System.out.println("i="+(i));
                Thread.sleep(1000);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

public class Demo1_11 {

    public static void main(String[] args) {
        try {
            MyThread_11 thread = new MyThread_11();
            thread.setDaemon(true);
            thread.start();
            Thread.sleep(5000);
            System.out.println("守護執行緒離開了！");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

結果：

i=1
i=2
i=3
i=4
i=5
守護執行緒離開了！

2018.9.9補充：
突然對this與Thread.currentThread()產生了疑問，下面來對這個區別來介紹一下：
建立一個MyObject類：

public class MyThread extends Thread{

    public MyThread() {
    }

    @Override
    public void run() {

        System.out.println("Thread.currentThread.getName= "
        +Thread.currentThread().getName());
        System.out.println("this.getName= "+this.getName());
    }

}

測試類：

public class Run {

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread t = new Thread(myThread);
        t.start();
    }
}

結果：

Thread.currentThread.getName= Thread-1
this.getName= Thread-0

顯然這裡this和Thread.currentThread()指向的不是同一個執行緒，看一下Thread原始碼：
這裡寫圖片描述

Thread t = new Thread(myThread)這句傳入的物件MyThread就是原始碼裡的target物件，Thread類的構造方法會給執行緒一個預設的名字，從”Thread-0”開始
this.getName()其實就是target.getName()，返回的是執行MyThread myThread = new MyThread()的執行緒名，而Thread.currentThread().getName()返回的是t.getName()，返回的是Thread t = new Thread(myThread)這句建立的執行緒

相關推薦

深入理解Java多執行緒（一）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 1，停止執行緒 停止執行緒意味著線上程執行完之前停止正在做的操作，即立刻放棄當前的操作，這並不容易。停止執行緒可以用Thread.stop()方法，但是這個方法不安全，所以不建議使用，還有一個方法就是Thre

深入理解java多執行緒（六）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 6，單例模式與多執行緒 如何使單例模式遇到多執行緒是安全的這是下面要討論的內容 6.1，立即載入 立即載入就是在使用類的時候已經將物件建立完畢，例如String s = new Stri

深入理解Java多執行緒（五）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 5，定時器Timer JDK中Timer類主要是負責計劃任務的功能，也就是在指定的時間開始執行某一個任務，封裝任務的類是TimerTask類，執行計劃任務的程式碼要放進TimerTask的子類，因為它一個抽象

深入理解Java多執行緒（四）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 4，Lock的使用 ReentrantLook類的使用 ReentrantReadWriteLock類的使用 4.1，ReentrantLook類的使用 新建MySe

深入理解Java多執行緒（三）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 3, 執行緒間通訊 執行緒在作業系統中是獨立的個體，經過特殊的處理，執行緒間可以實現通訊，進而成為一個整體，提高CPU利用率 3.1，等待/通知機制 等待：wait()方法作用是使當前執

深入理解Java多執行緒（二）

關於java多執行緒的概念以及基本用法：java多執行緒基礎 2，多執行緒的同步 多個執行緒對同一物件的變數進行同時訪問時會引發執行緒的安全問題，即一個執行緒對一個變數修改後，其他執行緒可能會讀取到修改後的變數值，所以我們要對獲得的例項變數的值進行同步處理，保證其原子性

Java多執行緒（一）基礎

1.關於執行緒與程序的區別：執行緒指程序中的一個執行場景，也就是執行流程，同一個程序中的執行緒共享其程序中的記憶體和資源（共享的記憶體是堆記憶體和方法區記憶體，棧記憶體不共享，每個執行緒有自己的，一個執行緒一個棧。）；每個程序是一個應用程式，都有獨立的記憶體空間。多執行緒的使用是為了提高程式

Java 多執行緒（一）—— 概念的引入

　　併發和並行 　　 　　程序和執行緒 　　 　　如何建立多執行緒 　　 　　第一種方法：繼承 Thread 類 　　 　　第二種方法：實現 Runnable 介面 　　 　　第三種方法：使用匿名內部類建立執行緒 　　 　　正文 　　 　　回到頂部 　　 　　併發和並行 　　 　　並行：指兩個或多個

Java多執行緒（一） 什麼是執行緒

宣告：本系列大多是翻譯自https://www.javatpoint.com，加上自己的增刪改，盡力寫的系統而通俗易懂，後文不再重複宣告。 java的多執行緒是一個同時執行多個執行緒的過程。 執行緒是一個輕量級的子程序，是最小的處理單元。多執行緒和多程序都用於實現多工處理。 但是，我們使用多執

java多執行緒（一）:執行緒的五種基本狀態以及生命週期

1、Java執行緒具有五中基本狀態： 新建狀態（New）：當執行緒物件對建立後，即進入了新建狀態，如：Thread thread1 = new MyThread(); 就緒狀態（Runnable）：當呼叫執行緒物件的start()方法[ 如:thread1 .start(); ]，執行緒

結合生活，剖析《生產者消費者模型》-java多執行緒（一）

　　部落格園的園友們好，看部落格園上各位大佬的文章，已陪伴了我程式設計師職業的三年， 如今自己同樣希望能把自己從小白到菜鳥的成長過程分享給大家。不定期更新！！！ 首先我本人智商不高，理解問題十分吃力，完全不屬於天才的行列，因此學習每一個知識 都喜歡刨根問底，結合生活，徹徹底底理解知識的本質！ 進入正題，這篇文

Java多執行緒（一）：執行緒基礎及建立

（一）、執行緒的生命週期 新建狀態: 使用 new 關鍵字和 Thread 類或其子類建立一個執行緒物件後，該執行緒物件就處於新建狀態。它保持這個狀態直到程式 start() 這個執行緒。 就緒狀態: 當執行緒物件呼叫了start()方法之後，該執行緒就進入就緒

Java多執行緒（一） —— 執行緒的狀態詳解

一、多執行緒概述  1、 程序 是一個正在執行的程式。是程式在計算機上的一次執行活動。 每一個程序執行都有一個執行順序。該順序是一個執行路徑，或者叫一個控制單元。 系統以程序為基本單位進行系統資源的排程和分配。程式要執行，系統就在記憶體中為該程式分配一塊獨立的記憶體空間，載入程式程式碼和資源進行執行。 程式

Java進階 ——— Java多執行緒（一）之程序和執行緒

引言 講到執行緒，不可避免的提到程序。而因為執行緒無法脫離程序單獨存在，那什麼是程序？ 延伸閱讀,Java多執行緒系列文章 什麼是程序？ 程序：具有一定獨立功能的程式關於某個資料集合上的一次執行活動,程序是系統進行資源分配和排程的最小單位。 例如手機執行的眾多

java多執行緒（一）（LongAdder）

LongAdder是jdk8新增的用於併發環境的計數器，目的是為了在高併發情況下，代替AtomicLong/AtomicInt，成為一個用於高併發情況下的高效的通用計數器。 高併發下計數，一般最先想到的應該是AtomicLong/AtomicInt，AtmoicXXX使

Java多執行緒（一）——實現多執行緒的兩種方式

java實現多執行緒的常用方式有兩種：繼承Thread類、實現Runnable介面實現run方法。 繼承Thread實現方式： public class ThreadTest extends Thread{ private int tick

Java多執行緒（一）：執行緒與程序

1.執行緒和程序 1.1 程序 程序是作業系統的概念，我們執行的一個TIM.exe就是一個程序。 程序（Process）是計算機中的程式關於某資料集合上的一次執行活動，是系統進行資源分配和排程的基本單位，是作業系統結構的基礎。在早期面向程序設計的計算機結構中，程序是程式的基本執行實體；在當代面向執行緒設計

深入理解Java多執行緒--執行緒池（ThreadPool）

在java多執行緒開發中，我們需要使用執行緒的時候一般是建立一個Thread物件，然後呼叫start（）方法去執行執行緒操作。這樣做沒有什麼問題，但是如果我們有很多工需要多個執行緒來非同步執行的時候，在我們建立了很多執行緒的情況下，會造成很大的效能方面的問題。 1.大量的執行緒的建立和銷燬，

深入理解多執行緒（一）——Synchronized的實現原理

synchronized，是Java中用於解決併發情況下資料同步訪問的一個很重要的關鍵字。當我們想要保證一個共享資源在同一時間只會被一個執行緒訪問到時，我們可以在程式碼中使用synchronized關鍵字對類或者物件加鎖。那麼，本文來介紹一下synchronized關鍵字的實

深入理解系列之JAVA多執行緒（2）——synchronized同步原理

多執行緒中為了解決執行緒安全問題，一個重要的手段就是同步！所謂同步其實就是使得原本各個執行緒交叉執行（非同步），變成排隊執行（同步）。同步策略使得不同執行緒操作共享資料遵循“先來後到“，從而避免某個執行緒沒有處理完資料就被另一執行緒搶佔操作出現資料被覆蓋或