通常程序會被編寫為一個順序執行并完成一個獨立任務的代碼。如果沒有特別的需求，最好總是這樣寫代碼，因為這種類型的程序通常很容易寫，也很容易維護。不過也有一些情況下，并行執行多個任務會有更大的好處。一個例子是，Web 服務需要在各自獨立的套接字（socket）上同時接收多個數據請求。每個套接字請求都是獨立的，可以完全獨立于其他套接字進行處理。具有并行執行多個請求的能力可以顯著提高這類系統的性能。考慮到這一點，Go 語言的語法和運行時直接內置了對并發的支持。

1. 進程與線程

當運行一個應用程序的時候，操作系統會為這個應用程序啟動一個進程。可以將這個進程看作一個包含了應用程序在運行中需要用到和維護的各種資源的容器。這些資源包括但不限于內存地址空間、文件和設備的句柄以及線程。

一個線程是一個執行空間，這個空間會被 操作系統調度來運行函數中所寫的代碼。每個進程至少包含一個線程，每個進程的初始線程被稱作主線程。因為執行這個線程的空間是應用程序的本身的空間，所以當主線程終止時，應用程序也會終止。操作系統將線程調度到某個處理器上運行，這個處理器并不一定是進程所在的處理器。不同操作系統使用的線程調度算法一般都不一樣，但是這種不同會被 操作系統屏蔽，并不會展示給程序員。

2. goroutine原理

Go 語言里的并發指的是能讓某個函數獨立于其他函數運行的能力。操作系統會在物理處理器上調度線程來運行，而Go語言中當一個函數創建為goroutine時，Go 會將其視為一個獨立的工作單元，這個單元會被調度到可用的邏輯處理器上執行。每個邏輯處理器都分別綁定到單個操作系統線程。Go語言運行時默認會為每個可用的物理處理器分配一個邏輯處理器。

Go 語言運行時的調度器是一個復雜的軟件，能管理被創建的所有goroutine 并為其分配執行時間。這個調度器在操作系統之上，將操作系統的線程與運行時的邏輯處理器綁定，并在邏輯處理器上運行goroutine。調度器在任何給定的時間，都會全面控制哪個goroutine 要在哪個邏輯處理器上運行。

下圖中可以看到操作系統線程、邏輯處理器和本地運行隊列之間的關系。如果創建一個goroutine 并準備運行，這個goroutine 就會被放到調度器的全局運行隊列中。之后，調度器就將這些隊列中的goroutine 分配給一個邏輯處理器，并放到這個邏輯處理器對應的本地運行隊列中。本地運行隊列中的goroutine 會一直等待直到自己被分配的邏輯處理器執行。

有時，正在運行的goroutine 需要執行一個阻塞的系統調用，如打開一個文件。當這類調用發生時，線程和goroutine 會從邏輯處理器上分離，該線程會繼續阻塞，等待系統調用的返回。與此同時，這個邏輯處理器就失去了用來運行的線程。所以，調度器會創建一個新線程，并將其綁定到該邏輯處理器上。之后，邏輯處理器會從本地運行隊列里選擇另一個goroutine 來運行。一旦被阻塞的系統調用執行完成并返回，對應的goroutine 會放回到本地運行隊列，而之前的線程會保存好，以便之后可以繼續使用。

如果一個 goroutine 需要做一個網絡I/O 調用，流程上會有些不一樣。在這種情況下，goroutine會和邏輯處理器分離，并移到集成了網絡輪詢器的運行時。一旦該輪詢器指示某個網絡讀或者寫操作已經就緒，對應的goroutine 就會重新分配到邏輯處理器上來完成操作。調度器對可以創建的邏輯處理器的數量沒有限制，但語言運行時默認限制每個程序最多創建10 000 個線程。這個限制值可以通過調用runtime/debug 包的SetMaxThreads 方法來更改。如果程序試圖使用更多的線程，就會崩潰。

3. 并發與并行

并發（concurrency）不是并行（parallelism）。并行是讓不同的代碼片段同時在不同的物理處理器上執行。并行的關鍵是同時做很多事情，而并發是指同時管理很多事情，這些事情可能只做了一半就被暫停去做別的事情了。在很多情況下，并發的效果比并行好，因為操作系統和硬件的總資源一般很少，但能支持系統同時做很多事情。這種“使用較少的資源做更多的事情”的哲學，也是指導Go 語言設計的哲學。

如果希望讓goroutine 并行，必須使用多于一個邏輯處理器。當有多個邏輯處理器時，調度器會將goroutine 平等分配到每個邏輯處理器上。這會讓goroutine 在不同的線程上運行。不過要想真的實現并行的效果，用戶需要讓自己的程序運行在有多個物理處理器的機器上。否則，哪怕Go 語言運行時使用多個線程，goroutine 依然會在同一個物理處理器上并發運行，達不到并行的效果。

下圖展示了在一個邏輯處理器上并發運行goroutine 和在兩個邏輯處理器上并行運行兩個并發的goroutine 之間的區別。調度器包含一些聰明的算法，這些算法會隨著Go 語言的發布被更新和改進，所以不推薦盲目修改語言運行時對邏輯處理器的默認設置。如果真的認為修改邏輯處理器的數量可以改進性能，也可以對語言運行時的參數進行細微調整。

3.1 在1個邏輯處理器上運行Go程序

下面的代碼通過調用runtime 包的GOMAXPROCS 函數，更改調度器只可以使用1個邏輯處理器。創建兩個goroutine，以并發的形式分別顯示大寫和小寫的英文字母：

package main
import (
	"fmt"
	"runtime"
	"sync"
)
func main() {
	runtime.GOMAXPROCS(1) // 分配一個邏輯處理器給調度器使用
	var wg sync.WaitGroup
	wg.Add(2)
	fmt.Println("Start Goroutines")
	go func() {
		defer wg.Done()
		for count := 0; count < 3; count++ {
			for char := 'a'; char < 'a'+26; char++ {
				fmt.Printf("%c ", char)
			}
		}
	}()
	go func() {
		defer wg.Done()
		for count := 0; count < 3; count++ {
			for char := 'A'; char < 'A'+26; char++ {
				fmt.Printf("%c ", char)
			}
		}
	}()
	fmt.Println("Waiting To Finish")
	wg.Wait()
	fmt.Println("\nTerminating Program")
}

程序的輸出為：

Start Goroutines
Waiting To Finish
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z A B C
D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z a b c d e f g h i j k l m n
o p q r s t u v w x y z a b c d e f g h i j k l m n o p q r s t u v w x y z?
Terminating Program

使用1個邏輯處理器，在同一個時刻實際只有一個線程在運行，而且每個goroutine花費的時間太短，并沒有發生goroutine的停止與重新調度，所以通過程序輸出可以看出每個goroutine在一個邏輯處理器上并發運行的效果，他們看起來是順序執行的。

3.2 goroutine的停止與重新調度

基于調度器的內部算法，一個正運行的goroutine 在工作結束前，可以被停止并重新調度。調度器這樣做的目的是防止某個goroutine 長時間占用邏輯處理器。當goroutine 占用時間過長時，調度器會停止當前正運行的goroutine，并給其他可運行的goroutine 運行的機會。

下圖從邏輯處理器的角度展示了這一場景。在第1 步，調度器開始運行goroutine A，而goroutine B 在運行隊列里等待調度。之后，在第2 步，調度器交換了goroutine A 和goroutine B。由于goroutine A 并沒有完成工作，因此被放回到運行隊列。之后，在第3 步，goroutine B 完成了它的工作并被系統銷毀。這也讓goroutine A 繼續之前的工作。

下面的代碼中，同樣設置只使用1個邏輯處理器，程序創建了兩個goroutine，分別打印1~5000 內的素數。查找并顯示素數會消耗不少時間，這會讓調度器有機會在第一個goroutine 找到所有素數之前，切換該goroutine的時間片：

package main
import (
	"fmt"
	"runtime"
	"sync"
)
var wg sync.WaitGroup
func main() {
	runtime.GOMAXPROCS(1) // 分配一個邏輯處理器給調度器使用
	wg.Add(2)
	// 創建兩個goroutine
	fmt.Println("Create Goroutines")
	go printPrime("A")
	go printPrime("B")
	fmt.Println("Waiting To Finish")
	wg.Wait()
	fmt.Println("Terminating Program")
}
// 顯示 5000 以內的素數值
func printPrime(prefix string) {
	defer wg.Done()
next:
	for outer := 2; outer < 5000; outer++ {
		for inner := 2; inner < outer; inner++ {
			if outer%inner == 0 {
				continue next
			}
		}
		fmt.Printf("%s:%d\n", prefix, outer)
	}
	fmt.Println("Completed", prefix)
}

程序的輸出為：

Create Goroutines
Waiting To Finish
B:2
B:3
...
B:4583
B:4591
A:3 ** 切換 goroutine
A:5
...
A:4561
A:4567
B:4603 ** 切換 goroutine
B:4621
...
Completed B
A:4457 ** 切換 goroutine
A:4463
...
A:4993
A:4999
Completed A
Terminating Program

goroutine B 先顯示素數。goroutine B 打印到素數4591后，調度器就將正運行的goroutine切換為goroutine A。之后goroutine A 在線程上執行了一段時間，再次切換為goroutine B。這次goroutine B 完成了所有的工作。一旦goroutine B 返回，就會看到線程再次切換到goroutine A 并完成所有的工作。每次運行這個程序，調度器切換的時間點都會稍微有些不同。

3.3 在多個邏輯處理器上運行Go程序

如果給調度器分配多個邏輯處理器，我們會看到之前的示例程序的輸出行為會有些不同。下面的代碼中把邏輯處理器的數量改為2，讓我們看看打印英文字母的效果：

package main
import (
	"fmt"
	"runtime"
	"sync"
)
func main() {
	runtime.GOMAXPROCS(2) // 分配2個邏輯處理器給調度器使用
	var wg sync.WaitGroup
	wg.Add(2)
	fmt.Println("Start Goroutines")
	go func() {
		defer wg.Done()
		// 顯示小寫字母表3 次
		for count := 0; count < 3; count++ {
			for char := 'a'; char < 'a'+26; char++ {
				fmt.Printf("%c ", char)
			}
		}
	}()
	go func() {
		defer wg.Done()
		// 顯示大寫字母表3 次
		for count := 0; count < 3; count++ {
			for char := 'A'; char < 'A'+26; char++ {
				fmt.Printf("%c ", char)
			}
		}
	}()
	fmt.Println("Waiting To Finish")
	wg.Wait()
	fmt.Println("\nTerminating Program")
}

程序輸出為：

Start Goroutines
Waiting To Finish
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z A B C D E F G H I J K L M N O P Q R S a b c d e f g h i j k l m?
n o p q r s t u v w x y z a b c d e f g h i j k l m n o p q r s t u v w x y z a b c d e f g h i j k l m n o p q r s t u v w x y z T U?
V W X Y Z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z?
Terminating Program

兩個goroutine 幾乎是同時開始運行的，大小寫字母是混合在一起顯示的。所以每個goroutine 獨自運行在自己的線程上。