文章目錄

Go語言中的併發編程

併發是編程裏面一個非常重要的概念，Go語言在語言層面天生支持併發，這也是Go語言流行的一個很重要的原因。

Go語言中的併發編程

併發與並行

併發：同一時間段，利用單個CPU快速來回切換執行多個任務。

並行：同一時刻，利用多個CPU並行執行多個任務。

Go語言的併發通過goroutine實現。goroutine類似於線程，屬於用戶態的線程，我們可以根據需要創建成千上萬個goroutine併發工作。goroutine是由Go語言的運行時（runtime）調度完成，而線程是由操作系統調度完成。

Go語言還提供channel在多個goroutine間進行通信。goroutine和channel是 Go 語言秉承的 CSP（Communicating Sequential Process）併發模式的重要實現基礎。

goroutine

在java/c++中我們要實現併發編程的時候，我們通常需要自己維護一個線程池，並且需要自己去包裝一個又一個的任務，同時需要自己去調度線程執行任務並維護上下文切換，這一切通常會耗費程序員大量的心智。那麼能不能有一種機制，程序員只需要定義很多個任務，讓系統去幫助我們把這些任務分配到CPU上實現併發執行呢？

Go語言中的goroutine就是這樣一種機制，goroutine的概念類似於線程，但 goroutine是由Go的運行時（runtime）調度和管理的。Go程序會智能地將 goroutine 中的任務合理地分配給每個CPU。Go語言之所以被稱爲現代化的編程語言，就是因爲它在語言層面已經內置了調度和上下文切換的機制。

在Go語言編程中你不需要去自己寫進程、線程、協程，你的技能包裏只有一個技能–goroutine，當你需要讓某個任務併發執行的時候，你只需要把這個任務包裝成一個函數，開啓一個goroutine去執行這個函數就可以了，就是這麼簡單粗暴。

| 使用goroutine

Go語言中使用goroutine非常簡單，只需要在調用函數的時候在前面加上go關鍵字，就可以爲一個函數創建一個goroutine。

一個goroutine必定對應一個函數，可以創建多個goroutine去執行相同的函數。

| 啓動單個goroutine

啓動goroutine的方式非常簡單，只需要在調用的函數（普通函數和匿名函數）前面加上一個go關鍵字。

func hello() {
	fmt.Println("Hello Goroutine!")
}
func main() {
	hello()
	fmt.Println("main goroutine done!")
}

這個示例中hello函數和下面的語句是串行的，執行的結果是打印完Hello Goroutine!後打印main goroutine done!。

接下來我們在調用hello函數前面加上關鍵字go，也就是啓動一個goroutine去執行hello這個函數。

func main() {
	go hello() // 啓動另外一個goroutine去執行hello函數
	fmt.Println("main goroutine done!")
}

這一次的執行結果只打印了main goroutine done!，並沒有打印Hello Goroutine!。爲什麼呢？

在程序啓動時，Go程序就會爲main()函數創建一個默認的goroutine。

當main()函數返回的時候該goroutine就結束了，所有在main()函數中啓動的goroutine會一同結束，main函數所在的goroutine就像是權利的遊戲中的夜王，其他的goroutine都是異鬼，夜王一死它轉化的那些異鬼也就全部GG了。

所以我們要想辦法讓main函數等一等hello函數，最簡單粗暴的方式就是time.Sleep了。

func main() {
	go hello() // 啓動另外一個goroutine去執行hello函數
	fmt.Println("main goroutine done!")
	time.Sleep(time.Second)
}

執行上面的代碼你會發現，這一次先打印main goroutine done!，然後緊接着打印Hello Goroutine!。

首先爲什麼會先打印main goroutine done!是因爲我們在創建新的goroutine的時候需要花費一些時間，而此時main函數所在的goroutine是繼續執行的。

| 啓動多個goroutine

在Go語言中實現併發就是這樣簡單，我們還可以啓動多個goroutine。讓我們再來一個例子：（這裏使用了sync.WaitGroup來實現goroutine的同步）

var wg sync.WaitGroup

func hello(i int) {
	defer wg.Done() // goroutine結束就登記-1
	fmt.Println("Hello Goroutine!", i)
}
func main() {

	for i := 0; i < 10; i++ {
		wg.Add(1) // 啓動一個goroutine就登記+1
		go hello(i)
	}
	wg.Wait() // 等待所有登記的goroutine都結束
}

多次執行上面的代碼，會發現每次打印的數字的順序都不一致。這是因爲10個goroutine是併發執行的，而goroutine的調度是隨機的。

goroutine與線程

| 可增長的棧

OS線程（操作系統線程）一般都有固定的棧內存（通常爲2MB）,一個goroutine的棧在其生命週期開始時只有很小的棧（典型情況下2KB），goroutine的棧不是固定的，他可以按需增大和縮小，goroutine的棧大小限制可以達到1GB，雖然極少會用到這個大。所以在Go語言中一次創建十萬左右的goroutine也是可以的。

| goroutine調度

GPM是Go語言運行時（runtime）層面的實現，是go語言自己實現的一套調度系統。區別於操作系統調度OS線程。

G很好理解，就是個goroutine的，裏面除了存放本goroutine信息外還有與所在P的綁定等信息。
P管理着一組goroutine隊列，P裏面會存儲當前goroutine運行的上下文環境（函數指針，堆棧地址及地址邊界），P會對自己管理的goroutine隊列做一些調度（比如把佔用CPU時間較長的goroutine暫停、運行後續的goroutine等等）當自己的隊列消費完了就去全局隊列裏取，如果全局隊列裏也消費完了會去其他P的隊列裏搶任務。
M（machine）是Go運行時（runtime）對操作系統內核線程的虛擬， M與內核線程一般是一一映射的關係，一個groutine最終是要放到M上執行的；

P與M一般也是一一對應的。他們關係是： P管理着一組G掛載在M上運行。當一個G長久阻塞在一個M上時，runtime會新建一個M，阻塞G所在的P會把其他的G 掛載在新建的M上。當舊的G阻塞完成或者認爲其已經死掉時回收舊的M。

P的個數是通過runtime.GOMAXPROCS設定（最大256），Go1.5版本之後默認爲物理線程數。在併發量大的時候會增加一些P和M，但不會太多，切換太頻繁的話得不償失。

單從線程調度講，Go語言相比起其他語言的優勢在於OS線程是由OS內核來調度的，goroutine則是由Go運行時（runtime）自己的調度器調度的，這個調度器使用一個稱爲m:n調度的技術（複用/調度m個goroutine到n個OS線程）。其一大特點是goroutine的調度是在用戶態下完成的，不涉及內核態與用戶態之間的頻繁切換，包括內存的分配與釋放，都是在用戶態維護着一塊大的內存池，不直接調用系統的malloc函數（除非內存池需要改變），成本比調度OS線程低很多。另一方面充分利用了多核的硬件資源，近似的把若干goroutine均分在物理線程上，再加上本身goroutine的超輕量，以上種種保證了go調度方面的性能。

更多內容點擊：深入Golang調度器之GMP模型

| GOMAXPROCS調度

Go運行時的調度器使用GOMAXPROCS參數來確定需要使用多少個OS線程來同時執行Go代碼。默認值是機器上的CPU核心數。例如在一個8核心的機器上，調度器會把Go代碼同時調度到8個OS線程上（GOMAXPROCS是m:n調度中的n）。

Go語言中可以通過runtime.GOMAXPROCS()函數設置當前程序併發時佔用的CPU邏輯核心數。

Go1.5版本之前，默認使用的是單核心執行。Go1.5版本之後，默認使用全部的CPU邏輯核心數。

我們可以通過將任務分配到不同的CPU邏輯核心上實現並行的效果，這裏舉個例子：

func a() {
	for i := 1; i < 10; i++ {
		fmt.Println("A:", i)
	}
}

func b() {
	for i := 1; i < 10; i++ {
		fmt.Println("B:", i)
	}
}

func main() {
	runtime.GOMAXPROCS(1)
	go a()
	go b()
	time.Sleep(time.Second)
}

兩個任務只有一個邏輯核心，此時是做完一個任務再做另一個任務。將邏輯核心數設爲2，此時兩個任務並行執行，代碼如下。

func a() {
	for i := 1; i < 10; i++ {
		fmt.Println("A:", i)
	}
}

func b() {
	for i := 1; i < 10; i++ {
		fmt.Println("B:", i)
	}
}

func main() {
	runtime.GOMAXPROCS(2)
	go a()
	go b()
	time.Sleep(time.Second)
}

Go語言中的操作系統線程和goroutine的關係：

一個操作系統線程對應用戶態多個goroutine。
go程序可以同時使用多個操作系統線程。
goroutine和OS線程是多對多的關係，即m:n。

channel

單純地將函數併發執行是沒有意義的。函數與函數間需要交換數據才能體現併發執行函數的意義。

雖然可以使用共享內存進行數據交換，但是共享內存在不同的goroutine中容易發生競態問題。爲了保證數據交換的正確性，必須使用互斥量對內存進行加鎖，這種做法勢必造成性能問題。

Go語言的併發模型是CSP（Communicating Sequential Processes），提倡 通過通信共享內存 而不是 通過共享內存而實現通信 。

如果說goroutine是Go程序併發的執行體，channel就是它們之間的連接。channel是可以讓一個goroutine發送特定值到另一個goroutine的通信機制。

Go 語言中的通道（channel）是一種特殊的類型。通道像一個傳送帶或者隊列，總是遵循先入先出（First In First Out）的規則，保證收發數據的順序。每一個通道都是一個具體類型的導管，也就是聲明channel的時候需要爲其指定元素類型。

| channel類型

channel是一種類型，一種引用類型。聲明通道類型的格式如下：

var 變量 chan 元素類型

舉幾個例子：

var ch1 chan int   // 聲明一個傳遞整型的通道
var ch2 chan bool  // 聲明一個傳遞布爾型的通道
var ch3 chan []int // 聲明一個傳遞int切片的通道

| 創建channel

通道是引用類型，通道類型的空值是nil。

var ch chan int
fmt.Println(ch) // <nil>

聲明的通道後需要使用make函數初始化之後才能使用。

創建channel的格式如下：

make(chan 元素類型, [緩衝大小])

channel的緩衝大小是可選的。

舉幾個例子：

ch4 := make(chan int)
ch5 := make(chan bool)
ch6 := make(chan []int)

| channel操作

通道有發送（send）、接收(receive）和關閉（close）三種操作。

發送和接收都使用<-符號。

現在我們先使用以下語句定義一個通道：

ch := make(chan int)

發送

將一個值發送到通道中。

ch <- 10 // 把10發送到ch中

接收

從一個通道中接收值。

x := <- ch // 從ch中接收值並賦值給變量x
<-ch       // 從ch中接收值，忽略結果

關閉

我們通過調用內置的close函數來關閉通道。

close(ch)

關於關閉通道需要注意的事情是，只有在通知接收方goroutine所有的數據都發送完畢的時候才需要關閉通道。通道是可以被垃圾回收機制回收的，它和關閉文件是不一樣的，在結束操作之後關閉文件是必須要做的，但關閉通道不是必須的。

關閉後的通道有以下特點：

對一個關閉的通道再發送值就會導致panic。
對一個關閉的通道進行接收會一直獲取值直到通道爲空。
對一個關閉的並且沒有值的通道執行接收操作會得到對應類型的零值。
關閉一個已經關閉的通道會導致panic。

| 無緩衝的通道

無緩衝的通道又稱爲阻塞的通道。我們來看一下下面的代碼：

func main() {
	ch := make(chan int)
	ch <- 10
	fmt.Println("發送成功")
}

上面這段代碼能夠通過編譯，但是執行的時候會出現以下錯誤：

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.main()
        .../src/github.com/Q1mi/studygo/day06/channel02/main.go:8 +0x54

爲什麼會出現deadlock錯誤呢？

因爲我們使用ch := make(chan int)創建的是無緩衝的通道，無緩衝的通道只有在有人接收值的時候才能發送值。就像你住的小區沒有快遞櫃和代收點，快遞員給你打電話必須要把這個物品送到你的手中，簡單來說就是無緩衝的通道必須有接收才能發送。

上面的代碼會阻塞在ch <- 10這一行代碼形成死鎖，那如何解決這個問題呢？

一種方法是啓用一個goroutine去接收值，例如：

func recv(c chan int) {
	ret := <-c
	fmt.Println("接收成功", ret)
}
func main() {
	ch := make(chan int)
	go recv(ch) // 啓用goroutine從通道接收值
	ch <- 10
	fmt.Println("發送成功")
}

無緩衝通道上的發送操作會阻塞，直到另一個goroutine在該通道上執行接收操作，這時值才能發送成功，兩個goroutine將繼續執行。相反，如果接收操作先執行，接收方的goroutine將阻塞，直到另一個goroutine在該通道上發送一個值。

使用無緩衝通道進行通信將導致發送和接收的goroutine同步化。因此，無緩衝通道也被稱爲同步通道。

| 有緩衝的通道

解決上面問題的方法還有一種就是使用有緩衝區的通道。我們可以在使用make函數初始化通道的時候爲其指定通道的容量，例如：

func main() {
	ch := make(chan int, 1) // 創建一個容量爲1的有緩衝區通道
	ch <- 10
	fmt.Println("發送成功")
}

只要通道的容量大於零，那麼該通道就是有緩衝的通道，通道的容量表示通道中能存放元素的數量。就像你小區的快遞櫃只有那麼個多格子，格子滿了就裝不下了，就阻塞了，等到別人取走一個快遞員就能往裏面放一個。

我們可以使用內置的len函數獲取通道內元素的數量，使用cap函數獲取通道的容量，雖然我們很少會這麼做。

| for range從通道循環取值

當向通道中發送完數據時，我們可以通過close函數來關閉通道。

當通道被關閉時，再往該通道發送值會引發panic，從該通道取值的操作會先取完通道中的值，再然後取到的值一直都是對應類型的零值。那如何判斷一個通道是否被關閉了呢？

我們來看下面這個例子：

// channel 練習
func main() {
	ch1 := make(chan int)
	ch2 := make(chan int)
	// 開啓goroutine將0~100的數發送到ch1中
	go func() {
		for i := 0; i < 100; i++ {
			ch1 <- i
		}
		close(ch1)
	}()
	// 開啓goroutine從ch1中接收值，並將該值的平方發送到ch2中
	go func() {
		for {
			i, ok := <-ch1 // 通道關閉後再取值ok=false
			if !ok {
				break
			}
			ch2 <- i * i
		}
		close(ch2)
	}()
	// 在主goroutine中從ch2中接收值打印
	for i := range ch2 { // 通道關閉後會退出for range循環
		fmt.Println(i)
	}
}

從上面的例子中我們看到有兩種方式在接收值的時候判斷該通道是否被關閉，不過我們通常使用的是for range的方式。使用for range遍歷通道，當通道被關閉的時候就會退出for range。

| 單向通道

有的時候我們會將通道作爲參數在多個任務函數間傳遞，很多時候我們在不同的任務函數中使用通道都會對其進行限制，比如限制通道在函數中只能發送或只能接收。

Go語言中提供了 單向通道 來處理這種情況。例如，我們把上面的例子改造如下：

func counter(out chan<- int) {
	for i := 0; i < 100; i++ {
		out <- i
	}
	close(out)
}

func squarer(out chan<- int, in <-chan int) {
	for i := range in {
		out <- i * i
	}
	close(out)
}
func printer(in <-chan int) {
	for i := range in {
		fmt.Println(i)
	}
}

func main() {
	ch1 := make(chan int)
	ch2 := make(chan int)
	go counter(ch1)
	go squarer(ch2, ch1)
	printer(ch2)
}

其中，

chan<- int是一個只寫單向通道（只能對其寫入int類型值），可以對其執行發送操作但是不能執行接收操作；
<-chan int是一個只讀單向通道（只能從其讀取int類型值），可以對其執行接收操作但是不能執行發送操作。
在函數傳參及任何賦值操作中可以將雙向通道轉換爲單向通道，但反過來是不可以的。

| 通道總結

channel常見的異常總結，如下圖：

關閉已經關閉的channel也會引發panic。

worker pool（goroutine池）

在工作中我們通常會使用可以指定啓動的goroutine數量–worker pool模式，控制goroutine的數量，防止goroutine泄漏和暴漲。

一個簡易的work pool示例代碼如下：

func worker(id int, jobs <-chan int, results chan<- int) {
	for j := range jobs {
		fmt.Printf("worker:%d start job:%d\n", id, j)
		time.Sleep(time.Second)
		fmt.Printf("worker:%d end job:%d\n", id, j)
		results <- j * 2
	}
}


func main() {
	jobs := make(chan int, 100)
	results := make(chan int, 100)
	// 開啓3個goroutine
	for w := 1; w <= 3; w++ {
		go worker(w, jobs, results)
	}
	// 5個任務
	for j := 1; j <= 5; j++ {
		jobs <- j
	}
	close(jobs)
	// 輸出結果
	for a := 1; a <= 5; a++ {
		<-results
	}
}

select多路複用

在某些場景下我們需要同時從多個通道接收數據。通道在接收數據時，如果沒有數據可以接收將會發生阻塞。你也許會寫出如下代碼使用遍歷的方式來實現：

for{
    // 嘗試從ch1接收值
    data, ok := <-ch1
    // 嘗試從ch2接收值
    data, ok := <-ch2
    …
}

這種方式雖然可以實現從多個通道接收值的需求，但是運行性能會差很多。爲了應對這種場景，Go內置了select關鍵字，可以同時響應多個通道的操作。

select的使用類似於switch語句，它有一系列case分支和一個默認的分支。每個case會對應一個通道的通信（接收或發送）過程。select會一直等待，直到某個case的通信操作完成時，就會執行case分支對應的語句。具體格式如下：

select{
    case <-ch1:
        ...
    case data := <-ch2:
        ...
    case ch3<-data:
        ...
    default:
        默認操作
}

舉個小例子來演示下select的使用：

func main() {
	ch := make(chan int, 1)
	for i := 0; i < 10; i++ {
		select {
		case x := <-ch:
			fmt.Println(x)
		case ch <- i:
		}
	}
}

使用select語句能提高代碼的可讀性。

可處理一個或多個channel的發送/接收操作。
如果多個case同時滿足，select會隨機選擇一個。
對於沒有case的select{}會一直等待，可用於阻塞main函數。

【對比python】

進程

運行中的程序就是一個進程，所有的進程都是通過它的父進程來創建的。因此，運行起來的python程序也是一個進程，那麼我們也可以在程序中再創建進程。

multiprocess不是一個模塊而是python中一個操作、管理進程的包。之所以叫multi是取自multiple的多功能的意思，在這個包中幾乎包含了和進程有關的所有子模塊。由於提供的子模塊非常多，爲了方便大家歸類記憶，我將這部分大致分爲四個部分：

創建進程部分
進程同步部分
進程池部分
進程之間數據共享

創建進程部分： multiprocess.process模塊

process模塊是一個創建進程的模塊，藉助這個模塊，就可以完成進程的創建。

Process(group , target , name , args , kwargs)，
# 由該類實例化得到的對象，表示一個子進程中的任務（尚未啓動）

參數介紹：

group參數未使用，值始終爲None
target表示調用對象，即子進程要執行的任務
args表示調用對象的位置參數元組，args=(1,2,'kkk',)
kwargs表示調用對象的字典,kwargs={'name':'kkk','age':18}
name爲子進程的名稱

強調：
1.需要使用關鍵字的方式來指定參數
2.args指定的爲傳給target函數的位置參數，是一個元組形式，必須有逗號

# 開進程的方法一
import time
import random
from multiprocessing import Process


def piao(name):
    print('%s piaoing' % name)
    time.sleep(random.randrange(1, 5))
    print('%s piao end' % name)


if __name__ == '__main__':
    p1 = Process(target=piao, args=('kkk',))  # 必須加,號
    p2 = Process(target=piao, args=('ttt',))
    p3 = Process(target=piao, args=('aaa',))
    p4 = Process(target=piao, args=('bbb',))

    p1.start()
    p2.start()
    p3.start()
    p4.start()
    print('主線程')

# 開進程的方法二:
import time
import random
from multiprocessing import Process


class Piao(Process):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print('%s piaoing' % self.name)

        time.sleep(random.randrange(1, 5))
        print('%s piao end' % self.name)


if __name__ == '__main__':
    p1 = Piao('ttt')
    p2 = Piao('aaa')
    p3 = Piao('bbb')
    p4 = Piao('ccc')
    p1.start()  # start會自動調用run
    p2.start()
    p3.start()
    p4.start()
    print('主線程')

方法介紹

p.start()：啓動進程，並調用該子進程中的p.run()
p.run():進程啓動時運行的方法，正是它去調用target指定的函數，我們自定義類的類中一定要實現該方法
p.terminate():強制終止進程p，不會進行任何清理操作，如果p創建了子進程，該子進程就成了殭屍進程，使用該方法需要特別小心這種情況。如果p還保存了一個鎖那麼也將不會被釋放，進而導致死鎖
p.is_alive():如果p仍然運行，返回True
p.join([timeout]):主線程等待p終止（強調：是主線程處於等的狀態，而p是處於運行的狀態）。timeout是可選的超時時間，需要強調的是，p.join只能join住start開啓的進程，而不能join住run開啓的進程

屬性介紹

p.daemon：默認值爲False，如果設爲True，代表p爲後臺運行的守護進程，當p的父進程終止時，p也隨之終止，並且設定爲True後，p不能創建自己的新進程，必須在p.start()之前設置
p.name:進程的名稱
p.pid：進程的pid
p.exitcode:進程在運行時爲None、如果爲–N，表示被信號N結束(瞭解即可)
p.authkey:進程的身份驗證鍵,默認是由os.urandom()隨機生成的32字符的字符串。這個鍵的用途是爲涉及網絡連接的底層進程間通信提供安全性，這類連接只有在具有相同的身份驗證鍵時才能成功（瞭解即可）

強調: 在Windows操作系統中由於沒有fork(linux操作系統中創建進程的機制)，在創建子進程的時候會自動 import 啓動它的這個文件，而在 import 的時候又執行了整個文件。因此如果將process()直接寫在文件中就會無限遞歸創建子進程報錯。所以必須把創建子進程的部分使用if _name_ ==‘__main__’ 判斷保護起來，import 的時候，就不會遞歸運行了。

進程間數據隔離

進程隔離是爲保護操作系統中進程互不干擾而設計的一組不同硬件和軟件的技術這個技術是爲了避免進程A寫入進程B的情況發生。進程的隔離實現，使用了虛擬地址空間。進程A的虛擬地址和進程B的虛擬地址不同，這樣就防止進程A將數據信息寫入進程B。進程隔離的安全性通過禁止進程間內存的訪問可以方便實現。

未完待續。。。

Go語言全棧開發：併發（上）

文章目錄

Go語言中的併發編程

[轉帖]使用NMT和pmap解決JVM資源泄漏問題原創

Python實現大麥網搶票的四大關鍵技術點解析

Python 安裝庫指令大全

salesforce零基礎學習（一百三十八）零碎知識點小總結（十）

一款開源的.NET程序集反編譯、編輯和調試神器

關於接口協議，你必須要知道這些！

2020年上半年數據庫系統工程師考試

基於 Milvus + LlamaIndex 實現高級 RAG

【2024-05-21】以茶會友

Flask開發：初識Flask

Go語言全棧開發：基本數據類型

RabbitMQ在python開發中的應用

Go語言全棧開發：流程控制

Go語言全棧開發：切片

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

linux以太網驅動總結