2. 程式人生 > >Java高併發程式設計：取消和關閉

Java高併發程式設計：取消和關閉

阿新 • • 發佈：2019-01-11

Java沒有提供任何機制來安全地終止執行緒，但是它提供了中斷(Interruption).這是一種協作機制，能夠使一個執行緒終止另一個執行緒當前的工作。

  • 在對一個執行緒物件呼叫Thread.interrupted()方法之後，一般情況下對這個執行緒不會產生任何影響。因為呼叫Thread.interrupted()方法只是將增執行緒的中斷標誌位設定為true。
  • 如果一個執行緒被呼叫Thread.interrupted()方法之後，如果它的狀態是阻塞狀態或者是等待狀態，而且這個狀態正是因為正在執行的wait、join、sleep執行緒造成的，那麼是會改變執行的結果（丟擲InterruptException異常）

1.執行緒終止

由於Java沒有提供任何機制來安全地終止執行緒,那麼我們應該如何終止執行緒呢？下面我們提供三種執行緒終止的方法：

  1. 使用退出標誌，使執行緒正常退出，也就是當run方法完成後執行緒終止。
  2. 使用stop方法強行終止執行緒（這個方法不推薦使用，因為stop和suspend、resume一樣，也可能發生不可預料的結果）。
  3. 使用interrupt方法中斷執行緒。

1.1 使用退出標誌

當run方法執行完後，執行緒就會退出。但有時run方法是永遠不會結束的。如在服務端程式中使用執行緒進行監聽客戶端請求，或是其他的需要迴圈處理的任務。在這種情況下，一般是將這些任務放在一個迴圈中，如while迴圈。如果想讓迴圈永遠執行下去，可以使用while（true）{……}來處理。但要想使while迴圈在某一特定條件下退出，最直接的方法就是設一個boolean型別的標誌，並通過設定這個標誌為true或false來控制while迴圈是否退出。

public class ThreadFlag implements Runnable{
    private volatile boolean exit=false;

    @Override
    public void run() {
        while (!exit){
            ///do something
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace
 
();
            }
        }
        System.out.println("-----------ThreadFlag shutdown----------");
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadFlag threadFlag=new ThreadFlag();
        Thread thread=new Thread(threadFlag);
        thread.start();
        Thread.sleep(3000);
        threadFlag.exit=true;
        thread.join();
        System.out.println("執行緒退出");
    }
}

上面程式碼使用了一個執行緒標誌位來判斷執行緒是否關閉.通過對執行緒標誌位進行操作來決定執行緒是否關閉.

1.2 使用stop方法終止執行緒

使用stop方法可以強行終止正在執行或掛起的執行緒。我們可以使用如下的程式碼來終止執行緒：

public class ThreadStop implements Runnable {
    @Override
    public void run() {
        try {
            while (true){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } finally {
            System.out.println("-----------ThreadStop shutdown----------");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadStop threadStop=new ThreadStop();
        Thread thread=new Thread(threadStop);
        thread.start();
        Thread.sleep(3000);
        thread.stop();
        System.out.println("執行緒退出");
    }
}

這種方法執行緒不安全，Java不建議使用這種stop方法關閉執行緒。

1.3 使用interrupt方法終止執行緒

使用interrupt方法來終端執行緒可分為兩種情況：

（1）執行緒處於阻塞狀態，如使用了sleep方法。

（2）使用while（！isInterrupted（））{……}來判斷執行緒是否被中斷。

enum  FuntuionType{
    FunctionType1,
    FunctionType2,
}
public class ThreadInterrupt implements Runnable{
    private FuntuionType funtuionType;

    public ThreadInterrupt(FuntuionType funtuionType) {
        this.funtuionType = funtuionType;
    }

    @Override
    public void run() {
        switch (funtuionType){
            case FunctionType1:
                int i = 0;
                while (!Thread.interrupted()){
                    //do something
                    i++;
                }
                System.out.println("Thread.interrupted() shutdown");
                break;
            case FunctionType2:
                try {
                    Thread.sleep(50*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Sleep InterruptedException throws");
                break;
            default:
                break;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadInterrupt threadInterrupt=new ThreadInterrupt(FuntuionType.FunctionType2);
        Thread thread=new Thread(threadInterrupt);
        thread.start();
        Thread.sleep(2000);
        thread.interrupt();
        System.out.println("執行緒已經退出");
    }
}

2. 任務取消

Java中沒有一種安全的搶佔式方法來停止執行緒，因此就沒有安全的搶佔式方法來停止任務。下面我們就來介紹一中協作式的方式來取消一個任務。

2.1 取消標誌位

第一種方式就是設定某個“已請求取消”的標誌位，而任務週期性的檢視這個標誌位。如果設定了這個標誌位，那麼任務就提前結束。

public class PrimeGenerator implements Runnable{
    private final List<BigInteger> primes=new ArrayList<>();
    private volatile boolean cancelled = false;
    private volatile BigInteger p = BigInteger.ONE;
    @Override
    public void run() {

        while (!cancelled){
            //此方法返回一個整數大於該BigInteger的素數。
            p = p.nextProbablePrime();
            synchronized (this) {
                primes.add(p);
            }
        }
    }

    public void cancel(){
        this.cancelled=true;
    }

    public synchronized List<BigInteger> get(){
        return new ArrayList<>(primes);
    }

    public static void main(String[] args) throws InterruptedException {
        PrimeGenerator primeGenerator=new PrimeGenerator();
        for (int i = 0; i < 10; i++) {
            Thread thread=new Thread(primeGenerator);
            thread.start();
        }

        Thread.sleep(2000);
        primeGenerator.cancel();
        for (BigInteger bigInteger : primeGenerator.get()) {
            System.out.println(bigInteger);
        }
    }
}

2.2 中斷 Interrupt

由於PrimeGenerator中的取消機制最終會使得素數的任務進行退出。但是如果使用這個方法中的任務呼叫了一個阻塞方法，列如BlockingQueue.put，那麼就會產生一個嚴重的問題————任務可能永遠不會檢查取消標誌。因此永遠不會結束。所以這個時候我們就採用中斷Interrupt來取消任務。

public class PrimeProducer implements Runnable {
    private final BlockingQueue<BigInteger> bigIntegers;
    private Thread thread;

    public void setThread(Thread thread) {
        this.thread = thread;
    }

    public PrimeProducer(BlockingQueue<BigInteger> bigIntegers) {
        this.bigIntegers = bigIntegers;
    }

    private volatile BigInteger p = BigInteger.ONE;

    @Override
    public void run() {
        try {
            while (!Thread.currentThread().isInterrupted()){
                p = p.nextProbablePrime();
                bigIntegers.put(p.nextProbablePrime());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void cancel(){
        thread.interrupt();
    }

    public BlockingQueue<BigInteger> getBigIntegers() {
        return bigIntegers;
    }

    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<BigInteger> bigIntegers=new LinkedBlockingQueue<>();
        PrimeProducer primeProducer=new PrimeProducer(bigIntegers);

        Thread thread=new Thread(primeProducer);
        primeProducer.setThread(thread);
        thread.start();
        
        Thread.sleep(1000);
        primeProducer.cancel();
        for (BigInteger bigInteger : primeProducer.getBigIntegers()) {
            System.out.println(bigInteger);
        }
    }
}

每個執行緒都有一個Boolean型別的中斷狀態。當中斷執行緒發生的時候，這個執行緒就把這個中斷狀態設定為true。咋Thread中包含了中斷執行緒以及查詢執行緒中斷狀態的方法。

Thrad中的中斷方法：

public class Thread{
    public void interrupt(){}
    public boolean isInterrupted(){}
    public static boolean interrupted(){}
}
  • interrupt()方法能夠中斷目標執行緒
  • isInterrupted方法能夠返回目標執行緒的中斷狀態
  • interrupted靜態方法能夠將清除當前執行緒的中斷狀態，並返回它之前的值，這也是清除中斷狀態的唯一方法

阻塞庫方法，比如Thread.sleep和Object.wait和Thread.join等，都會檢查執行緒何時中斷，並且在發生中斷時提前返回。他們在響應中斷時只需的操作包括：清除中斷狀態，丟擲InterruptExecption異常，表示阻塞操作由於中斷而提前結束。

當執行緒在非阻塞狀態下中斷時，它的中斷狀態將被設定為true，然後根據將取消的操作來檢查中斷狀態以判斷髮生了中斷。通過這樣的方法，中斷操作將變得有粘性————如果不觸發InterruptException，那麼中斷將一直保持，直到明確的清除中斷狀態。

總結：
對中斷的正確理解是：它並不會真正地中斷在一個正在執行的執行緒，而是發出中斷請求，然後由執行緒在下一個合適的時刻中斷自己。（這些合適的時刻稱為取消點）。有些方法，比如wait、slee和join等，將嚴格處理這種請求，當他們收到中斷請求或者開始執行發現某個已經被設定好的中斷狀態的時候，將丟擲一個異常。
中斷策略

最合理的中斷策略使某
種執行緒級（Thread-Level）取消操作或者服務級的取消操作：儘快退出，在必要時候進行清理，通知某個所有執行緒已經退出。當前檢查到中斷請求時候，任務不需要放棄所有的操作————它可以推遲處理中斷請求，並找到合適的時刻。因此需要記住中斷請求，並在完成當前任務之後丟擲InterruptExeception或者表示已經收到中斷請求。這項技術能夠確保在更新過程中發生中斷時，資料結構不會發生破壞。除了將InterruptException傳遞給呼叫者外還需要執行額外的操作，那麼應該在捕獲InterruptException之後恢復中斷狀態：

Thread.currentThread().interrupt();

響應中斷

當中斷異常發生的時候，我們有兩種方式進行響應中斷請求：

  • 傳遞異常（可能在執行某個特定於任務的清除操作之後）:從而使你的方法也可以是中斷的阻塞方法
  • 恢復中斷狀態：從而使呼叫佔中的上層程式碼能對其進行處理。如果不想處理中斷請求，一種標準的方法就是通過再次呼叫interrupt來恢復中斷狀態。你不能遮蔽中斷狀態，你只能恢復中斷狀態。

2.3 通過Future來實現取消

我們已經使用了一種抽象機制來管理任務的生命週期，處理異常，下面我們來介紹一種使用Future類來實現任務取消。

public class TimeRun {
    private static ExecutorService executorService= Executors.newFixedThreadPool(5);
    
    public static void timeRun(Runnable runnable, long timeout, TimeUnit timeUnit){
        Future<?> submit = executorService.submit(runnable);
        try {
            submit.get(timeout,timeUnit);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            //接下來任務將被取消
            e.printStackTrace();
        } finally {
            //如果任務已經結束，那麼執行取消操作也不會帶來任何影響
            //如果任務正在執行，那麼將會被中斷
            submit.cancel(true);
        }
    }
}

當Future.get丟擲InterruptException或者TimeoutException時，如果你知道不再需要結果，那麼就可以呼叫Future.cancel來取消任務。

2.4 處理不可中斷的阻塞

如果一個執行緒由於執行同步的Socket I/O 或者等待獲得內建鎖而阻塞，那麼中斷請求只能設定執行緒的中斷狀態，除此之外沒有其他任何作用。對於那些由於執行不可中斷操作而被阻塞的執行緒，可以使用類似於中斷的手段來停止這些執行緒。

public class ReaderThread extends Thread {
    private final Socket socket;
    private final InputStream inputStream;
    public static final int BUFSIZE=1024;
    
    public ReaderThread(Socket socket) throws IOException {
        this.socket = socket;
        this.inputStream=socket.getInputStream();
    }

    @Override
    public void interrupt() {
        try {
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            super.interrupt();
        }
    }

    @Override
    public void run() {
        byte [] buf=new byte[BUFSIZE];
        try {
            while (true) {
                int count= inputStream.read(buf);
                //dosomething
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

通過重寫Interrupt方法將非標準的取消操作封裝到Thread中，實現中斷功能

3. 停止執行緒的服務

正確的封裝原則是：除非擁有某個執行緒，否則不能對執行緒進行操作。比如，中斷執行緒，或者修改執行緒的優先順序等等。

服務應該提供生命週期方法（Lifecycle Method）來關閉它自己以及它所擁有的執行緒。這樣應用程式關閉服務的時候，服務就可以關閉所有執行緒了。對於持有執行緒的服務，只要服務的存在時間大於建立執行緒的方法的存在時間，就應該提供生命週期方法。

3.1 關閉ExecutorService

關閉ExecutorService提供了兩種關閉方法：shutdown和shutdownNow方法

強行關閉的速度更快，但是風險也更大，因為任務很可能執行到一半就結束
正常關閉的速度雖然慢，但是卻更為安全，因為ExecutorService會一直等到佇列中的所有任務都執行完成之後才關閉。

4. JVM關閉

JVM關閉應用程式可以分為兩種方式：

正常關閉：當最後一個“正常（非守護）”執行緒結束的時候，或者呼叫了System.exit(0)時，或者通過其他特定於平臺的方法關閉（比如發出了SIGNT訊號或者Ctrl-C）
強行關閉:通過呼叫Runtime.halt或者在作業系統中“殺死”JVM程序來強行關閉JVM

4.1 關閉鉤子

在正常關閉中，JVM首先呼叫以及註冊的關閉鉤子（shutdown Hook）。關閉鉤子是指通過Runntime.addShutdwonHook註冊的但是尚未開始的執行緒。JVM不能保證這些執行緒的執行順序。在關閉應用程式執行緒時，如果有執行緒正在執行，那麼這些執行緒接下來將於關閉程序併發執行。

public class JavaHook {
    private static class JavaTask implements Runnable{
        @Override
        public void run() {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("-----------JavaTask shutdown----------");
        }
    }

    public static void main(String[] args) {
        JavaTask javaTask=new JavaTask();
        Thread thread=new Thread(javaTask);
        thread.start();
        Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(4000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("-----------JavaHook finish----------");
            }
        }));
        System.out.println("JVM finsih....");
    }
}

關閉鉤子應該是執行緒安全的：他們在訪問共享資料的時候必須使用同步機制，並且小心的避免發生死鎖，這與其他併發程式碼的要求相同。而且關閉鉤子不應該對應用程式的狀態（比如其他服務是否已經關閉，後者所有的正常線是否已經執行完成）後者JVm的關閉原因作出任何假設。

5.總結

Java並沒有提供某種搶佔式的機制來取消或者終結執行緒。想法它提供一種協作式的中斷機制來實現取消操作，但是這要依賴於如何構建取消操作的協議，以及能否遵循這些協議。

相關推薦

Java高併發程式設計：取消和關閉

Java沒有提供任何機制來安全地終止執行緒，但是它提供了中斷(Interruption).這是一種協作機制，能夠使一個執行緒終止另一個執行緒當前的工作。 在對一個執行緒物件呼叫Thread.interrupted()方法之後，一般情況下對這個執行緒不會產生任何影響。因為

Java高併發程式設計：執行緒池

這裡首先介紹了java5中的併發的小工具包：java.util.concurrent.atomic，然後介紹了執行緒池的概念，對使用java5的方式建立不同形式的執行緒進行了演示，之後介紹了兩個 物件：Callable和Future，用於獲取執行緒執行後的結果，

Java高併發程式設計：Copy-On-Write容器

Copy-On-Write簡稱COW，是一種用於程式設計中的優化策略。其基本思路是，從一開始大家都在共享同一個內容，當某個人想要修改這個內容的時候，才會真正把內容Copy出去形成一個新的內容然後再改，這是一種延時懶惰策略。從JDK1.5開始Java併發包裡提供了兩個使用CopyOnWrite

Java高併發程式設計：活躍性危險

Java高併發程式中，不得不出現資源競爭以及一些其他嚴重的問題，比如死鎖、執行緒飢餓、響應性問題和活鎖問題。在安全性與活躍性之間通常存在依賴，我們使用加鎖機制來確保執行緒安全，但是如果過度地使用加鎖，則可能導致鎖順序死鎖（Lock-Ordering DeadLock）。 1.死鎖

Java高併發程式設計：使用JDK5中同步技術的3個面試題

第一題： 現有的程式程式碼模擬產生了16個日誌物件，並且需要執行16秒才能列印完這些日誌，請在程式中增加4個執行緒去呼叫parseLog()方法來分頭列印這16個日誌物件，程式只需要執行4秒即可列印完這些日誌物件。 public class Test {

Java高併發程式設計：同步工具類

內容摘要 這裡主要介紹了java5中執行緒鎖技術以外的其他同步工具，首先介紹Semaphore：一個計數訊號量。用於控制同時訪問資源的執行緒個數，CyclicBarrier同步輔助類：從字面意思看是路障，這裡用於執行緒之間的相互等待，到達某點後，繼續向下執行。

Java高併發程式設計：HandlerThread

1. HandlerThread的使用 繼承自Thread，在run()方法中，執行了Looper.prepare()和Looper.loop()，和handler結合使用，實現後臺輪詢執行緒功能 start() quit() getLooper()

Java高併發程式設計（八）：Java併發容器和框架

1. ConcurrentHashMap 1.1 ConcurrentHashMap的優勢 在併發程式設計中使用HashMap可能導致程式死迴圈。而使用執行緒安全的HashTable效率又非 常低下，基於以上兩個原因，便有了ConcurrentHashMap的登場機會。

Java高併發程式設計學習筆記（三）：Java記憶體模型和執行緒安全

文章目錄 原子性 有序性 可見性 – 編譯器優化 – 硬體優化(如寫吸收，批操作) Java虛擬機器層面的可見性 Happen-Before規則（先行發生） 程式順序原則: volat

高併發程式設計：執行緒安全和ThreadLocal

執行緒安全的概念：當多個執行緒訪問某一個類（物件或方法）時，這個類始終都能表現出正確的行為，那麼這個類（物件或方法）就是執行緒安全的。 執行緒安全 說的可能比較抽象，下面就以一個簡單的例子來看看什麼是執行緒安全問題。 public class MyThread impleme

Java 高併發程式設計詳解：多執行緒與架構設計

內容簡介 本書主要包含四個部分： 部分主要闡述 Thread 的基礎知識，詳細介紹執行緒的 API 使用、執行緒安全、執行緒間資料通訊，以及如何保護共享資源等內容，它是深入學習多執行緒內容的基礎。 第二部分引入了 ClassLoader，這是因為 ClassLoader 與執行緒不無關係

頂級架構師學習——第二階段：實戰Java高併發程式設計

1、什麼是並行？ 並行處理（ParallelProcessing）是計算機系統中能同時執行兩個或更多個處理機的一種計算方法。處理機可同時工作於同一程式的不同方面。並行處理的主要目的是節省大型和複雜問題的解決時間。 2、為什麼需要並行？ 平行計算只有在  影象處理  和 

16-Java併發程式設計：Timer和TimerTask（轉載）

Java併發程式設計：Timer和TimerTask（轉載） 　　下面內容轉載自： 　　其實就Timer來講就是一個排程器,而TimerTask呢只是一個實現了run方法的一個類,而具體的TimerTask需要由你自己來實現,例如這樣: Timer timer =

高併發程式設計：Volatile關鍵字和Atomic類

在接觸併發程式設計之前我對volatile關鍵字是沒有什麼映像的，這個關鍵字解決了什麼問題呢？讓我們先來看一個示例： public class UseVolatitle extends Thread { private boolean isrunning

Java併發程式設計：Timer和TimerTask（轉載）

public Timer(boolean isDaemon) { this("Timer-" + serialNumber(), isDaemon); }  　　另外兩個構造方法負責傳入名稱和將timer啟動： public Timer(String name, boo

《Java高併發程式設計》學習 --3.2 執行緒複用：執行緒池

1）什麼是執行緒池 為了避免系統頻繁地建立和銷燬執行緒，我們可以讓建立的執行緒進行復用。執行緒池中，總有那麼幾個活躍執行緒。當你需要使用執行緒時，可以從池子中隨便拿一個空閒執行緒，當完成工作時，並不急著關閉執行緒，而是將整個執行緒退回到池子，方便其他人使用。 2）JDK對執

Java高併發程式設計（十二）：Executor框架

Java中的執行緒既是工作單元，也是執行單元。工作單元包括Runnable和Callable，而執行單元是由Executor框架支援。 1. Executor框架簡介 1.1 Executor框架的兩級排程模型 在HotSpot VM的執行緒模型中，Java執行緒（java.la

Java高併發程式設計（十一）：Java中執行緒池

在開發過程中，合理地使用執行緒池能夠帶來3個好處。 降低資源消耗。通過重複利用已建立的執行緒降低執行緒建立和銷燬造成的消耗。 提高響應速度。當任務到達時，任務可以不需要等到執行緒建立就能立即執行。 提高執行緒的可管理性。執行緒是稀缺資源，如果無限制地建立

Java高併發程式設計（十）：Java併發工具類

1. 等待多執行緒完成的CountDownLatch CountDownLatch允許一個或多個執行緒等待其他執行緒完成操作。 1.1 應用場景 假如有這樣一個需求：我們需要解析一個Excel裡多個sheet的資料，此時可以考慮使用多 執行緒，每個執行緒解析一個sheet裡的資料

《Java高併發程式設計》學習 --7.10 多個Actor同時修改資料：Agent

在Actor的程式設計模型中，Actor之間主要通過訊息進行資訊傳遞。因此，很少發生多個Actor需要訪問一個共享變數的情況。但在實際開發中，這種情況很難完全避免。如果多個Actor需要對同一個共享變數進行讀寫時，如何保證執行緒安全呢？ 在Akka中，使用一種叫做Agent