程序與執行緒的概念

• 在傳統的作業系統中，程式並不能獨立執行，作為資源分配和獨立執行的基本單位都是程序。

在未配置 OS 的系統中，程式的執行方式是順序執行，即必須在一個程式執行完後，才允許另一個程式執行；在多道程式環境下，則允許多個程式併發執行。程式的這兩種執行方式間有著顯著的不同。也正是程式併發執行時的這種特徵，才導致了在作業系統中引入程序的概念。

自從在 20 世紀 60 年代人們提出了程序的概念後，在 OS 中一直都是以程序作為能擁有資源和獨立執行的基本單位的。直到 20 世紀 80 年代中期，人們又提出了比程序更小的能獨立執行的基本單位——執行緒（Threads），試圖用它來提高系統內程式併發執行的程度，從而可進一步提高系統的吞吐量。特別是在進入 20 世紀 90 年代後，多處理機系統得到迅速發展，執行緒能比程序更好地提高程式的並行執行程度，充分地發揮多處理機的優越性，因而在近幾年所推出的多處理機 OS 中也都引入了執行緒，以改善 OS 的效能。

—–以上摘自《計算機作業系統（第三版）》湯小丹等編著。

• 下圖是來自某知乎使用者的解釋：

通過上述可以大致瞭解，執行緒和程序是幹什麼的了，那麼我們下邊給程序和執行緒總結一下概念：

程序（Process）

計算機中的程式關於某資料集合上的一次執行活動，是系統進行資源分配和排程的基本單位，是作業系統結構的基礎。在早期面向程序設計的計算機結構中，程序是程式的基本執行實體；在當代面向執行緒設計的計算機結構中，程序是執行緒的容器。程式是指令、資料及其組織形式的描述，程序是程式的實體。

執行緒

有時被稱為輕量級程序（Lightweight Process，LWP），是程式執行流的最小單元。執行緒是程式中一個單一的順序控制流程。程序內一個相對獨立的、可排程的執行單元，是系統獨立排程和分派 CPU 的基本單位指執行中的程式的排程單位。在單個程式中同時執行多個執行緒完成不同的工作，稱為多執行緒。

程序和執行緒的關係

執行緒和程序各自有什麼區別和優劣

1. 程序是資源分配的最小單位，執行緒是程式執行的最小單位。

2. 程序有自己的獨立地址空間，每啟動一個程序，系統就會為它分配地址空間，建立資料表來維護程式碼段、堆疊段和資料段，這種操作非常昂貴。而執行緒是共享程序中的資料的，使用相同的地址空間，因此 CPU 切換一個執行緒的花費遠比程序要小很多，同時建立一個執行緒的開銷也比程序要小很多，執行緒的上下文切換的效能消耗要小於程序。

3. 執行緒之間的通訊更方便，同一程序下的執行緒共享全域性變數、靜態變數等資料，而程序之間的通訊需要以通訊的方式（IPC）進行。不過如何處理好同步與互斥是編寫多執行緒程式的難點。

4. 但是多程序程式更健壯，多執行緒程式只要有一個執行緒死掉，整個程序也死掉了，而一個程序死掉並不會對另外一個程序造成影響，因為程序有自己獨立的地址空間。

同步與非同步

對於一次方法的呼叫來說，同步方法呼叫一旦開始，就必須等待該方法的呼叫返回，後續的方法才可以繼續執行；非同步的話，方法呼叫一旦開始，就可以立即返回，呼叫者可以執行後續的方法，這裡的非同步方法通常會在另一個執行緒裡真實的執行，而不會妨礙當前執行緒的執行。

並行與併發

併發和並行是兩個相對容易比較混淆的概念。他都可以表示在同一時間範圍內有兩個或多個任務同時在執行，但其在任務排程的時候還是有區別的，首先看下圖：

併發任務執行過程：

並行任務執行過程：

從上圖中可以看到，兩個任務在執行的時候，併發是沒有時間上的重疊的，兩個任務是交替執行的，由於切換的非常快，對於外界呼叫者來說相當於同一時刻多個任務一起執行了；而並行可以看到時間上是由重疊的，也就是說並行才是真正意義上的同一時刻可以有多個任務同時執行。

Java 實現多執行緒方式

1、繼承 Thread，重寫 run() 方法：

public class MyThread extends Thread {

    @Override
    public void run() {
        while (true) {
            System.out.println(this.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); //執行緒啟動的正確方式
    }
}

輸出結果：

Thread-0
Thread-0
Thread-0
...

另外，要明白啟動執行緒的是 start() 方法而不是 run() 方法，如果用 run() 方法，那麼他就是一個普通的方法執行了，也就是隻是會執行一次，這也是一個常見的筆試面試題哦！

2、實現 Runable 介面：

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("123");
    }

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable, "t1");
        thread.start();
    }
}

這裡Thread和Runnable的關係是這樣的：Thread 類本身實現了 Runnable 介面，並且持有 run 方法，但 Thread 類的 run 方法主體是空的，Thread 類的 run 方法通常是由子類的 run 方法重寫，詳細定義如下：

Runable 介面的定義：

public interface Runnable {
    public abstract void run();
}

Thread 類的定義：

public class Thread implements Runnable {
}

執行緒安全

執行緒安全概念：當多個執行緒訪問某一個類（物件或方法）時，這個類始終能表現出正確的行為，那麼這個類（物件或方法）就是執行緒安全的。

執行緒安全就是多執行緒訪問時，採用了加鎖機制，當一個執行緒訪問該類的某個資料時，進行保護，其他執行緒不能進行訪問，直到該執行緒讀取完，釋放了鎖，其他執行緒才可使用。這樣的話就不會出現資料不一致或者資料被汙染的情況。 執行緒不安全就是不提供資料訪問保護，有可能出現多個執行緒先後更改資料以至於所得到的資料是髒資料。這裡的加鎖機制常見的如：Synchronized

Synchronized 修飾符

1、Synchronized：可以在任意物件及方法上加鎖，而加鎖的這段程式碼稱為互斥區或臨界區。

2、不使用 Synchronized 例項（程式碼 A）：

public class MyThread extends Thread {

    private int count = 5;

    @Override
    public void run() {
        count--;
        System.out.println(this.currentThread().getName() + " count:" + count);
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread1 = new Thread(myThread, "thread1");
        Thread thread2 = new Thread(myThread, "thread2");
        Thread thread3 = new Thread(myThread, "thread3");
        Thread thread4 = new Thread(myThread, "thread4");
        Thread thread5 = new Thread(myThread, "thread5");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
    }
}

輸出的一種結果如下：

thread3 count:2
thread4 count:1
thread1 count:2
thread2 count:3
thread5 count:0

可以看到，上述的結果是不正確的，這是因為，多個執行緒同時操作run()方法，對 count 進行修改，進而造成錯誤。

3、使用 Synchronized 例項（程式碼 B）：

public class MyThread extends Thread {

    private int count = 5;

    @Override
    public synchronized void run() {
        count--;
        System.out.println(this.currentThread().getName() + " count:" + count);
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread thread1 = new Thread(myThread, "thread1");
        Thread thread2 = new Thread(myThread, "thread2");
        Thread thread3 = new Thread(myThread, "thread3");
        Thread thread4 = new Thread(myThread, "thread4");
        Thread thread5 = new Thread(myThread, "thread5");
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
    }
}

輸出結果：

thread1 count:4
thread2 count:3
thread3 count:2
thread5 count:1
thread4 count:0

可以看出程式碼 A 和程式碼 B 的區別就是在run()方法上加上了 Synchronized 修飾。

說明如下：

當多個執行緒訪問 MyThread 的 run 方法的時候，如果使用了 Synchronized 修飾，那個多執行緒就會以排隊的方式進行處理（這裡排隊是按照 CPU 分配的先後順序而定的），一個執行緒想要執行 Synchronized 修飾的方法裡的程式碼，首先是嘗試獲得鎖，如果拿到鎖，執行 Synchronized 程式碼體的內容，如果拿不到鎖的話，這個執行緒就會不斷的嘗試獲得這把鎖，直到拿到為止，而且多個執行緒同時去競爭這把鎖，也就是會出現鎖競爭的問題。

一個物件有一把鎖，多個執行緒多個鎖！

何為，一個物件一把鎖，多個執行緒多個鎖！首先看一下下邊的例項程式碼（程式碼 C）：

public class MultiThread {

    private int num = 200;

    public synchronized void printNum(String threadName, String tag) {
        if (tag.equals("a")) {
            num = num - 100;
            System.out.println(threadName + " tag a,set num over!");
        } else {
            num = num - 200;
            System.out.println(threadName + " tag b,set num over!");
        }
        System.out.println(threadName + " tag " + tag + ", num = " + num);
    }

    public static void main(String[] args) throws InterruptedException {
        final MultiThread multiThread1 = new MultiThread();
        final MultiThread multiThread2 = new MultiThread();

        new Thread(new Runnable() {
            public void run() {
                multiThread1.printNum("thread1", "a");
            }
        }).start()

        new Thread(new Runnable() {
            public void run() {
                multiThread2.printNum("thread2", "b");
            }
        }).start();
    }
}

輸出結果：

thread1 tag a,set num over!
thread1 tag a, num = 100
thread2 tag b,set num over!
thread2 tag b, num = 0

可以看出，有兩個物件：multiThread1和multiThread2，如果多個物件使用同一把鎖的話，那麼上述執行的結果就應該是：thread2 tag b, num = -100，因此，是每一個物件擁有該物件的鎖的。

關鍵字synchronized取得的鎖都是物件鎖，而不是把一段程式碼或方法當做鎖，所以上述例項程式碼 C 中哪個執行緒先執行synchronized 關鍵字的方法，那個執行緒就持有該方法所屬物件的鎖，兩個物件，執行緒獲得的就是兩個不同物件的不同的鎖，他們互不影響的。

那麼，我們在正常的場景的時候，肯定是有一種情況的就是，所有的物件會對一個變數 count 進行操作，那麼如何實現哪？很簡單就是加 static，我們知道，用 static 修改的方法或者變數，在該類的所有物件是具有相同的引用的，這樣的話，無論例項化多少物件，呼叫的都是一個方法，程式碼如下（程式碼 D）：

public class MultiThread {

    private static int num = 200;

    public static synchronized void printNum(String threadName, String tag) {
        if (tag.equals("a")) {
            num = num - 100;
            System.out.println(threadName + " tag a,set num over!");
        } else {
            num = num - 200;
            System.out.println(threadName + " tag b,set num over!");
        }
        System.out.println(threadName + " tag " + tag + ", num = " + num);
    }

    public static void main(String[] args) throws InterruptedException {
        final MultiThread multiThread1 = new MultiThread();
        final MultiThread multiThread2 = new MultiThread();

        new Thread(new Runnable() {
            public void run() {
                multiThread1.printNum("thread1", "a");
            }
        }).start();

        new Thread(new Runnable() {
            public void run() {
                multiThread2.printNum("thread2", "b");
            }
        }).start();
    }
}

輸出結果：

thread1 tag a,set num over!
thread1 tag a, num = 100
thread2 tag b,set num over!
thread2 tag b, num = -100

可以看出，對變數和方法都加上了 static 修飾，就可以實現我們所需要的場景。同時也說明了，對於非靜態 static 修飾的方法或變數，是一個物件一把鎖的

物件鎖的同步和非同步

• 同步：Synchronized

同步的概念就是共享，我們要知道“共享”這兩個字，如果不是共享的資源，就沒有必要進行同步，也就是沒有必要進行加鎖。

同步的目的就是為了執行緒的安全，其實對於執行緒的安全，需要滿足兩個最基本的特性：原子性和可見性。

• 非同步：Synchronized

非同步的概念就是獨立，相互之間不受到任何制約，兩者之間沒有任何關係，這裡的非同步可以理解為多個執行緒之間不會競爭共享資源。

• 示例程式碼：

  public class MyObject {

  public void method() {
      System.out.println(Thread.currentThread().getName());
  }
  
  public static void main(String[] args) {
      final MyObject myObject = new MyObject();

  Thread t1 = new Thread(new Runnable() { public void run() { myObject.method(); } }, "t1"); Thread t2 = new Thread(new Runnable() { public void run() { myObject.method(); } }, "t2"); t1.start(); t2.start(); 

  }

  }

上述程式碼中method()就是非同步的方法。一方面，他不會出現對共享變數的修改，另一方面，無需保證訪問該方法的執行緒安全性。

Synchronized 應用

注意：

我們通常情況下使用的大多數框架 SSM、以及常見的多執行緒任務排程框架、大資料框架等，其中都大量的使用了Synchronized 這個最簡單的實現多執行緒同步的關鍵字，後續文章也會以我們常用的框架為基礎，介紹其中使用的到的多執行緒技術，但不會詳細的介紹其實現的原理，多會以截圖的形式展示出來，這裡只是讓大家認識到，不是多執行緒技術沒有用，而是很多的框架都給我們在底層遮蔽掉了這些內容。
對於一個滿足於碼農世界的程式設計師來說，熟練的使用各種框架提供給我們的服務就基本可以了，但是如果想了解框架內部的實現原理，首先，多執行緒的學習就是我們首要的任務，這也是本次達人課的重點。關於框架內部使用到多執行緒技術的更多細節問題希望讀者能借此專題的學習，自己把原始碼下載下來研究一下。

1、MyBatis 中的使用：

MyBatis 中對於資料庫連線池的處理，我們肯定都知道是一個需要保證執行緒安全的東西，上圖中就大致展示了 MyBatis 中我們常用的兩種資料來源物件：PooledDataSource 和 UnpooledDataSource。根據上述顯示的部分方法可以看出都是用到了簡單的 Synchronized 關鍵字。

//請求資料庫連線的次數
protected long requestCount = 0; 

public synchronized long getRequestCount() {
    return requestCount;
}

上述是獲取連線中請求的數量，因為在不同時刻，請求的數量可能會發生變化，但是在對這個requestCount進行訪問的時候，要加鎖，以保證在訪問這個方法的時候，不會被其他執行緒修改，可以看出就是我們平常簡單的使用。

//請求資料庫連線的次數
protected long requestCount = 0;
//獲取連線的累積時間
protected long accumulatedRequestTime = 0; 

public synchronized long getAverageRequestTime() {
    return requestCount == 0 ? 0 : accumulatedRequestTime / requestCount;
}

上述程式碼，展示了獲取請求的平均時間。

protected void pushConnection(PooledConnection conn) throws SQLException {

    synchronized (state) { //同步
        //從activeConnections集合中移除該PooledConnection物件
        state.activeConnections.remove(conn);
        if (conn.isValid()) { //檢測PooledConnection物件是否有效
            //檢測空閒連線數是否以達到上限，以及PooledConnection是否為該連線池的連線
            if (state.idleConnections.size() < poolMaximumIdleConnections && conn.getConnectionTypeCode() == expectedConnectionTypeCode) {
                state.accumulatedCheckoutTime += conn.getCheckoutTime(); //累積checkout時長
                if (!conn.getRealConnection().getAutoCommit()) { //回滾提交事務
                    conn.getRealConnection().rollback();
                }
                //為返還連線建立新的PooledConnection物件，然後新增到idleConnections集合中
                PooledConnection newConn = new PooledConnection(conn.getRealConnection(), this);
                state.idleConnections.add(newConn);
                newConn.setCreatedTimestamp(conn.getCreatedTimestamp());
                newConn.setLastUsedTimestamp(conn.getLastUsedTimestamp());
                conn.invalidate(); //將原PooledConnection物件設定為無效
                if (log.isDebugEnabled()) {
                    log.debug("Returned connection " + newConn.getRealHashCode() + " to pool.");
                }
                state.notifyAll();
            } else { //空閒連線數以達到上限或PooledConnection物件並不屬於該連線池
                state.accumulatedCheckoutTime += conn.getCheckoutTime(); //累積checkout時長
                if (!conn.getRealConnection().getAutoCommit()) {
                    conn.getRealConnection().rollback();
                }
                conn.getRealConnection().close(); //關閉真正的資料庫連線
                if (log.isDebugEnabled()) {
                    log.debug("Closed connection " + conn.getRealHashCode() + ".");
                }
                conn.invalidate();
            }
        } else {
            if (log.isDebugEnabled()) {
                log.debug("A bad connection (" + conn.getRealHashCode() + ") attempted to return to the pool, discarding connection.");
            }
            state.badConnectionCount++;
        }
    }
}

既然是資料庫連線池，肯定是需要把用完的連線扔到連線池中去，上述程式碼就是 MyBatis 中使用完的連線重新新增到連線池的過程，其中使用 synchronized 對 state 進行了同步操作，state 表示當前資料庫的一個連線的狀態。

上述的程式碼，看不懂不要緊，不是本課程的重點，但是我們應該很清楚的認識到，多執行緒實實在在使用到了。同樣，如果我們面試的時候遇到了讓我們手寫資料庫連線池的時候，我們應該也要考慮到多執行緒的情況下如何保證資料的正確性。