本文屬xxKarina原創(chuàng)，轉(zhuǎn)載請注明
個人博客地址：https://xxkarina.github.io/

文章要點

• 線程是什么
• 線程有什么
• 線程怎么用

線程是什么？

學習線程，首先要先了解幾個常用的概念：

• 進程：每個正在系統(tǒng)上運行的程序都是一個進程，一個進程至少包含一個線程，進程可以是整個或者部分程序的動態(tài)執(zhí)行
• 線程：線程是一組指令的集合，是輕量級的進程，是進程中負責程序執(zhí)行的執(zhí)行單元；線程依靠程序，是程序中的順序控制流，需要使用程序的資源和環(huán)境
• 多線程：簡單的理解就是，在一個程序中運行多個任務，其目的是為了更好的利用CPU資源，加快進程的運行速度，增加效率，實現(xiàn)多個線程并發(fā)執(zhí)行

有了多線程，我們就可以實現(xiàn)并發(fā)啦

• 并發(fā)：通過CPU調(diào)度算法，實現(xiàn)宏觀上并行，微觀上串行的技術(shù)

線程有什么？

線程的狀態(tài)：

我們都知道，線程也有生命周期，整個生命周期有五大基本狀態(tài)：

• 新建狀態(tài)：新建一個線程對象

• 就緒狀態(tài)：創(chuàng)建了對象之后，這個線程如果執(zhí)行了start()方法，就會位于線程池，等待CPU的使用權(quán)，是一種可運行狀態(tài)

• 運行狀態(tài)：在就緒狀態(tài)的基礎上獲取了CPU使用權(quán)，于是執(zhí)行程序代碼，在運作狀態(tài)

• 阻塞狀態(tài)：線程因為某種原因失去了CPU的使用權(quán)，暫時停止運行，轉(zhuǎn)為阻塞狀態(tài)，要再次運行則必須經(jīng)過先轉(zhuǎn)為就緒狀態(tài)，常見的阻塞有三種情況：

  • 等待阻塞： 正在運行的線程，如果執(zhí)行了wait()方法，就會被JVM放入等待池中
  • 同步阻塞： 正在運行的線程在獲取對象的同步鎖失敗時，也會被JVM放入等待池
  • 其他阻塞：正在運行的線程若執(zhí)行了sleep()或者join()方法，或者發(fā)出了I/O請求，則線程暫停運行，進入阻塞狀態(tài)

• 死亡狀態(tài)：

它們之間的關系，我借用了網(wǎng)上找的一張圖片來描述

線程的生命周期

線程怎么用？

這里，我們細說個所以然

• 創(chuàng)建線程方法一：繼承 Thread 類

Thread 類是線程類，本質(zhì)上是實現(xiàn)了 Runnable 接口，該類的實例就是一個線程，一個線程要執(zhí)行的任務就寫在 run() 方法中，格式：

public abstract void run ()

Thread 類常用的方法有:

• //線程的線程體，通常在 Thread 類的子類中覆蓋
• public void run()
• //由 JVM 調(diào)用線程的 run()方法，啟動線程開始執(zhí)行
• public void start()
• //返回正在執(zhí)行的線程對象引用
• public static Thread currentThread()
• //設置線程名
• public void setName(String name)
• //返回線程名
• public void getName()
• //使當前正在執(zhí)行的線程暫時停止執(zhí)行指定的毫秒時間，需要處理異常
• public static void sleep(long millis)
• //使當前執(zhí)行的線程暫停執(zhí)行，允許其他線程執(zhí)行
• public static void yield()
• //中斷當前線程
• public void interrupt()
• //返回指定線程是否處于活動狀態(tài)
• public boolean isAlive()

創(chuàng)建線程小Demo（繼承Thread）：

/*
 * 輸入線程程序，查看結(jié)果
 */
class SimpleThread extends Thread {
    public SimpleThread(String str) {
        super(str); // 調(diào)用其父類的構(gòu)造方法
    }

    public void run() { // 重寫run方法
        for (int i = 0; i < 10; i++) {
            System.out.println(i + " " + getName());
            // 打印次數(shù)和線程的名字
            try {
                sleep((int) (Math.random() * 1000));
                // 線程睡眠，把控制權(quán)交出去
            } catch (InterruptedException e) {
            }
        }
        System.out.println("DONE! " + getName());
        // 線程代碼就完畢啦
    }

}

public class TwoThreadsTest {
    public static void main(String args[]) {
        new SimpleThread("First").start();
        // 第一個線程的名字為First
        new SimpleThread("Second").start();
        // 第二個線程的名字為Second
    }

}

上述代碼，首先將類 SimpleThread 繼承了 Thread 類，然后在其覆蓋的run() 方法（亦即線程體）中加入需要執(zhí)行的代碼，再通過 new 方法，創(chuàng)建了兩個不同的線程，分別執(zhí)行他們的 start() 方法開始執(zhí)行

將上面的代碼執(zhí)行幾遍，你會發(fā)現(xiàn)每次的執(zhí)行結(jié)果都不一樣，這進一步說明了多線程的獨立性以及達到了異步的目的

• 創(chuàng)建線程方法二：實現(xiàn) Runnable 接口

繼承Thread 類固然是更好理解一點，但是基于Java不支持多繼承的特性，這進一步給我們帶來了困擾，在這種情況下我們就可以使用第二種方式 實現(xiàn)Runnable接口，上面我們說到，繼承Thread類的本質(zhì)就是實現(xiàn)了Runnable 接口，所以他們的使用方法有很大的相似性，幾乎一樣

創(chuàng)建線程小Demo（實現(xiàn)Runnable接口）：

/*
 * 輸入線程程序，查看結(jié)果
 */
class SimpleThread implements Runnable {
    public SimpleThread() {
        super(); // 調(diào)用其父類的構(gòu)造方法
    }

    public void run() { // 重寫run方法
        for (int i = 0; i < 10; i++) {
            System.out.println(i + " " + Thread.currentThread().getName());
            // 打印次數(shù)和線程的名字
            try {
                Thread.sleep((int) (Math.random() * 1000));
                // 線程睡眠，把控制權(quán)交出去
            } catch (InterruptedException e) {
            }
        }
        System.out.println("DONE! " + Thread.currentThread().getName());
        // 線程代碼就完畢啦
    }

}

public class TwoThreadsTest {
    public static void main(String args[]) {
        SimpleThread target = new SimpleThread();
        new Thread(target,"First").start();
        // 第一個線程的名字為First
        new Thread(target,"Second").start();
        // 第二個線程的名字為Second
    }

}

由于沒有繼承Thread類，所以我們要直接對Thread進行操作，調(diào)用方法或者創(chuàng)建的線程的時候都需要以Thread類為基礎

• 創(chuàng)建線程方法三：實現(xiàn) Callable 接口

使用Callable和Future接口創(chuàng)建線程，具體是創(chuàng)建Callable接口的實現(xiàn)類，并實現(xiàn)call()方法，并使用FutureTask類來包裝Callable實現(xiàn)類的對象，且以此FutureTask對象作為Thread對象的target來創(chuàng)建線程。

創(chuàng)建線程小Demo（實現(xiàn)Callable接口）：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class SimpleThread implements Callable<Integer> {
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            sum += i;
        }

        return sum;
    }
}

public class TwoThreadsTest {
    public static void main(String args[]) {
        // 創(chuàng)建對象
        Callable<Integer> simpleThread = new SimpleThread();
        // 使用FutureTask來包裝對象
        FutureTask<Integer> ft = new FutureTask<Integer>(simpleThread);
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            // FutureTask對象作為Thread對象的target創(chuàng)建新的線程
            Thread thread = new Thread(ft);
            thread.start();
            // 線程代碼就完畢啦
            System.out.println("DONE! ");
            try {
                // 取得新創(chuàng)建的新線程中的call()方法返回的結(jié)果
                System.out.println("sum = " + ft.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }

        }
    }
}

整個Demo中幾乎找不到我們熟悉的身影，其實，它和繼承Thread一樣，本質(zhì)上都是實現(xiàn)了Runnable接口，我們來看下FutureTask的定義

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

所以，雖然我們在使用實現(xiàn)Callable接口的時候，發(fā)現(xiàn)實現(xiàn)的是call()方法而不是run()并且有返回值，其實是一樣的