多執行緒的執行緒狀態及相關操作

wangyudong927發表於2021-12-14
執行緒

執行緒狀態

執行緒方法

方法 說明
setPriority(int newPriority) 更改執行緒的優先順序
static void sleep(long millis) 在指定的毫秒數內讓當前正在執行的執行緒休眠
void join() 等待該執行緒終止
static void yield() 暫停當前正在執行的執行緒物件，並執行其他執行緒
void interrupt() 中斷執行緒，別用這個方式
boolean isAlive() 測試執行緒是否處於活動轉檯

停止執行緒

  • 不推薦使用JDK提供的stop()、destroy()方法。(已廢棄)

  • 推薦執行緒自己停下來

  • 建議使用一個標誌位進行終止變數

    當flag=false，則終止執行緒執行

//測試stop
//1.建議執行緒正常停止--->利用次數，不建議死迴圈
//2.建議使用標誌位--->設定一個標誌位
//3.不要使用stop或者destroy等過時或者JDK不建議使用的方法

public class TestStop implements Runnable{

    //1.設定一個標識位
    private boolean flag = true;

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run...Thread"+i++);
        }
    }

    //2.設定一個公開的方法停止執行緒，轉換標誌位

    public void stop(){
        this.flag = false;
    }
    
    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if (i==900){
                //呼叫stop方法切換標誌位，讓執行緒停止
                //改變子執行緒中flag的值為false，主執行緒則繼續執行迴圈
                testStop.stop();
                System.out.println("執行緒該停止了");
            }
        }
    }
}

執行緒休眠 Thread.sleep();

  • sleep(時間)指定當前執行緒阻塞的毫秒數；
  • sleep存在異常InterruptedException；
  • sleep時間達到後執行緒進入就緒狀態；
  • sleep可以模擬網路延時，倒數計時等；
  • 每一個物件都有一個鎖，sleep不會釋放鎖；
import java.text.SimpleDateFormat;
import java.util.Date;

//模擬倒數計時...
public class TestSleep2{

    public static void main(String[] args) {
        //列印當前系統時間
        Date startTime = new Date(System.currentTimeMillis());
        int num = 1;

        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime = new Date(System.currentTimeMillis());//更新當前時間
                num++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (num>=10){
                break;
            }
        }
        
        /*try {
            tenDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/
    }

    //模擬倒數計時
    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }
    }
}
=============================================================================
import com.Thread.demo01.TestThread4;

//模擬網路延時: 放大問題的發生性
//不同執行緒可能得到同一張票
public class TestSleep implements Runnable{
    //票數
    private int ticketNums = 10;

    @Override
    public void run() {
        while (true) {
            if (ticketNums<=0){
                break;
            }
            //模擬延時
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
        }
    }

    public static void main(String[] args) {

        TestThread4 testThread4 = new TestThread4();

        new Thread(testThread4,"小明").start();
        new Thread(testThread4,"老師").start();
        new Thread(testThread4,"黃牛黨").start();
    }
}

執行緒禮讓

  • 禮讓執行緒，讓當前正在執行的執行緒暫停，但不阻塞
  • 將執行緒從執行狀態轉為就緒狀態
  • 讓cpu重新排程，禮讓不一定成功！看cpu心情
//測試禮讓執行緒
//禮讓不一定成功，看CPU心情
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}

class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"執行緒開始執行");
        Thread.yield();//禮讓
        System.out.println(Thread.currentThread().getName()+"執行緒停止執行");
    }
}

Join(插隊)

  • join合併執行緒，待此執行緒執行完成後，再執行其他執行緒，其他執行緒阻塞
  • 可以想象成插隊
//測試join方法//想象為插隊
public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("執行緒vip來了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException{

        //啟動我們的執行緒
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);//需要定義一個引數，以便呼叫join
        thread.start();

        //主執行緒

        for (int i = 0; i < 1000; i++) {
            if (i==200){
                thread.join();//插隊
            }
            System.out.println("main"+i);
        }
    }
}

執行緒狀態觀測(thread.getState())

  • Thread.State(執行緒狀態)
    • 執行緒可以出於以下狀態之一：
      • NEW 尚未啟動的執行緒處於此狀態
      • RUNNABLE 在Java虛擬機器中執行的執行緒處於此狀態
      • BLOCKED 被阻塞等待監視器鎖定的執行緒處於此狀態
      • WAITING 正在等待另一個執行緒執行特定動作的執行緒處於此狀態
      • TIMED_WAITING 正在等待另一個執行緒執行動作達到指定等待時間的執行緒處於此狀態
      • TERMINATED 已退出的執行緒處於此狀態
    • 一個執行緒可以在給定時間點處於一個狀態。這些狀態是不反映任何作業系統執行緒狀態的虛擬機器狀態
//觀察測試執行緒的狀態
public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("/////");
        });

        //觀察狀態
        Thread.State state = thread.getState();
        System.out.println(state);//NEW

        //觀察啟動後
        thread.start();//啟動執行緒
        state = thread.getState();
        System.out.println(state);//Run

        while (state != Thread.State.TERMINATED){//只要執行緒不終止，就一直輸出狀態
            Thread.sleep(100);
            state = thread.getState();//更新執行緒狀態
            System.out.println(state);//輸出狀態
        }
    }
}

執行緒優先順序

  • Java提供一個執行緒排程器來監控程式中啟動後進入就緒狀態的所有執行緒，執行緒排程器按照優先順序決定應該排程哪個執行緒來執行
  • 執行緒的優先順序用數字表示，範圍從1~10
    • Thread.MIN_PRIORITY = 1;
    • Thread.MAX_PRIORITY = 10;
    • Thread.NORM_PRIORITY = 5;
  • 使用以下方式改變或獲取優先順序
    • getPriority().setPriority(int xxx)
  • 優先順序低只是意味著獲得排程的概率低，並不是優先順序低就不會被呼叫了，這都是看CPU的排程。優先順序的設定建議在start()排程前
//測試執行緒的優先順序
public class TestPriority {

    public static void main(String[] args) {
        //主執行緒預設優先順序
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority);
        Thread t2 = new Thread(myPriority);
        Thread t3 = new Thread(myPriority);
        Thread t4 = new Thread(myPriority);

        //先設定優先順序，再啟動
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
        t4.start();
    }
}

class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

守護(daemon)執行緒

  • 執行緒分為使用者執行緒和守護執行緒
  • 虛擬機器必須確保使用者執行緒執行完畢
  • 虛擬機器不用等待守護執行緒執行完畢
  • 如：後臺記錄操作日誌，監控記憶體，垃圾回收等待...
//測試守護執行緒
//上帝守護你
public class TestDaemon {

    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//預設是false表示是使用者執行緒，正常的執行緒都是使用者執行緒...

        thread.start();//上帝守護執行緒啟動

        new Thread(you).start();//你 使用者執行緒啟動...
    }
}

//上帝
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑著你");
        }
    }
}

//你
class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("你一生都開心的活著");
        }
        System.out.println("=====goodbye! world!====="); //Hello,World!
    }
}

相關文章