執行緒_join yield 與interrupt執行緒

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

join yield與中斷執行緒（2）

1、join

join()方法：加入執行緒讓呼叫的執行緒先執行指定時間或者是指向完畢

異常：InterruptedException-如果任何執行緒中斷當前執行緒。當丟擲異常時，當前執行緒的中斷狀態被清除

package com.huanghe;

/**
 * @Author: River
 * @Date:Created in  10:27 2018/5/28
 * @Description: join()方法：加入執行緒讓呼叫的執行緒先執行指定時間或者是指向完畢
 */
public class ThreadDemo2 {
    public 
 static void main(String[] args) {

        MyRunable2 mr2 = new MyRunable2();
        Thread t = new Thread(mr2);
        t.start();

        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"--"+i);
            try {
                Thread.sleep(500);
            } catch 
 (InterruptedException e) {
                e.printStackTrace();
            }
            if (i == 10) {
                try {
                    t.join();//讓t執行緒執行完畢
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }

    }
}

class MyRunable2 implements Runnable{

    @Override 

    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"--"+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
執行的結果如下：
main--0
Thread-0--0
main--1
Thread-0--1
main--2
Thread-0--2
main--3
Thread-0--3
Thread-0--4
main--4
Thread-0--5
main--5
Thread-0--6
main--6
Thread-0--7
main--7
main--8
Thread-0--8
Thread-0--9
main--9
main--10
Thread-0--10
Thread-0--11
Thread-0--12
Thread-0--13
Thread-0--14
Thread-0--15
Thread-0--16
Thread-0--17
Thread-0--18
Thread-0--19
main--11
main--12
main--13
main--14
main--15
main--16
main--17
main--18
main--19

2、yield()

yield：

解釋它之前，先簡述下，多執行緒的執行流程：多個執行緒併發請求執行時，由cpu決定優先執行哪一個，

即使通過thread.setPriority()，設定了執行緒的優先順序，也不一定就是每次都先執行它

yield，表示暫停當前執行緒，執行其他執行緒(包括自身執行緒) 由cpu決定

public class TestYield implements Runnable {    

        public void run() {    

                System.out.println("first: " + Thread.currentThread().getName() );    
                // 暫停當前正在執行的執行緒物件，並執行其他執行緒，就是進入就緒狀態    
                Thread.currentThread().yield();    
                // 可能還會執行 本執行緒: 以下語句不一定緊接著上面的語句被執行，可能其他執行緒的先執行了  
                System.out.println("second: " + Thread.currentThread().getName() );    

        }    

        public static void main(String[] args) {    
            TestYield runn = new TestYield();    
            Thread t1 = new Thread(runn);    
            Thread t2 = new Thread(runn);    
            Thread t3 = new Thread(runn);    

            t2.setPriority(t2.getPriority()+1); //設定t2的執行緒優先順序   
            t1.start();    
            t2.start();    
            t3.start();    

        }    
}

多次執行，看執行結果

first: Thread-0  
first: Thread-2  
second: Thread-2  
first: Thread-1  
second: Thread-0  
second: Thread-1

其實預設情況下，多執行緒時，cpu就會切換執行的任務執行緒，而yield方法，只是人為的通知系統，進行切換，
且有一定機率能切換回本身

3、中斷

public void interrupt():
//中斷這個執行緒
//除非當前執行緒中斷自身，這是始終允許的
//可以使用interrupt()方法將執行緒從凍結狀態強制恢復到執行狀態中來，讓執行緒具備CPU的執行資格，但是強制動作會發生中斷異常InterruptedException，記得需要進行處理

public static boolean interrupted()
 //測試當前執行緒是否中斷。該方法可以清除中斷狀態。換句話說，如果這個方法被連續的呼叫兩次，那麼第二個呼叫將返回false(除非當前執行緒再次中斷，在第一個呼叫已經清除其中的中斷狀態之後，在第二個呼叫之前已經檢查過)

package com.huanghe.Demo;

/**
 * @Author: River
 * @Date:Created in  10:27 2018/5/28
 * @Description: join()方法：加入執行緒讓呼叫的執行緒先執行指定時間或者是指向完畢
 * (1):使用Interrupt方法中斷執行緒，設定一箇中斷標記
 * (2):自定義中斷標記
 */
public class ThreadDemo2 {
    public static void main(String[] args) {

        MyRunable2 mr2 = new MyRunable2();
        Thread t = new Thread(mr2);
        t.start();

        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"--"+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
           if (i == 10) {
               t.interrupt();//中斷執行緒,中斷標記
            }
        }
    }
}

class MyRunable2 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            if (Thread.interrupted()){//測試中斷狀態，此方法會把中斷標記清除
                break;
            }
            System.out.println(Thread.currentThread().getName()+"--"+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

執行的結果是：

Thread-0--0
main--0
main--1
Thread-0--1
Thread-0--2
main--2
Thread-0--3
main--3
Thread-0--4
main--4
Thread-0--5
main--5
Thread-0--6
main--6
Thread-0--7
main--7
Thread-0--8
main--8
Thread-0--9
main--9
Thread-0--10
main--10
Thread-0--11
main--11
Thread-0--12
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at com.huanghe.Demo.MyRunable2.run(ThreadDemo2.java:53)
    at java.lang.Thread.run(Thread.java:745)
main--12
Thread-0--13
main--13
Thread-0--14
main--14
Thread-0--15
main--15
Thread-0--16
main--16
Thread-0--17
main--17
Thread-0--18
main--18
Thread-0--19
main--19

為什麼會出現丟擲異常之後又繼續的執行呢？

因為sleep方法會丟擲中斷異常，InterruptedException：如果任何執行緒中斷當前執行緒，就會丟擲中斷異常；因為在sleep中會丟擲中斷異常，並且異常會被清除

package com.huanghe;

/**
 * @Author: River
 * @Date:Created in  10:27 2018/5/28
 * @Description: join()方法：加入執行緒讓呼叫的執行緒先執行指定時間或者是指向完畢
 */
public class ThreadDemo2 {
    public static void main(String[] args) {

        MyRunable2 mr2 = new MyRunable2();
        Thread t = new Thread(mr2);
        t.start();

        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"--"+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
           if (i == 10) {
//                try {
//                    t.join();//讓t執行緒執行完畢
//                }catch (InterruptedException e){
//                    e.printStackTrace();
//                }
               t.interrupt();//1、中斷執行緒,中斷標記
            }
        }

    }
}

class MyRunable2 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
             if (Thread.interrupted()){//4）測試中斷狀態，此方法會把中斷標記清除
                break;
            }
            System.out.println(Thread.currentThread().getName()+"--"+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace(); //2、因為在sleep中會丟擲中斷異常，並且異常會被清除
                 t.interrupt();//3、中斷標記需要再次的被打上
            }
        }
    }
}
//執行的結果
main--0
Thread-0--0
main--1
java.lang.InterruptedException: sleep interrupted
Thread-0--1
    at java.lang.Thread.sleep(Native Method)
    at com.huanghe.MyRunable2.run(ThreadDemo2.java:42)
    at java.lang.Thread.run(Thread.java:745)
java.lang.InterruptedException: sleep interrupted
main--2
Thread-0--2
    at java.lang.Thread.sleep(Native Method)
    at com.huanghe.MyRunable2.run(ThreadDemo2.java:42)
    at java.lang.Thread.run(Thread.java:745)
main--3
java.lang.InterruptedException: sleep interrupted
Thread-0--3
    at java.lang.Thread.sleep(Native Method)
Thread-0--4
    at com.huanghe.MyRunable2.run(ThreadDemo2.java:42)
    at java.lang.Thread.run(Thread.java:745)
main--4
java.lang.InterruptedException: sleep interrupted
Thread-0--5
    at java.lang.Thread.sleep(Native Method)
Thread-0--6
    at com.huanghe.MyRunable2.run(ThreadDemo2.java:42)
    at java.lang.Thread.run(Thread.java:745)
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at com.huanghe.MyRunable2.run(ThreadDemo2.java:42)
    at java.lang.Thread.run(Thread.java:745)
Thread-0--7
main--5
java.lang.InterruptedException: sleep interrupted
Thread-0--8
    at java.lang.Thread.sleep(Native Method)
main--6
    at com.huanghe.MyRunable2.run(ThreadDemo2.java:42)
Thread-0--9
    at java.lang.Thread.run(Thread.java:745)
java.lang.InterruptedException: sleep interrupted
main--7
    at java.lang.Thread.sleep(Native Method)
Thread-0--10
    at com.huanghe.MyRunable2.run(ThreadDemo2.java:42)
Thread-0--11
    at java.lang.Thread.run(Thread.java:745)
java.lang.InterruptedException: sleep interrupted
main--8
    at java.lang.Thread.sleep(Native Method)
Thread-0--12
    at com.huanghe.MyRunable2.run(ThreadDemo2.java:42)
    at java.lang.Thread.run(Thread.java:745)
java.lang.InterruptedException: sleep interrupted
Thread-0--13
    at java.lang.Thread.sleep(Native Method)
main--9
    at com.huanghe.MyRunable2.run(ThreadDemo2.java:42)
Thread-0--14
    at java.lang.Thread.run(Thread.java:745)
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at com.huanghe.MyRunable2.run(ThreadDemo2.java:42)
    at java.lang.Thread.run(Thread.java:745)
Thread-0--15
main--10
Thread-0--16
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at com.huanghe.MyRunable2.run(ThreadDemo2.java:42)
    at java.lang.Thread.run(Thread.java:745)
main--11
Thread-0--17
main--12
java.lang.InterruptedException: sleep interrupted
Thread-0--18
    at java.lang.Thread.sleep(Native Method)
Thread-0--19
    at com.huanghe.MyRunable2.run(ThreadDemo2.java:42)
    at java.lang.Thread.run(Thread.java:745)
main--13
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at com.huanghe.MyRunable2.run(ThreadDemo2.java:42)
    at java.lang.Thread.run(Thread.java:745)
main--14
main--15
main--16
main--17
main--18
main--19
會出現異常的原因是sleep()會丟擲中斷異常

從執行的結果中可以看出，程式並沒有停止執行，但是丟擲了異常，這個異常是Runable裡面的sleep丟擲的異常，t.interrup();只是做了一箇中斷標記，t是不是真的需要中斷進行，需要執行緒自己進行決定；

所以如果需要完成一個正常的中斷，需要上面的四步才可以順序的完成

4、自定義標記中斷執行緒

由於上面的中斷過程很麻煩，所以在做中斷執行緒的時候使用的是自定義中斷執行緒

package com.huanghe;

/**
 * @Author: River
 * @Date:Created in  10:27 2018/5/28
 * @Description: join()方法：加入執行緒讓呼叫的執行緒先執行指定時間或者是指向完畢
 * (1):使用Interrupt方法中斷執行緒，設定一箇中斷標記
 * (2):自定義中斷標記
 */
public class ThreadDemo2 {
    public static void main(String[] args) {

        MyRunable2 mr2 = new MyRunable2();
        Thread t = new Thread(mr2);
//        t.start();

        MyRunable3 mr3 = new MyRunable3();
        Thread t2 = new Thread(mr3);
        t2.start();

        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"--"+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
           if (i == 10) {
//                try {
//                    t.join();//讓t執行緒執行完畢
//                }catch (InterruptedException e){
//                    e.printStackTrace();
//                }
//               t.interrupt();//中斷執行緒,中斷標記
               mr3.flag=false;//自定義中斷異常
            }

        }

    }
}

class MyRunable2 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            if (Thread.interrupted()){//測試中斷狀態，此方法會把中斷標記清除
                break;
            }
            System.out.println(Thread.currentThread().getName()+"--"+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
                Thread.currentThread().interrupt();
            }
        }
    }
}


class MyRunable3 implements Runnable{

    public boolean flag=true;

    public MyRunable3(){
        flag = true;
    }

    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println(Thread.currentThread().getName() + "====" + (i++));
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

執行緒_join yield 與interrupt執行緒

join yield與中斷執行緒（2） 1、join join()方法：加入執行緒讓呼叫的執行緒先執行指定時間或者是指向完畢異常：InterruptedException-如果任何執行緒中斷當前執行緒。當丟擲異常時，當前執行緒的中斷狀態

Java執行緒中yield與join方法的區別

長期以來，多執行緒問題頗為受到面試官的青睞。雖然我個人認為我們當中很少有人能真正獲得機會開發複雜的多執行緒應用(在過去的七年中，我得到了一個機會)，但是理解多執行緒對增加你的信心很有用。之前，我討論了一個wait()和sleep()方法區別的問題，這一次，我將會討

Python——程序與執行緒以及yield與return的區別

一、程序與執行緒 1. 一個程式至少有一個程序，一個程序至少有一個執行緒 2. 執行緒的劃分尺度小於程序，使得多執行緒程式的併發性高 3. 程序在執行過程中擁有獨立的記憶體單元，而多個執行緒共享記憶體，從而極大地提高了程式的執行

Java多執行緒程式設計中執行緒的同步與互斥/執行緒安全/Java鎖

摘要：多執行緒三個特徵:原子性、可見性以及有序性.>執行緒的同步與互斥?(同步執行緒與非同步執行緒,執行緒同步和非同步問題)  1.同步:假設現有執行緒A和執行緒B,執行緒A需要往緩衝區寫資料,執行緒B需要從緩衝區讀資料,但他們之間存在一種制約

執行緒（二）：執行緒開啟方式與多執行緒（threading模組）

目錄執行緒的建立Threading.Thread類 1）執行緒的建立 2）多執行緒與多程序 3）Thread類的其他方法 4）守護執行緒 multiprocess模組的完全模仿了threading模組的介面，二者在使用層面，有很大的相似性，因而不再詳細介紹（官方連結）

php執行緒安全版本與非執行緒安全版本

Windows下的PHP版本分兩種：執行緒安全版本與非執行緒安全版本。要論兩者的區別，詳細論說起來比較麻煩，從使用者的角度，記住什麼時候用哪種版本的區別就可以了吧： 1、windows + IIS + FastCGI ：使用非執行緒安全版本。解釋: 以FastCGI方

Java執行緒安全策略與多執行緒併發最佳實踐

執行緒安全策略不可變物件不可變物件(Immutable Objects)是指物件一旦被建立它的狀態（

多執行緒中sleep() wait() yield() join(), interrupt(),stop()，suspend()用法與區別

網上卻是有很多的關於這個的答案，但是都長得一樣，為了寫這篇部落格，自己找了幾個例子。 JoinThread: package com.com.aaa.threadJoinDemo; public c

多執行緒中sleep() wait() yield() join(), interrupt(),stop()，suspend()，setPriority()用法與區別

網上卻是有很多的關於這個的答案，但是都長得一樣，為了寫這篇部落格，自己找了幾個例子。 JoinThread: package com.com.aaa.threadJoinDemo; public class JoinThread extends Thread{ publ

Java多執行緒初探——yield()方法與join()方法

一、執行緒與程序 1、程序是程式（任務）執行過程，持有資源（共享記憶體，共享檔案）和執行緒，程序是動態性的，如果程式沒有執行就不算一個程序。 2、執行緒是系統中最小的執行單元，同一程序中有多個執行緒，執行緒共享程序的資源 Java中建立現成的方式就不再贅述了，有兩種：（1

執行緒中的yield與sleep方法的區別

轉載出：http://www.cnblogs.com/wdfrog/archive/2013/04/24/3039475.html wait會放棄物件鎖而notify不會放棄物件鎖，需要通過推出同步程式碼塊，或者呼叫wait以放棄物件鎖，讓被喚醒的執行緒執行當執行緒在執

多執行緒中的join(),yield()與優先順序Priority

1、join()：join()方法使呼叫該方法的執行緒在此之前執行完畢，也就是等待該方法的執行緒執行完畢後再往下繼續執行。注意該方法也需要捕捉異常。 ublic class Test { public static void main(String[] args) {

[領卓教育]執行緒的同步與互斥機制——訊號量

訊號量的初始化 int sem_init(sem_t *sem, int pshared, unsigned int value); 功能：初始化訊號量引數： sem ：要是初始化的訊號量　 pshared：訊號量共享的範圍(0: 執行緒間使用非0:程序間使用) value : 初始

c#中委託與多執行緒的實質

delegate（委託）的概念，.Net的委託本質上就是指向函式的指標，只不過這種指標是經過封裝後型別安全的。委託和執行緒是兩個不同的概念，執行緒是動態的，委託就是一個或一組記憶體地址，是靜態的。執行緒執行時如果遇到了指向函式的指標就執行這個函式。.Net為了方便程式設計，給委託賦予了兩種方式以供呼

java多執行緒8.效能與活躍性問題

死鎖——鎖順序死鎖兩個執行緒試圖以不同的順序來獲得相同的鎖。如果按照相同的順序來請求鎖，那麼就不會出現迴圈的加鎖依賴，因此也就不會產生死鎖。 public class LeftRightDeadlock { private final Object left = new Object();

第六章單例模式與多執行緒——立即載入“餓漢模式”與延遲載入“懶漢模式”

立即載入就是使用類的時候已經將物件建立完畢了，也稱為“餓漢模式” package test01; public class MyObject { // 建立物件 private static MyObject object = new MyObject(); private MyObjec

爬蟲與多執行緒

多執行緒和多程序爬蟲一.執行緒 1.什麼是執行緒。執行緒是作業系統能夠進行運算排程的最小單位。它被包含在程序中，是進城中的實際運作單位。一條執行緒指的是程序中一個單一順序的控制流，一個執行緒可以併發多個執行緒，每條執行緒執行不同的任務。 2.執行緒常用的方法

Java併發程式設計之執行緒生命週期、守護執行緒、優先順序和join、sleep、yield

Java併發程式設計中，其中一個難點是對執行緒生命週期的理解，和多種執行緒控制方法、執行緒溝通方法的靈活運用。這些方法和概念之間彼此聯絡緊密，共同構成了Java併發程式設計基石之一。 Java執行緒的生命週期 Java執行緒類定義了New、Runnable、Running Man、Blocked和Dead

執行緒安全與非執行緒安全

1、執行緒不共享資料對同一資源，各個執行緒各自執行一遍，程式碼如下: package com.zzm.th01; /** * 執行緒不共享資料 * Created by ming on 2017/6/15. */ public class th04 extends Thr

C語言高階篇 - 4.連結串列&狀態機與多執行緒

1.連結串列的引入 1、從陣列的缺陷說起 (1)陣列有2個缺陷，一個是陣列中所有元素的型別必須一致；第二個是陣列的元素個數必須事先制定並且一旦指定之後不能更改。 (2)如何解決

執行緒_join yield 與interrupt執行緒

join yield與中斷執行緒（2）

1、join

2、yield()

3、中斷

4、自定義標記中斷執行緒

相關推薦