Java線程的六種狀態以及切換

時間 2020-12-06

標籤 java 多線程併發 ide 函數工具性能 this spa 線程欄目 Java 简体版

原文原文鏈接

Thread線程狀態的劃分:

Java中線程的狀態分爲6種。java

初始(NEW)：新建立了一個線程對象，但尚未調用start()方法。

運行(RUNNABLE)：Java線程中將就緒（ready）和運行中（running）兩種狀態籠統的稱爲「運行」。線程對象建立後，其餘線程(好比main線程）調用了該對象的start()方法。該狀態的線程位於可運行線程池中，等待被線程調度選中，獲取CPU的使用權，此時處於就緒狀態（ready）。就緒狀態的線程在得到CPU時間片後變爲運行中狀態（running）。

3. 阻塞(BLOCKED)：表示線程阻塞於鎖。
4. 等待(WAITING)：進入該狀態的線程須要等待其餘線程作出一些特定動做（通知或中斷）。
5. 超時等待(TIMED_WAITING)：該狀態不一樣於WAITING，它能夠在指定的時間後自行返回。多線程

終止(TERMINATED)：表示該線程已經執行完畢。

這6種狀態定義在Thread類的State枚舉中，可查看源碼進行一一對應。併發

1、線程的狀態圖

2、狀態詳細說明

2.1. 初始狀態(NEW)

實現Runnable接口和繼承Thread能夠獲得一個線程類，new一個實例出來，線程就進入了初始狀態。ide

2.2. 就緒狀態(RUNNABLE之READY)

就緒狀態只是說你資格運行，調度程序(Cpu)沒有挑選到你，你就永遠是就緒狀態。
調用線程的start()方法，此線程進入就緒狀態。
當前線程sleep()方法結束，其餘線程join()結束，等待用戶輸入完畢，某個線程拿到對象鎖，這些線程也將進入就緒狀態。
當前線程時間片用完了，調用當前線程的yield()方法，當前線程進入就緒狀態。
鎖池裏的線程拿到對象鎖後，進入就緒狀態。

2.3. 運行中狀態(RUNNABLE之RUNNING)

線程調度程序從可運行池中選擇一個線程做爲當前線程時線程所處的狀態。這也是線程進入運行狀態的惟一的一種方式。函數

2.4. 阻塞狀態(BLOCKED)

阻塞狀態是線程阻塞在進入synchronized關鍵字修飾的方法或代碼塊(獲取鎖)時的狀態。工具

2.5. 等待(WAITING)

處於這種狀態的線程不會被分配CPU執行時間，它們要等待被顯式地喚醒，不然會處於無限期等待的狀態。性能

2.6. 超時等待(TIMED_WAITING)

處於這種狀態的線程不會被分配CPU執行時間，不過無須無限期等待被其餘線程顯示地喚醒，在達到必定時間後它們會自動喚醒。this

2.7. 終止狀態(TERMINATED)

當線程的run()方法完成時，或者主線程的main()方法完成時，咱們就認爲它終止了。這個線程對象也許是活的，可是它已經不是一個單獨執行的線程。線程一旦終止了，就不能復生。
在一個終止的線程上調用start()方法，會拋出java.lang.IllegalThreadStateException異常。

3、等待隊列

調用obj的wait(), notify()方法前，必須得到obj鎖，也就是必須寫在synchronized(obj) 代碼段內。
與等待隊列相關的步驟和圖

線程1獲取對象A的鎖，正在使用對象A。
線程1調用對象A的wait()方法。
線程1釋放對象A的鎖，並立刻進入等待隊列。
鎖池裏面的對象爭搶對象A的鎖。
線程5得到對象A的鎖，進入synchronized塊，使用對象A。
線程5調用對象A的notifyAll()方法，喚醒全部線程，全部線程進入同步隊列。若線程5調用對象A的notify()方法，則喚醒一個線程，不知道會喚醒誰，被喚醒的那個線程進入同步隊列。
notifyAll()方法所在synchronized結束，線程5釋放對象A的鎖。
同步隊列的線程爭搶對象鎖，但線程1何時能搶到就不知道了。

4、同步隊列狀態

當前線程想調用對象A的同步方法時，發現對象A的鎖被別的線程佔有，此時當前線程進入同步隊列。簡言之，同步隊列裏面放的都是想爭奪對象鎖的線程。
當一個線程1被另一個線程2喚醒時，1線程進入同步隊列，去爭奪對象鎖。
同步隊列是在同步的環境下才有的概念，一個對象對應一個同步隊列。
線程等待時間到了或被notify/notifyAll喚醒後，會進入同步隊列競爭鎖，若是得到鎖，進入RUNNABLE狀態，不然進入BLOCKED狀態等待獲取鎖。

5、幾個方法的比較

Thread.sleep(long millis)，必定是當前線程調用此方法，當前線程進入TIMED_WAITING狀態，但不釋放對象鎖，millis後線程自動甦醒進入就緒狀態。做用：給其它線程執行機會的最佳方式。
Thread.yield()，必定是當前線程調用此方法，當前線程放棄獲取的CPU時間片，但不釋放鎖資源，由運行狀態變爲就緒狀態，讓OS再次選擇線程。做用：讓相同優先級的線程輪流執行，但並不保證必定會輪流執行。實際中沒法保證yield()達到讓步目的，由於讓步的線程還有可能被線程調度程序再次選中。Thread.yield()不會致使阻塞。該方法與sleep()相似，只是不能由用戶指定暫停多長時間。
thread.join()/thread.join(long millis)，當前線程裏調用其它線程t的join方法，當前線程進入WAITING/TIMED_WAITING狀態，當前線程不會釋放已經持有的對象鎖。線程t執行完畢或者millis時間到，當前線程通常狀況下進入RUNNABLE狀態，也有可能進入BLOCKED狀態（由於join是基於wait實現的）。
Object.wait()，當前線程調用對象的wait()方法，當前線程釋放對象鎖，進入等待隊列。依靠notify()/notifyAll()喚醒或者wait(long timeout) timeout時間到自動喚醒。
Object.notify()喚醒在此對象監視器上等待的單個線程，選擇是任意性的。notifyAll()喚醒在此對象監視器上等待的全部線程。
LockSupport.park()/LockSupport.parkNanos(long nanos),LockSupport.parkUntil(long deadlines), 當前線程進入WAITING/TIMED_WAITING狀態。對比wait方法,不須要得到鎖就可讓線程進入WAITING/TIMED_WAITING狀態，須要經過LockSupport.unpark(Thread thread)喚醒。

六建立線程的幾種方式

Thread

線程運行的過程會產生不少信息，這些信息都保存在Thread類中的成員變量裏面，常見的有：
a.線程的ID是惟一標識getId()
b.線程的名稱：getName()，若是不設置線程名稱默認爲「Thread-xx」
c.線程的優先級：getPriority，線程優先級從1-10,其中數字越大表示優先級別越高，同時得到JVM調度執行的可能性越大，JDK內置了三種常見的狀態：spa

`//最小優先級
public final static int MIN_PRIORITY = 1;

//通常優先級
public final static int NORM_PRIORITY = 5;

//最大優先級
public final static int MAX_PRIORITY = 10;`

通常不推薦設置線程的優先級，若是進行設置了非法的優先級程序就會出現IllegalArgumentException異常。線程

建立線程方式一：

繼承Thread類。
步驟：
1，定義一個類繼承Thread類。
2，覆蓋Thread類中的run方法。
3，直接建立Thread的子類對象建立線程。
4，調用start方法開啓線程並調用線程的任務run方法執行。

能夠經過Thread的getName獲取線程的名稱 Thread-編號(從0開始)
主線程的名字就是main。

class Demo extends Thread
{
    /**
     *線程名稱
     */
    private String name;
    Demo(String name)
    {
       //父類構造函數，改線程的名稱 
        super(name); 
        //this.name = name;
    }
    //***run方法中定義就是線程要運行的任務代碼。***
    public void run()
    {
        for(int x=0; x<10; x++)
        {
            //for(int y=-9999999; y<999999999; y++){}
            System.out.println(name+"....x="+x+".....name="+Thread.currentThread().getName());
        }
    }
}

class ThreadDemo2 
{
    public static void main(String[] args) 
    {
        Demo d1 = new Demo("旺財");
        Demo d2 = new Demo("xiaoqiang");
        d1.start();//開啓線程，調用run方法。
        d2.start();
        System.out.println("over...."+Thread.currentThread().getName());
    }
}

建立線程方式二

當該類有本身父類的時候，經過實現Runnable接口，覆蓋run方法。（經常使用）
步驟：

1，定義類實現Runnable接口。

2，覆蓋接口中的run方法，將線程的任務代碼封裝到run方法中。

3，經過Thread類建立線程對象，並將Runnable接口的子類對象做爲Thread類的構造函數的參數進行傳遞。

爲何？由於線程的任務都封裝在Runnable接口子類對象的run方法中。

因此要在線程對象建立時就必須明確要運行的任務。

思想：將線程的任務經過Runnable接口封裝成了對象。

4，調用線程對象的start方法開啓線程。

實現Runnable接口的好處：

1，將線程的任務從線程的子類中分離出來，進行了單獨的封裝，按照面向對象的思想將任務封裝成對象。
2，避免了java單繼承的侷限性。

//extends Fu 
//準備擴展Demo類的功能，讓其中的內容能夠做爲線程的任務執行。
//經過接口的形式完成。
class Demo implements Runnable{
    public void run()
    {
        show();
    }
    public void show()
    {
        for(int x=0; x<20; x++)
        {
            System.out.println(Thread.currentThread().getName()+"....."+x);
        }
    }
}

class  ThreadDemo
{
    public static void main(String[] args) 
    {    
        Demo d = new Demo();
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);
        t1.start();
        t2.start();

    }
}

建立線程方式三

實現Callable接口

與使用Runnable相比， Callable功能更強大些

1 相比run()方法，能夠有返回值

2 方法能夠拋出異常

3 支持泛型的返回值

4 須要藉助FutureTask類，好比獲取返回結果

Future接口

1 能夠對具體Runnable、Callable任務的執行結果進行取消、查詢是
否完成、獲取結果等。

2 FutrueTask是Futrue接口的惟一的實現類

3 FutureTask 同時實現了Runnable, Future接口。它既能夠做爲 Runnable被線程執行，又能夠做爲Future獲得Callable的返回值

//1.建立一個實現Callable的實現類
class Stu implements Callable {
    //2.實現call方法,將此線程須要執行的操做生命call()中
    @Override
    public Object call() throws Exception {
        int sum=0;
        for (int i = 1; i <=100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class Bank {
    public static void main(String[] args) {
        //3.建立Callable接口實現類的對象
        Stu stu = new Stu();
        //4.將此Callable接口實現類的對象做爲傳遞到FutureTask構造器中，建立FutureTask的對象
         FutureTask futureTask = new FutureTask(stu);
        //5.FutureTask的對象做爲參數傳遞到Thread類的構造器中建立Thread，並調用start()
         new Thread(futureTask).start();
        try {
            Object sum = futureTask.get();
            System.out.println("總和爲"+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }
}

建立線程方式四

使用線程池
背景：常常建立和銷燬、使用量特別大的資源，好比並髮狀況下的線程，對性能影響很大。

思路：提早建立好多個線程，放入線程池中，使用時直接獲取，使用完放回池中。能夠避免頻繁建立銷燬、實現重複利用。相似生活中的公共交通工具。

好處:

1提升響應速度（減小了建立新線程的時間）;

2下降資源消耗（重複利用線程池中線程，不須要每次都建立）;

3便於線程管理;

corePoolSize：核心池的大小

 maximumPoolSize：最大線程數

 keepAliveTime：線程沒有任務時最多保持多長時間後會終止

//建立並使用多線程的第四種方法：使用線程池
class MyThread implements Runnable {

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if(i % 2 ==0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }

}

public class ThreadPool {
    public static void main(String[] args) {
        // 1.提供指定線程的數量
        ExecutorService service = Executors.newFixedThreadPool(10);
        //設置線程的屬性
        ThreadPoolExecutor service1= (ThreadPoolExecutor) service;
        //service1.setMaximumPoolSize(15);
        //service1.setCorePoolSize();*/
        // 2.將Runnable實現類的對象做爲形參傳遞給ExecutorService的submit()方法中，開啓線程
        // 並執行相關的run()
        service.execute(new MyThread());//適用於Runnable
        //service.submit();適用於Callable

        // 3.結束線程的使用
        service.shutdown();

    }
}