併發編程基礎（上）

從我開始寫博客到現在，已經寫了不少關於併發編程的了，差不多還有一半內容整個併發編程系列就結束了，而今天這篇博客是比較簡單的，只是介紹下併發編程的基礎知識（ = =！其實，對於大神來說，前面所有博客都是基礎）。本來我不太想寫這篇博客，因爲這篇博客的很多內容都是以記憶爲主，而且網上也有大把大把的博客，都寫的相當不錯，但是我最終決定還是要寫一寫，因爲沒有這篇博客，併發編程系列就不能算是一個完整的系列。

什麼是線程

說到線程，不得不說到進程，因爲線程是無法單獨存在的，它只是進程中的一部分。
進程是代碼在數據集合上的一次運行活動，是系統進行資源分配和調度的基本單位。線程則是進程的一個執行路徑，一個進程中至少有一個線程。操作系統在分配系統資源的時候，會把CPU資源分配給線程，因爲真正執行工作，需要佔用CPU運行的是線程，所以也可以說線程是CPU分配的基本單位。
在Java中，我們啓動一個main函數，就啓動了一個JVM的進程，而main函數所在的線程被稱爲“主線程”。
每個線程都有一個叫“程序計數器”的私有的內存區域，用來記錄當前線程下一個要執行的指令地址，爲什麼要把程序計數器設計成私有的呢？因爲線程是佔用CPU的基本單位，而CPU一般是使用時間片輪轉的方式來讓線程佔有的，所以當某個線程的時間片用完後，要讓出CPU，等下一次獲得時間片了，再繼續執行。那麼線程怎麼知道之前的程序執行到哪裏了呢？就是靠程序計數器。另外需要注意的是，如果執行的是native方法，那麼程序計數器記錄的是undefined地址。

線程的三種創建方式與區別

線程有三種創建方式，分別是

繼承Thread類並重寫run方法;
實現Runnable接口的run方法;
實現Callable泛型接口，並實現call方法。

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


public class MyTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

class MyRannable implements Runnable {
    @Override
    public void run() {
        System.out.println("run");
    }
}

public class MyTest {
    public static void main(String[] args) {
        MyRannable myRannable = new MyRannable();
        new Thread(myRannable).start();
    }
}

class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "MyCallable";
    }
}

public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String>futureTask=new FutureTask<>(new MyCallable());
        new Thread(futureTask).start();
        System.out.println(futureTask.get());
    }
}

相信前面兩種方式不用多說，大家都懂。我們現在來看看第三種方式，首先定義了MyCallable類，並實現了Callable接口的call方法。在main方法中創建了FutureTask對象，傳入了MyCallable對象，然後用Thread包裝了FutureTask對象，隨後啓動，最後用futureTask提供的get方法獲取結果，獲取結果這一步是阻塞的。

在面試中，經常會問如下的問題：

調用Thread的start方法會發生什麼事情，線程會馬上執行嗎？
不會，調用Thread的start方法，線程沒有馬上執行，它處於“就緒”的狀態，需要獲得CPU資源後纔會執行。
調用Thread的start和run方法，有什麼區別？
調用start方法，纔會真正開啓新的線程執行run中的方法，而調用run方法，只是和調用普通方法一樣，不會開啓線程。
上面三種方式的區別是什麼，優缺點？
只有Thread纔是真正的線程，其他兩種方法都需要被Thread包裝纔可以成爲線程，在run方法中，可以使用this來獲得當前線程，不需要使用Thread.currentThread()，缺點在於Java是單繼承的，如果繼承了Thread類，就沒有辦法繼承其他類了，這是比較致命的，還有一個致命的缺點：無法交給線程池管理。
Runnable是接口，所以實現了Runnable接口，還可以繼承其他的類，但是必須被Thread類包裝纔可以成爲線程，可以被線程池管理。
以上兩種方法都是沒有返回值的，所以第三種方式Callable出現了，也可以被線程池管理，同樣的，也必須被Thread類包裝纔可以成爲線程。

線程的狀態

新建：當創建Thread的實例後，此線程進行新建狀態。如：Thread t1 = new Thread() 。（但是也有一些博客對這個提出了強烈的反對，認爲new Thread()只是創建了一個普通的Java對象而已，和線程或者線程的狀態八竿子打不着，不過認爲創建Thread實例後，線程就處於新建狀態的說法確實是主流）
就緒：當調用了start方法後，線程不會馬上執行，此時線程的狀態是“就緒”，等待分配CPU資源。
運行：線程獲得CPU資源後，真正開始執行。
死亡：當線程運行結束後，進入“死亡”狀態，處於此狀態的線程永遠都不會再次進入“就緒”。
阻塞：由於某種原因導致正在運行的線程讓出CPU並暫停自己的執行，就進入了“阻塞”的狀態，比如調用線程的sleep方法，對象的wait方法等。當滿足條件被返回後，線程重新進入“就緒”的狀態，再次等待分配CPU資源。

關於死亡和阻塞狀態，其實說的不太完整，因爲除了線程運行結束後這種“自然死亡”，還有一個情況，就是被stop了，但是Java已經不推薦使用stop等操作了，所以就忘記吧，阻塞也是同樣的道理，也不推薦使用suspend方法了，也忘記它把。

線程通知與等待

在Java中，每個對象都繼承了Object類，而在Object類中提供了通知和等待的操作，所以每個對象都有這樣的操作，既然是線程的通知與等待，爲什麼要把它定義在Object類中？因爲Java提供的鎖，鎖的是對象，而不是方法或是線程，所以自然要定義在Object類中。

wait

當一個線程調用共享變量的wait方法後，該線程會被阻塞掛起，直到發生以下的兩個事情才返回：

其他線程調用了該對象的notify或者notifyAll方法；
其他線程調用了該線程的interrupt方法，該線程會被返回，並且拋出InterruptedException異常。

class MyRunnable implements Runnable {
    Object object=new Object();

    @Override
    public void run() {
        try {
           synchronized (object){
               object.wait();
               System.out.println("run");
           }
        } catch (InterruptedException e) {
            System.out.println("被中斷了");
            e.printStackTrace();
        }
    }
}

public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
        thread.interrupt();
    }
}

運行結果：

被中斷了
java.lang.InterruptedException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:502)
    at com.codebear.MyRunnable.run(MyTest.java:13)
    at java.lang.Thread.run(Thread.java:748)

首先新建了一個子線程，子線程內部獲取了object的監視器鎖，隨後調用object的wait方法阻塞當前線程，主線程調用interrupt方法中斷子線程，子線程被返回，並且產生了異常。

這也就是爲什麼我們在調用共享變量的wait方法的時候，Java“死皮賴臉”的要我們對異常進行處理的原因：

調用wait方法後，還會釋放對共享變量的監視器鎖，讓其他線程可以進入臨界區：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        try {
            synchronized (MyRunnable.class) {
                System.out.println("我是" + Thread.currentThread().getName() + "，我進入了臨界區");
                MyRunnable.class.wait();
                Thread.sleep(Integer.MAX_VALUE);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("run");
    }
}

public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread1 = new Thread(myRunnable);
        thread1.start();
        Thread thread2 = new Thread(myRunnable);
        thread2.start();
    }
}

運行結果：

我是Thread-1，我進入了臨界區
我是Thread-0，我進入了臨界區

可以很清楚的看到，兩個線程都進入了臨界區。
線程A獲取了共享對象的監視器鎖後，進入了臨界區，線程B只能等待，線程A調用了共享對象的wait方法後，釋放了共享對象的監視器鎖，讓線程B也可以獲得共享變量的監視器鎖，並且進入臨界區。

在調用共享變量的wait方法前，必須先對該共享變量進行synchronized操作，否則會拋出IllegalMonitorStateException異常：

class MyRunnable implements Runnable {
    Object object = new Object();

    @Override
    public void run() {
        try {
            object.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("run");
    }
}

public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
        thread.interrupt();
    }
}

運行結果：

Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:502)
    at com.codebear.MyRunnable.run(MyTest.java:12)
    at java.lang.Thread.run(Thread.java:748)

另外需要注意的是，一個線程雖然從阻塞掛起的狀態到就緒的狀態，但是可能其他線程並沒有喚醒它，這就是虛假喚醒，雖然虛假喚醒在實踐中很少發生，但是防患於未然，比較嚴謹的做法就是在wait方法外面，包裹一個while循環，while循環的條件就是檢測是否滿足了被喚醒的條件，這樣即使虛假喚醒發生了，該線程被返回了，由於被while包裹了，發現並沒有滿足被喚醒的條件，又會被再次wait。
如下所示：

  while(是否滿足了被喚醒的條件) {
     object.wait();
  }

notify

wait方法是將當前線程阻塞掛起，那麼必定有一個方法是喚醒此線程的，就像沉睡的白雪公主也在等待王子的到來，將她喚醒一樣。
被喚醒的線程不能馬上從wait方法處返回，並且繼續執行，因爲還需要再次獲取共享變量的監視器鎖（因爲調用wait方法後，已經釋放了監視器，所以這裏需要再次獲取）。
如果有多個線程都調用了共享變量的wait方法而被阻塞掛起，那麼調用notify方法後，只會隨機喚醒其中一個線程。
還有一點尤其需要注意：當調用共享變量的notify方法後，並沒有釋放共享變量的監視器鎖，只有退出臨界區或者調用wait方法後，纔會釋放共享變量的監視器鎖，我們可以做一個實驗：

class CodeBearRunnable implements Runnable {

    private Object object = new Object();

    @Override
    public void run() {
        synchronized (object) {
            object.notify();
            System.out.println("我是" + Thread.currentThread().getName() + LocalDateTime.now());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class NotifyTest {
    public static void main(String[] args) {
        CodeBearRunnable codeBearRunnable = new CodeBearRunnable();
        new Thread(codeBearRunnable).start();
        new Thread(codeBearRunnable).start();
    }
}

運行結果：

我是Thread-02019-04-28T18:12:19.195
我是Thread-12019-04-28T18:12:22.196

我們來分析下代碼：當線程A獲取了共享變量的監視器鎖，進入了臨界區，調用共享變量的notify方法，打印出當前的時間，隨後sleep當前線程3秒。如果notify方法會釋放鎖，那麼線程B打印出來時間和線程A打印出來的時間應該相差不大，但是可以很清楚的看到，打印出來的時間相差了3秒，說明了線程A調用共享變量的notify方法後，並沒有釋放共享變量的鎖，只有退出了臨界區，才釋放了共享變量的鎖。

notifyAll

如果有多個線程都調用了共享變量的wait方法而被阻塞掛起，那麼調用notifyAll方法後，所有線程都會被喚醒。

最後，我們用一個常見的面試題來熟悉下wait/notify的應用：兩個線程交替打印奇偶數：

class MyRunnable implements Runnable {
    static private int i = 0;

    @Override
    public void run() {
        try {
            while (i < 100) {
                synchronized (MyRunnable.class) {
                    MyRunnable.class.notify();
                    MyRunnable.class.wait();
                    System.out.println("我是" + Thread.currentThread() + "：" + i++);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Thread thread1 = new Thread(new MyRunnable());
        thread1.start();

        Thread thread2 = new Thread(new MyRunnable());
        thread2.start();
    }
}

運行結果：

join

在開發中，我們經常會遇到這樣的需求：等待某些事情都完成後，纔可以繼續執行。比如旅遊網站查詢某個產品的航班，航班可以分爲去程和返程，我們可以開兩個線程同時查詢去程和返程的航班，等他們的結果都返回後，再執行其他操作。

class GoRunnable implements Runnable {
    @Override
    public void run() {
       System.out.println("查詢去程航班");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ReturnRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("查詢返程航班");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Thread thread1 = new Thread(new GoRunnable());
        thread1.start();

        Thread thread2 = new Thread(new ReturnRunnable());
        thread2.start();
        System.out.println("開始查詢航班，現在的時間是"+ LocalDateTime.now());
        thread1.join();
        thread2.join();
        System.out.println("航班查詢完畢，現在的時間是"+ LocalDateTime.now());
    }
}

運行結果：

查詢去程航班
查詢返程航班
開始查詢航班，現在的時間是2019-04-28T21:18:05.719
航班查詢完畢，現在的時間是2019-04-28T21:18:10.654

如果是同步查詢，那麼查詢航班的耗時應該在(5+3)秒左右，現在利用線程+join方法，兩個線程同時執行，耗時5秒左右（取決於慢的那個），在實際項目中，可以提升用戶的體驗，大幅提高查詢的效率。

這裏僅僅是演示join的功能，如果在實際項目中遇到這樣的場景應該不會用join這麼“粗糙”的方法。

讓我們再來看看當join遇到interrupt方法會擦出怎樣的火花：

class GoRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("查詢去程航班");
        for (; ; ) {
        }
    }
}

public class MyTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Thread thread1 = new Thread(new GoRunnable());
        thread1.start();
        Thread.currentThread().interrupt();
        try {
            thread1.join();
        } catch (InterruptedException e) {
            System.out.println("主線程" + e.toString());
        }
    }
}

運行結果：

主線程java.lang.InterruptedException
查詢去程航班

子線程內部是一個死循環，執行子線程後，中斷主線程，在主線程中的thread1.join處拋出了異常。但是需要注意的是，因爲中斷的是主線程，所以是在主線程中拋出異常，這裏我用try包住thread1.join()只是爲了更好的展現錯誤，其實這裏並不強制要求對異常進行捕獲。

本來想用一篇博客就結束併發編程基礎的，但是寫起來才發現想多了，一是想把每個知識點都說的清楚一點，並給出各種例子來幫助大家更好的理解，二是併發編程基礎的知識點確實挺多的，所以還是分兩篇博客來吧。

併發編程基礎（上）

什麼是線程

線程的三種創建方式與區別

線程的狀態

線程通知與等待

wait

notify

notifyAll

join

電子科技大學計算機科學與技術就讀體驗

Golang爬蟲代理接入的技術與實踐

大白話布隆過濾器

劍指Spring源碼（三）俯瞰Spring的Bean的生命週期（大衆版）

ThreadLocal源碼解析，內存泄露以及傳遞性

併發編程基礎（下）

併發編程基礎（上）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結