Java開啟線程的四種方法

1，繼承Thread類

繼承Thread類,重寫run方法(不推薦,因為java的單繼承局限性)

public class ExtendThread extends Thread {

    /*
    * 創建步驟如下：
    * 1，定義Thread類的子類，並重寫該類的run()方法，該run()方法的方法體就代表了線程需要完成的任務。因此把run方法稱為線程執行體。
    * 2，創建Thread子類了的實例，即創建線程對象。本實例中是new一個ExtendThread，即可創建線程對象，也就是開啟了一個線程
    * 3，調用線程對象的start()方法來啟動該線程。
    *
    * 調用示例：
    * //循環10次即開啟10個線程
    * for (int i = 0; i < 10; i++) {
    *     ExtendThread extendThread = new ExtendThread();
    *     extendThread.start();
    * }
    * */

    /**
     * 重寫Thread類的run()，這個方法稱為線程執行體
     * */
    @Override
    public void run() {
        doSomething();
    }

    /**
     * 需要處理的任務
     * */
    public void doSomething(){
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "執行" + i);
        }
    }
}

2，實現Runnable接口

方式一：直接實現Runnable接口(避免單繼承的局限性,方便共享資源,推薦使用)

public class RunnableImpl implements Runnable {

    /*
    * 創建步驟如下：
    * 1，定義Runnable接口的實現類，並且實現run方法，這個方法同樣是線程執行體
    * 2，創建Runnable實現類的實例，並以此實例對象作為Thread的target來創建Thread類，這個新創建的Thread對象才是真正的線程對象，即開啟了新的線程
    * 3，調用線程對象的start()方法來開啟該線程
    *
    * 調用示例：
    * //開啟10個線程
    * for (int i = 0; i < 10; i++) {
    *     Thread thread = new Thread(new RunnableImpl());
    *     thread.start();
    * }
    * */

    /**
     * 實現Runnable接口的run方法，這個方法稱為線程執行體
     * */
    @Override
    public void run() {
        doSomething();
    }

    /**
     * 需要處理的任務
     * */
    private void doSomething(){
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "執行" + i);
        }
    }
}

方式二：匿名內部類

public class Anonymous {

    /*
    * 創建步驟如下：
    * 匿名內部類本質上也是一個類實現了Runnable接口，重寫了run方法，只不過這個類沒有名字，直接作為參數傳入Thread類
    *
    * 調用示例：
    * //開啟10個線程
    * for (int i = 0; i < 10; i++) {
    *     Anonymous anonymous =new Anonymous();
    *     anonymous.myRun();
    * }
    *
    * */

    public void myRun(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                doSomething();
            }
        }).start();
    }

    /**
     * 需要處理的任務
     * */
    private void doSomething(){
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "執行" + i);
        }
    }
}

3，實現Callable接口

public class CallableImpl implements Callable<String> {

    /*
     * 創建步驟如下：
     * 1，定義實現Callable<V>接口的實現類，實現call方法，這個方法是線程執行體
     * 2，創建Callable<V>實現類的實例，借助FutureTask得到線程執行的返回值
     * 3，將FutureTask的實例，作為Thread的target來創建Thread類
     * 4，調用start方法，開啟線程
     *
     * 調用示例：
     * Callable<String> tc = new CallableImpl();
     * FutureTask<String> task = new FutureTask<>(tc);
     * new Thread(task).start();
     * try {
     *     System.out.println(task.get());
     * } catch (InterruptedException | ExecutionException e) {
     *     e.printStackTrace();
     * }
     *
     * 說明：
     * 1.與使用Runnable相比， Callable功能更強大些
     * 2.實現的call()方法相比run()方法，可以返回值
     * 3.方法可以拋出異常
     * 4.支持泛型的返回值
     * 5.需要借助FutureTask類，比如獲取返回結果
     * Future接口可以對具體Runnable、Callable任務的執行結果進行取消、查詢是否完成、獲取結果等。
     * FutureTask是Futrue接口的唯一的實現類
     * FutureTask 同時實現了Runnable, Future接口。它既可以作為Runnable被線程執行，又可以作為Future得到Callable的返回值
     *
     * */

    private int ticket = 5;

    @Override
    public String call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println(doSomething());
        }

        return "出票任務完成";
    }

    public String doSomething() {
        String result = "";
        if (this.ticket > 0) {
            result = "出票成功，ticket=" + this.ticket--;
        } else {
            result = "出票失敗，ticket=" + this.ticket;
        }
        return result;
    }
}

4，創建線程池

public class ThreadPool implements Runnable {

    /*
     * 創建步驟如下：
     * 1，定義Runnable接口的實現類，或者定義（繼承Runnable接口的類）的實現類，並且實現run方法，這個方法是線程執行體
     * 2，創建一個自定義線程個數的線程池
     * 3，實例化Runnable接口的實現類
     * 4，將3步的實例，作為線程池實例的execute方法的command參數，開啟線程
     * 5，關閉線程池
     *
     * 調用示例：
     * ExecutorService pool = Executors.newFixedThreadPool(2);
     * ThreadPool threadPool = new ThreadPool("AA");
     * ThreadPool threadPoo2 = new ThreadPool("BB");
     * pool.execute(threadPool);
     * pool.execute(threadPoo2);
     * pool.shutdown();
     *
     * 說明：
     * 示例中創建的是2個線程的線程池
     * execute方法是開啟線程方法，實參要求是實現Runnable的類。所以，繼承Thread類的子類也可以以線程池的方式開啟線程
     *
     * */

    String name;
    public ThreadPool(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        doSomething();
    }

    /**
     * 需要處理的任務
     * */
    private void doSomething() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "執行" + i + "，name=" + this.name);
        }
    }
}