Thread和Runnable的區別

一、Thread和Runnable區別

Java中的thread和runnable都是與線程有關的概念，它們之間有什麼區別呢？

thread是一個類，可以擴展Java類庫，它在實現線程時必須重寫run()方法。而runnable是一個接口，它只有一個run()方法需要重寫。在實現線程時，通常使用Runnable接口。

//Thread示例
class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("Thread");
    }
}

//Runnable示例
class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("Runnable");
    }
}

public class Main {
    public static void main(String[] args){
        //創建Thread對象並啟動線程
        MyThread myThread = new MyThread();
        myThread.start();

        //創建Runnable對象並啟動線程
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

二、Runnable接口

Runnable接口是一個函數式接口，它只有一個run()方法需要重寫，該方法定義了線程要執行的任務的代碼邏輯。

實現Runnable接口相對於擴展Thread類更加靈活，因為Java是單繼承的，如果擴展了Thread類那麼該類就不能再擴展其他的類了，這給程序設計帶來了極大的限制。另外，如果需要創建多個線程對象，那麼要擴展Thread類需要去創建多個Thread的子類，而實現Runnable接口只需要創建多個Runnable類的實例對象即可。

//Runnable示例
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i = 0; i < 5; i++){
            System.out.println(Thread.currentThread().getName() + ":" + i);
            try{
                Thread.sleep(500);
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args){
        //創建Runnable對象並啟動線程1
        MyRunnable myRunnable1 = new MyRunnable();
        Thread thread1 = new Thread(myRunnable1, "Thread-1");
        thread1.start();

        //創建Runnable對象並啟動線程2
        MyRunnable myRunnable2 = new MyRunnable();
        Thread thread2 = new Thread(myRunnable2, "Thread-2");
        thread2.start();
    }
}

三、Runnable狀態

線程狀態是指一個線程在某一時刻的狀態。Java中的線程有以下六種狀態：

New：新建狀態，在線程創建後還沒有啟動時處於此狀態
Runnable：就緒狀態，當線程調用start()方法後處於此狀態
Blocked：阻塞狀態，線程暫停執行，等待某個條件滿足後再繼續執行
Waiting：等待狀態，線程等待其他線程的通知，不會自動恢復運行
Timed Waiting：定時等待狀態，線程等待其他線程的通知，等待一段時間後會自動恢復運行
Terminated：終止狀態，線程執行完畢或者拋出異常後處於此狀態

Runnable狀態是指線程正在執行中的狀態。

import java.util.concurrent.TimeUnit;

//Runnable示例
class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("Runnable線程開始執行。。。");
        try{
            TimeUnit.SECONDS.sleep(5);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("Runnable線程執行結束。。。");
    }
}

public class Main {
    public static void main(String[] args){
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();

        while(thread.isAlive()){
            System.out.println("線程正在執行中。。。");
            try{
                TimeUnit.SECONDS.sleep(1);
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        System.out.println("線程執行完畢。。。");
    }
}

四、Thread和Runnable的選擇

一般來說，如果只是簡單的單線程程序，可以直接繼承Thread類；如果是多線程程序，或者需要繼承其他類的情況下，建議採用實現Runnable接口的方式。

Thread類在實現Runnable接口的基礎上進行了封裝，提供了更多的線程操作方法，適用於需要控制線程的詳細信息的高級應用。而Runnable接口則更為簡潔，更為靈活。

//Thread示例
class MyThread extends Thread{
    @Override
    public void run() {
        for(int i = 0; i < 5; i++){
            System.out.println(Thread.currentThread().getName() + ":" + i);
            try{
                sleep(500);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

//Runnable示例
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i = 0; i < 5; i++){
            System.out.println(Thread.currentThread().getName() + ":" + i);
            try{
                Thread.sleep(500);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args){
        //創建Thread對象並啟動線程
        MyThread myThread = new MyThread();
        myThread.start();

        //創建Runnable對象並啟動線程
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

五、總結

Java中的thread和runnable都是與線程有關的概念，其中thread是一個類，可以擴展Java類庫，它在實現線程時必須重寫run()方法；而runnable是一個接口，它只有一個run()方法需要重寫。在實現線程時，通常使用Runnable接口。

Runnable接口相對於擴展Thread類更加靈活，因為Java是單繼承的，如果擴展了Thread類那麼該類就不能再擴展其他的類了，這給程序設計帶來了極大的限制。另外，如果需要創建多個線程對象，那麼要擴展Thread類需要去創建多個Thread的子類，而實現Runnable接口只需要創建多個Runnable類的實例對象即可。

線程的狀態包括新建狀態、就緒狀態、阻塞狀態、等待狀態、定時等待狀態和終止狀態。Runnable狀態指線程正在執行中的狀態。

使用Thread類，則需要在類中直接實現run()方法；使用Runnable接口，需要在類中實現run()方法，並且需要創建一個Thread對象，將實現了Runnable接口的類傳遞給Thread對象的構造方法，並且調用start()方法啟動線程。

原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-hk/n/196042.html