執行緒

筆記目錄：(https://www.cnblogs.com/wenjie2000/p/16378441.html)

程式(program)

是為完成特定任務、用某種語言撰寫的一組指令的集合，簡單的說:就是我們寫的代碼

行程

行程是指運行中的程式，比如我們使用QQ，就啟動了一個行程，作業系統就會為該行程分配記憶體空間，當我們使用迅雷，又啟動了一個行程，作業系統將為迅雷分配新的記憶體空間，
行程是程式的一次執行程序，或是正在運行的一個程式，是動態程序:有它自身的產生、存在和消亡的程序

執行緒介紹

什么是執行緒

執行緒由行程創建的，是行程的一個物體2.一個行程可以擁有多個執行緒（例如迅雷中多個下載任務同時進行）
坦克大戰（每個敵人坦克就是一個執行緒）[后面會把多執行緒加入到坦克大戰中，學以致用]

其他相關概念

單執行緒:同一個時刻，只允許執行一個執行緒
多執行緒:同一個時刻，可以執行多個執行緒，比如:一個qq行程，可以同時打開多個聊天視窗,一個迅雷行程，可以同時下載多個檔案
并發:同一個時刻，多個任務交替執行，造成一種“貌似同時”的錯覺，簡單的說，單核cpu實作的多任務就是并發，

并行:同一個時刻，多個任務同時執行，多核cpu可以實作并行，

public class Test {
    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();
        //獲取當前電腦的cpu數量/核心數
        int cpuNums = runtime.availableProcessors();
        System.out.println("當前有CPU個數"+cpuNums);
    }
}

執行緒使用

創建執行緒的兩種方式

在java中執行緒來使用有兩種方法，

繼承Thread類,重寫run方法
實作Runnable介面，重寫run方法

繼承Thread

執行緒應用案例1-繼承Thread類

請撰寫程式,開啟一個執行緒，該執行緒每隔1秒，在控制臺輸出“啪瞄,我是小貓咪'
對上題改進:當輸出80次唶瞄,我是小貓咪，結束該執行緒
使用JConsole監控執行緒執行情況，并畫出程式示意圖!

public class Test {
    public static void main(String[] args) throws InterruptedException {
        //創建Cat物件，可以當做執行緒使用
        Cat cat = new Cat();

        /*
            (1)
            public synchronized void start() {
                start0();
            }
            (2)
            //start0()是本地方法，是JVM呼叫，底層是c/c++實作
            //真正實作多執行緒的效果，是start0()，而不是 run
            private native void start0();
        */

        cat.start();//啟動執行緒
        //cat.run();//run方法就是一個普通的方法，沒有真正的啟動一個執行緒，就會把run方法執行完畢，才向下執行

        //說明:當main執行緒啟動一個子執行緒 Thread-0，主執行緒不會阻塞，會繼續執行//這時主執行緒和子執行緒是交替執行..
        System.out.println("主執行緒繼續執行" + " 執行緒名" + Thread.currentThread().getName());//執行緒main
        for (int i = 0; i < 60; i++) {
            System.out.println("主執行緒i=" + i);
            //讓主執行緒休眠
            Thread.sleep(1000);
        }

    }
}
//說明
//1，當一個類繼承了 Thread 類，該類就可以當做執行緒使用
//2．我們會重寫 run方法，寫上自己的業務代碼
//3.run Thread類實作了Runnable介面的run方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
*/

class Cat extends Thread {
    int times = 0;

    @Override
    public void run() {
        while (true) {
            //該執行緒每隔1秒，在控制臺輸出“瞄瞄，我是小貓咪"
            System.out.println("瞄瞄，我是小貓咪" + " 執行緒名" + (++times) + Thread.currentThread().getName());//讓該執行緒休眠1秒ctrl+alt+t
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times == 80) {
                break; //當times 到80，退出while，這時執行緒也就退出..
            }
        }
    }
}

start()方法原理

實作Runnable

執行緒應用案例2-實作Runnable介面

說明

java是單繼承的，在某些情況下一個類可能已經繼承了某個父類,這時在用繼承Thread類方法來創建執行緒顯然不可能了，
java設計者們提供了另外一個方式創建執行緒，就是通過實作Runnable介面來創建執行緒

執行緒使用應用案例-實作Runnable介面

應用案例

請撰寫程式該程式可以每隔1秒，在控制臺輸出“hi!”,當輸出10次后，自動退出，請使用實作Runnable介面的方式實作，

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Dog dog = new Dog();
        //dog.start();這里不能呼叫start
        //創建了Thread物件，把 dog物件(實作Runnable)，放入Thread
        Thread thread = new Thread(dog);
        thread.start();
    }
}

class Dog implements Runnable {//通過實作Runnable介面，開發執行緒
    int count = 0;

    @Override
    public void run() {//普通方法
        while (true) {
            System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count>10){
                break;
            }
        }
    }
}

這里底層使用了設計模式【代理模式】

以下為代碼模擬實作Runnable介面開發執行緒的機制(可以用來代替上述代碼中的Thread類的功能)此處只是模擬來展示原理，并不能實際創建新執行緒，任然是執行main執行緒

//執行緒代理類，模擬了一個極簡的Thread類
class ThreadProxy implements Runnable {//你可以把Proxy類當做 ThreadProxy
    private Runnable target = null;//屬性，型別是 Runnable

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    public void start() {
        start0();
    }

    public void start0() {
        run();
    }
}

繼承Thread vs 實作Ruunnable的區別

從java的設計來看，通過繼承Thread或者實作Runnable介面來創建執行緒本質上沒有區別,從jdk幫助檔案我們可以看到Thread類本身就實作了Runnable介面
實作Runnable介面方式更加適合多個執行緒共享一個資源的情況，并且避免了單繼承的限制（建議使用Runnnable介面）

思考：[售票系統]，編程模擬三個售票視窗售票100張,分別使用繼承 Thread和實作Runnable方式,并分析有什么問題?

public class Test {
    public static void main(String[] args) {
//測驗
        SellTicket01 sellTicket01 = new SellTicket01();
        SellTicket01 sellTicket02 = new SellTicket01();
        SellTicket01 sellTicket03 = new SellTicket01();
        //這里會出現超賣問題
        sellTicket01.start();//啟動售票執行緒
        sellTicket02.start();//啟動售票執行緒
        sellTicket03.start();//啟動售票執行緒
    }
}

class SellTicket01 extends Thread {
    private static int ticketNum = 100;//讓多個執行緒共享ticketNum

    @Override
    public void run() {

        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票結束...");
                break;
            }
            //休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("視窗" + Thread.currentThread().getName() +"售出一張票"
                    + "剩余票數=" + (--ticketNum));
        }
    }
}

執行緒終止

基本說明

當執行緒完成任務后,會自動退出，
還可以通過使用變數來控制run方法退出的方式停止執行緒，即通知方式

●應用案例

需求:啟動一個執行緒，要求在main執行緒中去停止執行緒t,請編程實作.

public class Test {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        Thread thread = new Thread(t1);
        thread.start();
        //如果希望main執行緒去控制t1 執行緒的終止，必須可以修改 loop
        // 讓t1退出run方法，從而終止t1執行緒->通知方式
        //讓主執行緒休眠10秒，再通知t1執行緒退出
        System.out.println("main執行緒休眠10s");
        Thread.sleep(5 * 1000);
        t1.setLoop(false);
    }

}

class T implements Runnable {
    boolean loop = true;//步驟1:定義標記變數，默認為true@Override
    int count=0;
    @Override
    public void run() {
        while (loop) {//步驟2:將loop作為回圈條件
            try {
                Thread.sleep(50);//讓當前執行緒休眠10ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("AThread運行中...."+(++count));
        }
    }

    //步驟3:提供公共的set方法，用于更新loop
    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

執行緒常用方法

常用方法第一組

setName //設定執行緒名稱,，使之與引數name相同
getName //回傳該執行緒的名稱
start //使該執行緒開始執行;Java虛擬機底層呼叫該執行緒的start0方法
run //呼叫執行緒物件 run方法;
setPriprity //更改執行緒的優先級
getPriority //獲取執行緒的優先級
sleep //在指定的毫秒數內讓當前正在執行的執行緒休眠(暫停執行)
interrupt //中斷執行緒

注意事項和細節

start底層會創建新的執行緒,呼叫run，run 就是一個簡單的方法呼叫，本身不會啟動新執行緒
執行緒優先級的范圍
sleep:執行緒的靜態方法,使當前執行緒休眠

interrupt:中斷執行緒，但并沒有真正的結束執行緒，所以一般用于中斷正在休眠執行緒

public class Test {
    public static void main(String[] args) throws InterruptedException {
        //測驗相關的方法
        T t = new T();
        t.setName("老韓");
        t.setPriority(Thread.MIN_PRIORITY);//1
        t.start();//啟動子執行緒

        //主執行緒列印5hi，然后我就中斷子執行緒的休眠
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
        }
        t.interrupt();//當執行到這里,就會中斷t執行緒的休眠，

    }
}

class T extends Thread {
    int count=0;
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                //Thread.currentThread().getName()獲取當前執行緒的名稱
                System.out.println(Thread.currentThread().getName() + "吃包子~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + "休眠中 ~~~"+(++count));
                Thread.sleep(20000);//20秒
            } catch (InterruptedException e) {
                //當該執行緒執行到一個interrupt 方法時，就會catch一個例外，可以加入自己的業務代碼
                //InterruptedException是捕獲到一個中斷例外，
                System.out.println(Thread.currentThread().getName() + "被interrupt了");
            }
        }
    }
}

常用方法第二組

yield:執行緒的禮讓，讓出cpu,讓其他執行緒執行,但禮讓的時間不確定,所以也不一定禮讓成功（例：Thread.yield();//禮讓自己使用cpu資源，不指定某一特定執行緒，具體用法看下面代碼）
join:執行緒的插隊，插隊的執行緒一旦插隊成功,則肯定
先執行完插入的執行緒所有的任務（例：t2.join();//指定特定的某一執行緒先完成任務，再執行自己的作業）

案例:創建一個子執行緒,每隔1s輸出hello,輸出20次,主執行緒每隔1秒,，輸出hi,輸出20次.要求:兩個執行緒同時執行，當主執行緒輸出5次后,就讓子執行緒運行完畢,主執行緒再繼續

public class Test {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        t2.start();
        for (int i = 1; i <= 20; i++) {
            Thread.sleep(1000);
            System.out.println("主執行緒(小弟)吃了" +i+"個包子");
            if (i == 5) {
                System.out.println("主執行緒(小弟)讓子執行緒(老大）先吃");
                //join，執行緒插隊
                //t2.join();// 這里相當于讓t2 執行緒先執行完畢
                Thread.yield();//禮讓，不一定成功
                System.out.println("執行緒(老大)吃完了主執行緒(小弟）接著吃..");
            }
        }
    }
}

class T2 extends Thread {
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子執行緒（老大）吃了" + i + "包子");
        }
    }
}

用戶執行緒和守護執行緒

用戶執行緒:也叫作業執行緒，當執行緒的任務執行完或通知方式結束
守護線星:一般是為作業執行緒服務的，當所有的用戶執行緒結束，守護執行緒自動結束
常見的守護執行緒:垃圾回識訓制

public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果我們希望當main執行緒結束后，子執行緒自動結束
        //,只需將子執行緒設為守護執行緒即可
        myDaemonThread.setDaemon(true);//守護執行緒要在該執行緒啟動前設定
        myDaemonThread.start();
        for (int i = 1; i <= 10; i++) {//main執行緒
            System.out.println("寶強在辛苦的作業...");
            Thread.sleep(1000);
        }
    }
}

class MyDaemonThread extends Thread {
    public void run() {
        while (true) {//無限回圈
            try {
                Thread.sleep(1000);//休眠1000毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("馬蓉和宋喆快樂聊天，哈哈哈~~~");
        }
    }
}

執行緒的生命周期

JDK檔案中用Thread.State列舉表示了執行緒的幾種狀態

執行緒狀態轉換圖

synchronized

執行緒同步機制

在多執行緒編程，一些敏感資料不允許被多個執行緒同時訪問,此時就使用同步訪問技術，保證資料在任何同一時刻，最多有一個執行緒訪問，以保證資料的完整性，
也可以這里理解:執行緒同步，即當有一個執行緒在對記憶體進行操作時，其他執行緒都不可以對這個記憶體地址進行操作，直到該執行緒完成操作，其他執行緒才能對該內仔地址進行操作.

同步具體方法-Synchronized

注意 synchronized鎖的是一個特定的物件，而不是方法，也不是某塊代碼（由同一類創建的不同物件中的同一方法或代碼并不能被synchronized鎖）

同步代碼塊

synchronized(物件){//得到物件的鎖，才能操作同步代碼
    //需要被同步代碼;
}

synchronized還可以放在方法宣告中，表示整個方法-為同步方法
```
public synchronized void m (String name){
	//需要被同步的代碼
}
```

執行緒同步可理解為上廁所問題

只有一間廁所（synchronized處理了的方法或代碼塊），進入一個人然后鎖上門（鎖），出來后下一個人才能進入，

使用synchronized解決售票問題（之前會出現剩余票數為負數的情況）

public class Test {
    public static void main(String[] args) {
        //測驗
        SellTicket03 sellTicket03 = new SellTicket03();

        new Thread(sellTicket03).start();//啟動售票執行緒1
        new Thread(sellTicket03).start();//啟動售票執行緒2
        new Thread(sellTicket03).start();//啟動售票執行緒3
    }
}

class SellTicket03 implements Runnable{
    private int ticketNum = 100;//讓多個執行緒共享ticketNum
    private boolean loop = true;

    @Override
    public void run() {

        while (loop) {
            ticketCheck();
        }
    }
    
    public synchronized void ticketCheck() {//注意此處 synchronized鎖的是一個特定的物件，而不是方法（由同一類創建的不同物件中的同一方法不能被synchronized鎖）
        if (ticketNum <= 0) {
            System.out.println("售票結束...");
            loop = false;
            return;
        }
        //休眠50毫秒
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("視窗" + Thread.currentThread().getName() + " 售出一張票 " + "剩余票數=" + (--ticketNum));
    }
}

互斥鎖

基本介紹

Java語言中，引入了物件互斥鎖的概念，來保證共享資料操作的完整性，
每個物件都對應于一個可稱為“互斥鎖”的標記，這個標記用來保證在任一時刻，只能有r-個執行緒訪問該物件，
關鍵字synchronized來與物件的互斥鎖聯系，當某個物件用synchronized修飾時,表明該物件在任一時刻只能由一個執行緒訪問
同步的局限性:導致程式的執行效率要降低
同步方法（(非靜態的)的鎖可以是this(針對一個物件),也可以是其他物件(要求是同一個物件)
同步方法(靜態的)的鎖為當前類本身，

public class Test {
    public static void main(String[] args) {
        //測驗
        SellTicket03 sellTicket03 = new SellTicket03();

        new Thread(sellTicket03).start();//啟動售票執行緒1
        new Thread(sellTicket03).start();//啟動售票執行緒2
        new Thread(sellTicket03).start();//啟動售票執行緒3
    }
}

class SellTicket03 implements Runnable {
    private int ticketNum = 100;//讓多個執行緒共享ticketNum
    private boolean loop = true;

    @Override
    public void run() {
        while (loop) {
            ticketCheck();
        }
    }

    //說明
    //1. public synchronized static void m1()丹鎖是加在SellTicket03.class
    //2．如果在靜態方法中，實作一個同步代碼塊.
    /*
    synchronized (SellTicket03.class) {
        System.out.println("m2");
    */
    public synchronized static void m1() {
    }

    public static void m2() {
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
    }

    //說明
    //1. public synchronized void sell(){}就是一個同步方法
    //2．這時鎖在 this物件
    //3．也可以在代碼塊上寫 synchronize ,同步代碼塊
    public /*synchronized*/ void ticketCheck() {
        synchronized (this) {
            if (ticketNum <= 0) {
                System.out.println("售票結束...");
                loop = false;
                return;
            }
            //休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("視窗" + Thread.currentThread().getName() + " 售出一張票 " + "剩余票數=" + (--ticketNum));
        }
    }
}

注意事項和細節

同步方法如果沒有使用static修飾:默認鎖物件為this
如果方法使用static修飾，默認鎖物件:當前類.class
實作的落地步驟:

需要先分析上鎖的代碼
選擇同步代碼塊或同步方法
要求多個執行緒的鎖物件為同一個即可!

死鎖

基本介紹

多個執行緒都占用了對方的鎖資源,但不肯相讓，導致了死鎖，在編程是一定要避免死鎖的發生，

應用案例

媽媽：你先完成作業，才讓你玩手機

小明：你先讓我玩手機,我才完成作業，

模擬死鎖

public class Test {
    public static void main(String[] args) {
        //模擬死鎖現象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A執行緒");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B執行緒");
        A.start();
        B.start();
    }
}
//執行緒
class DeadLockDemo extends Thread {
    static Object o1 = new Object();//保證多執行緒，共享一個物件,這里使用static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
        this.flag = flag;
    }

    //下面業務邏輯的分析
    //1．如果flag為 T，執行緒A就會先得到/持有o1 物件鎖，然后嘗試去獲取o2物件鎖
    //2．如果執行緒A得不到o2物件鎖，就會Blocked
    //3．如果flag為F，執行緒B就會先得到/持有o2物件鎖，然后嘗試去獲取 o1物件鎖
    //4．如果執行緒B得不到 o1 物件鎖，就會Blocked
    //總的來說兩個執行緒都有對方的鎖，且都需要對方的鎖，如果沒有，就會一直等待，因而照成Blocked
    public void run() {
        if (flag) {
            synchronized (o1) {
                System.out.println(Thread.currentThread().getName() + "進入1");
                synchronized (o2) {// 這里獲得li物件的監視權
                    System.out.println(Thread.currentThread().getName() + "進入2");
                }
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + "進入3");
                synchronized (o1) {//這里獲得li物件的監視權
                    System.out.println(Thread.currentThread().getName() + "進入4");
                }
            }
        }
    }
}

死鎖現象很危險，一定要避免，

釋放鎖

下面操作會釋放鎖（還是將同步機制比作上廁所）

當前執行緒的同步方法、同步代碼塊執行結束

案例:上廁所，完事出來
當前執行緒在同步代碼塊、同步方法中遇到break、return.

案例:沒有正常的完事,經理叫他修改bug，不得已出來
當前執行緒在同步代碼塊、同步方法中出現了未處理的Error或Exception,導致例外結束

案例:沒有正常的完事,發現忘帶紙,不得已出來
當前執行緒在同步代碼塊、同步方法中執行了執行緒物件的wait()方法，當前執行緒暫停，并釋放鎖，

案例:沒有正常完事,覺得需要醞釀下，所以出來等會再進去，讓其他人先進來，

下面操作不會釋放鎖

執行緒執行同步代碼塊或同步方法時，程式呼叫Thread.sleep()、Thread.yield()方法暫停當前執行緒的執行,不會釋放鎖

案例:上廁所，太困了，在坑位上瞇了一會
執行緒執行同步代碼塊時,其他執行緒呼叫了該執行緒的suspend()方法將該執行緒掛起,該執行緒不會釋放鎖，

注意:應盡量避免使用suspend()和resume()來控制執行緒，這兩個方法官方不再推薦使用，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/503345.html

標籤：其他

上一篇：Python代碼用在這些地方，其實1行就夠了！

下一篇：基本運算子

Java學習-第一部分-第二階段-第七節：泛型

執行緒