本文講介紹以下幾個內(nèi)容：

引入用GoLang語言寫的幾個case；

介紹什么是閉包；

介紹什么是閉包的延遲綁定；

從閉包的延遲綁定講到GoLang的Go Routine的延遲綁定問題；

I. 幾個有趣的Case

開門見山，首先請各位看官們先看下面foo1()到foo7()一共7個函數(shù)，然后回答后面的問題。（一下子丟出7個函數(shù)，請見諒。不過，每個函數(shù)都非常簡短，而本文接下來將圍繞這7個函數(shù)展開，因此，請各位看官老爺們耐心且看看題，活動活動腦細胞~）

case 1：

func foo1(x *int) func() {  return func() {    *x = *x + 1    fmt.Printf("foo1 val = %d
", *x)  }}

case 2：

func foo2(x int) func() {  return func() {    x = x + 1    fmt.Printf("foo2 val = %d
", x)  }}

case 3：

func foo3() {  values := []int{1, 2, 3, 5}  for _, val := range values {    fmt.Printf("foo3 val = %d
", val)  }}

case 4：

func show(v interface{}) {  fmt.Printf("foo4 val = %v
", v)}func foo4() {  values := []int{1, 2, 3, 5}  for _, val := range values {    go show(val)  }}

case 5：

func foo5() {  values := []int{1, 2, 3, 5}  for _, val := range values {    go func() {      fmt.Printf("foo5 val = %v
", val)    }()  }}

case 6：

var foo6Chan = make(chan int, 10)func foo6() {  for val := range foo6Chan {    go func() {      fmt.Printf("foo6 val = %d
", val)    }()  }}

case 7：

func foo7(x int) []func() {  var fs []func()  values := []int{1, 2, 3, 5}  for _, val := range values {    fs = append(fs, func() {      fmt.Printf("foo7 val = %d
", x+val)    })  }  return fs}

Q1：

第一組實驗：假設(shè)現(xiàn)在有變量x=133，并創(chuàng)建變量f1和f2分別為foo1(&x)和foo2(x)的返回值，請問多次調(diào)用f1()和f2()會打印什么？

第二組實驗：重新賦值變量x=233，請問此時多次調(diào)用f1()和f2()會打印什么？

第三組實驗：如果直接調(diào)用foo1(&x)()和foo2(x)()多次，請問每次都會打印什么？

Q2：
請問分別調(diào)用函數(shù)foo3()，foo4()和foo5()，分別會打印什么？

Q3：

第一組實驗：如果“幾乎同時”往channelfoo6Chan里面塞入一組數(shù)據(jù)"1,2,3,5"，foo6會打印什么？

第二組實驗：如果以間隔納秒（10^-9秒）的時間往channel里面塞入一組數(shù)據(jù)，此時foo6又會打印什么？

第三組實驗：如果是微秒（10^-6秒）呢？如果是毫秒（10^-3秒）呢？如果是秒呢？

Q4：
請問如果創(chuàng)建變量f7s=foo7(11)，f7s是一個函數(shù)集合，遍歷f7s會打印什么？

接下來，我們逐一來看這些問題和對應(yīng)的foo函數(shù)。

II. case1~2：值傳遞（by value） vs. 引用傳遞（by reference）

子標(biāo)題好難起 >0<... ? 看到case1和case2的兩組函數(shù)foo1()和foo2()，相信各位看官就知道，其中一個知識點就是值傳遞和引用傳遞。 ? 其實呢，Go是沒有引用傳遞的，即使是foo1()在參數(shù)上加了*，內(nèi)部實現(xiàn)機制仍舊是值傳遞，只不過傳遞的是指針的數(shù)值。但是為了稱呼方便，下文會成為“引用傳遞”（為了區(qū)分正確的引用傳遞，這里特意加了引號）。 ? 如下圖所示，我們的目的是傳遞X變量，于是我們創(chuàng)建了一個傳參地址（臨時地址變量），它存放了X變量的地址值，調(diào)用函數(shù)的時候給它這個傳參地址，函數(shù)呢，則會再創(chuàng)建一個入?yún)⒌刂罚莻鲄⒌刂返囊环菘截?。函?shù)拿到了這個地址值，可以通過尋址拿到這個X變量，此時函數(shù)如果直接修改X變量可以認為是“本地修改”或者“永久修改”了這個變量的數(shù)值。 ? 「舉個生活中的例子，比如一個叫做“函數(shù)”的人想尋找一個叫做“X”的人，函數(shù)跑過來問知道X的我，我拿出地址簿，給他出示了X這個人的家庭地址，函數(shù)記性不太好，所以拿了一本本子把X的地址抄在了他自己的本子上?！?? 這個例子中，我的那個記著X的家庭地址的地址簿，就是傳參地址；函數(shù)抄錄了X地址的本子，就是入?yún)⒌刂?；X的家庭地址，就對應(yīng)了X變量的地址值。（哎，為什么講的這么細節(jié)了？） ? Golang的“引用傳遞” ? 話題似乎有點扯遠了，拉回來，我們再來看看foo1()和foo2()。 ? foo1()和foo2()的區(qū)別確實在于值傳遞和引用傳遞，但是這個并不是本文介紹的中心。本文要介紹的已經(jīng)在標(biāo)題上寫明了：閉包（closure）。 ?

閉包（closure）

什么是閉包呢？摘用Wikipedia上的一句定義：

aclosureis a record storinga functiontogether withan environment.
閉包是由函數(shù)和與其相關(guān)的引用環(huán)境組合而成的實體 。

因此閉包的核心就是：函數(shù)和環(huán)境。其實這里就已經(jīng)可以回答本文題目的問題：閉包究竟包了什么？答案是：函數(shù)和環(huán)境。但是相信部分看官們到這里依然不清楚：什么函數(shù)？什么環(huán)境？ 函數(shù)，指的是在閉包實際實現(xiàn)的時候，往往通過調(diào)用一個外部函數(shù)返回其內(nèi)部函數(shù)來實現(xiàn)的。內(nèi)部函數(shù)可能是內(nèi)部實名函數(shù)、匿名函數(shù)或者一段lambda表達式。用戶得到一個閉包，也等同于得到了這個內(nèi)部函數(shù)，每次執(zhí)行這個閉包就等同于執(zhí)行內(nèi)部函數(shù)。 環(huán)境，Wikipedia上說是與其（函數(shù)）相關(guān)的引用環(huán)境，可以說解釋地很精準(zhǔn)了。 具體地說，在實際中引用環(huán)境是指外部函數(shù)的環(huán)境，閉包保存/記錄了它產(chǎn)生時的外部函數(shù)的所有環(huán)境。但是這段話對于尚未理解閉包的同學(xué)來說依舊是不友好的，聽完還是懵懂的。這里嘗試做個更實用性的解釋：

如果外部函數(shù)的所有變量可見性都是local的，即生命周期在外部函數(shù)結(jié)束時也結(jié)束的，那么閉包的環(huán)境也是封閉的。

反之，那么閉包其實不再封閉，全局可見的變量的修改，也會對閉包內(nèi)的這個變量造成影響。

跳回foo1()和foo2()的例子，正好來解釋閉包的函數(shù)和環(huán)境。

func foo1(x *int) func() {    return func() {        *x = *x + 1        fmt.Printf("foo1 val = %d
", *x)    }}func foo2(x int) func() {    return func() {        x = x + 1        fmt.Printf("foo1 val = %d
", x)    }}
// Q1第一組實驗x := 133f1 := foo1(&x)f2 := foo2(x)f1() f2()f1()f2()// Q1第二組x = 233f1()f2()f1()f2()// Q1第三組foo1(&x)()foo2(x)()foo1(&x)()foo2(x)()

定義了x=133之后，我們獲取得到了f1=foo1(&x)和f2=foo2(x)。這里f1f2就是閉包的函數(shù)，也就是foo1()foo2()的內(nèi)部匿名函數(shù)；而閉包的環(huán)境即外部函數(shù)foo1()foo2()的變量x（因為內(nèi)部匿名函數(shù)引用到的相關(guān)變量只有x，因此這里簡化為變量x）。 閉包的函數(shù)做的事情歸納為：1). 將環(huán)境的變量x自增1；2). 打印環(huán)境變量x。 閉包的環(huán)境則是其外部函數(shù)獲取到的變量x。 因此Q1第一組實驗的答案為：

f1() // foo1 val = 134f2() // foo2 val = 134f1() // foo1 val = 135f2() // foo2 val = 135

這是因為閉包f1f2都保存了x=133時的整個環(huán)境，每次調(diào)用閉包f1f2都會執(zhí)行一次自增+打印的內(nèi)部匿名函數(shù)。因此第一次輸出都是(133+1=)134，第二次輸出都是(134+1=)135。 那么Q1第二組實驗的答案呢？

f1() // foo1 val = 234f2() // foo2 val = 136f1() // foo1 val = 235f2() // foo2 val = 137

有趣的事情發(fā)生了！f1的值居然發(fā)生了顯著性的變化！通過這組實驗，能夠更好地解釋其（函數(shù)）相關(guān)的引用環(huán)境其實就是產(chǎn)生這個閉包的時候的外部函數(shù)的環(huán)境，因此變量x的可見性和作用域也與外部函數(shù)相同，又因為foo1是“引用傳遞”，變量x的作用域不局限在foo1()中，因此當(dāng)x發(fā)生變化的時候，閉包f1內(nèi)部也變化了。這個也正好是"反之，那么閉包其實不再封閉，全局可見的變量的修改，也會對閉包內(nèi)的這個變量造成影響"的證明。 Q1的第三組實驗的答案：

foo1(&x)() // foo1 val = 236foo2(x)() // foo2 val = 237foo1(&x)() // foo1 val = 237foo2(x)() // foo2 val = 238foo2(x)() // foo2 val = 238

因為foo1()返回的閉包都會修改變量x的數(shù)值，因此調(diào)用foo1()()之后，變量x必然增加1。而foo2()返回的閉包僅僅修改其內(nèi)部環(huán)境的變量x而對調(diào)用外部的變量x不影響，且每次調(diào)用foo2()返回的閉包是獨立的，和其他調(diào)用foo2()的閉包不相關(guān)，因此最后兩次的調(diào)用，打印的數(shù)值都是相同的；第一次調(diào)用和第二次調(diào)用foo2()發(fā)現(xiàn)打印出來的數(shù)值增加了1，是因為兩次調(diào)用之間傳入的x的數(shù)值分別是236和237，而不是說第二次在第一次基礎(chǔ)上增加了1，這點需要補充說明。

III. case7：閉包的延遲綁定

hhh，是不是以為我會接著講case3，居然先提到了case7，意不意外驚不驚喜！ 廢話不多說，看官們來瞅瞅下面調(diào)用f7()的時候分別會打印什么？

func foo7(x int) []func() {    var fs []func()    values := []int{1, 2, 3, 5}    for _, val := range values {        fs = append(fs, func() {            fmt.Printf("foo7 val = %d
", x+val)        })    }    return fs}// Q4實驗：f7s := foo7(11)for _, f7 := range f7s {    f7()}

答案是：

foo7 val = 16foo7 val = 16foo7 val = 16foo7 val = 16

是的，你沒有看錯，會打印4行，且都是16！是不是很驚喜！ 相信已經(jīng)有很多同學(xué)在網(wǎng)上看到過類似的case，并且也早已知道結(jié)果了，不清楚的同學(xué)們現(xiàn)在也看到答案了。嗯，這就是大名鼎鼎的閉包延遲綁定問題。網(wǎng)上的解釋其實有很多了，這里嘗試用之前對于閉包的環(huán)境的定義來解釋這個現(xiàn)象： “ 閉包是一段函數(shù)和相關(guān)的引用環(huán)境的實體。case7的問題中，函數(shù)是打印變量val的值，引用環(huán)境是變量val。僅僅是這樣的話，遍歷到val=1的時候，記錄的不應(yīng)該是val=1的環(huán)境嗎？ 上文在閉包解釋最后，還有一句話：閉包保存/記錄了它產(chǎn)生時的外部函數(shù)的所有環(huán)境。如同普通變量/函數(shù)的定義和實際賦值/調(diào)用或者說執(zhí)行，是兩個階段。閉包也是一樣，for-loop內(nèi)部僅僅是聲明了一個閉包，foo7()返回的也僅僅是一段閉包的函數(shù)定義，只有在外部執(zhí)行了f7()時才真正執(zhí)行了閉包，此時才閉包內(nèi)部的變量才會進行賦值的操作。哎，如果這么說的話，豈不是應(yīng)該拋出異常嗎？因為val是一個比foo7()生命周期更短的變量??？ 這就是閉包的神奇之處，它會保存相關(guān)引用的環(huán)境，也就是說，val這個變量在閉包內(nèi)的生命周期得到了保證。因此在執(zhí)行這個閉包的時候，會去外部環(huán)境尋找最新的數(shù)值！你是不是不相信？來來來，我們馬上寫個臨時的case執(zhí)行下分分鐘就明白了：

臨時的case：

func foo0() func() {    x := 1    f := func() {        fmt.Printf("foo0 val = %d
", x)    }    x = 11    return f}
foo0()() // 猜猜我會輸出什么？

既然我說會在執(zhí)行的時候去外部環(huán)境尋找最新的數(shù)值，那x的最新數(shù)值就是11呀，果然，最后輸出的就是11。 以上就是我對于閉包的延遲綁定的通俗版本解釋。:)

IV. case3~6：Go Routine的延遲綁定

case3、case4和case5不是閉包，case3只是遍歷了內(nèi)部的slice并且打印，case4是在遍歷時通過協(xié)程調(diào)用了打印函數(shù)打印，case5也是在遍歷slice時調(diào)用了內(nèi)部匿名函數(shù)打印。 Q2的case3問題的答案先丟出來：

func foo3() {    values := []int{1, 2, 3, 5}    for _, val := range values {        fmt.Printf("foo3 val = %d
", val)    }}
foo3()//foo3 val = 1a//foo3 val = 2//foo3 val = 3//foo3 val = 5

中規(guī)中矩，遍歷輸出slice的內(nèi)容：1，2，3，5。 Q2的case4問題的答案再丟出來：

func show(v interface{}) {    fmt.Printf("foo4 val = %v
", v)}func foo4() {    values := []int{1, 2, 3, 5}    for _, val := range values {        go show(val)    }}
foo4()//foo3 val = 2//foo3 val = 3//foo3 val = 1//foo3 val = 5

嗯，因為Go Routine的執(zhí)行順序是隨機并行的，因此執(zhí)行多次foo4()輸出的順序不一行相同，但是一定打印了“1，2，3，5”各個元素。 最后是Q2的case5問題的答案：

func foo5() {    values := []int{1, 2, 3, 5}    for _, val := range values {        go func() {            fmt.Printf("foo5 val = %v
", val)        }()    }}
foo5()//foo3 val = 5//foo3 val = 5//foo3 val = 5//foo3 val = 5

居然都打印了5，驚不驚喜，意不意外？！相信看過子標(biāo)題的你，一定不意外了（捂臉）。是的，接下來就要講講Go Routine的延遲綁定： 其實這個問題的本質(zhì)同閉包的延遲綁定，或者說，這段匿名函數(shù)的對象就是閉包。在我們調(diào)用go func() { xxx }()的時候，只要沒有真正開始執(zhí)行這段代碼，那它還只是一段函數(shù)聲明。而在這段匿名函數(shù)被執(zhí)行的時候，才是內(nèi)部變量尋找真正賦值的時候。 在case5中，for-loop的遍歷幾乎是“瞬時”完成的，4個Go Routine真正被執(zhí)行在其后。矛盾是不是產(chǎn)生了？這個時候for-loop結(jié)束了呀，val生命周期早已結(jié)束了，程序應(yīng)該報錯才對呀？ 回憶上一章，是不是一個相同的情境？是的，這個匿名函數(shù)可不就是一個閉包嗎？一切就解釋通了：閉包真正被執(zhí)行的時候，for-loop結(jié)束了，但是val的生命周期在閉包內(nèi)部被延長了且被賦值到最新的數(shù)值5。 不知道各位看官是否好奇，既然說Go Routine執(zhí)行的時候比for-loop慢，那如果我在遍歷的時候增加sleep機制呢？于是設(shè)計了Q3實驗：

var foo6Chan = make(chan int, 10)func foo6() {    for val := range foo6Chan {        go func() {            fmt.Printf("foo6 val = %d
", val)        }()    }}// Q3第一組實驗go foo6()foo6Chan <- 1foo6Chan <- 2foo6Chan <- 3foo6Chan <- 5// Q3第二組實驗foo6Chan <- 11time.Sleep(time.Duration(1) * time.Nanosecond)foo6Chan <- 12time.Sleep(time.Duration(1) * time.Nanosecond)foo6Chan <- 13time.Sleep(time.Duration(1) * time.Nanosecond)foo6Chan <- 15// Q3第三組實驗// 微秒foo6Chan <- 21time.Sleep(time.Duration(1) * time.Microsecond)foo6Chan <- 22time.Sleep(time.Duration(1) * time.Microsecond)foo6Chan <- 23time.Sleep(time.Duration(1) * time.Microsecond)foo6Chan <- 25time.Sleep(time.Duration(10) * time.Second)// 毫秒foo6Chan <- 31time.Sleep(time.Duration(1) * time.Millisecond)foo6Chan <- 32time.Sleep(time.Duration(1) * time.Millisecond)foo6Chan <- 33time.Sleep(time.Duration(1) * time.Millisecond)foo6Chan <- 35time.Sleep(time.Duration(10) * time.Second)// 秒foo6Chan <- 41time.Sleep(time.Duration(1) * time.Second)foo6Chan <- 42time.Sleep(time.Duration(1) * time.Second)foo6Chan <- 43time.Sleep(time.Duration(1) * time.Second)foo6Chan <- 45time.Sleep(time.Duration(10) * time.Second)// 實驗完畢，最后記得關(guān)閉channelclose(foo6Chan)

嘗試執(zhí)行了多次，第一組答案如下：

foo6 val = 5/3foo6 val = 5foo6 val = 5foo6 val = 5

絕大部分時候執(zhí)行出來都是5。 第二組答案如下：

foo6 val = 15/13/11/12foo6 val = 15/13foo6 val = 15foo6 val = 15

絕大部分時候執(zhí)行得到的都是15。 第三組答案如下：

// 微秒foo6 val = 23/21foo6 val = 23/22foo6 val = 25/23foo6 val = 25// 毫秒foo6 val = 31foo6 val = 32foo6 val = 33foo6 val = 35// 秒foo6 val = 41foo6 val = 42foo6 val = 43foo6 val = 45

毫秒和秒的兩組非常確定，順序輸出。但是微妙就不一定了，有時候是順序輸出，大部分時候是隨機輸出如“22，22，23，25”或者“21，22，25，25”之類的。 可見，Go Routine的匿名函數(shù)從定義到執(zhí)行，耗時時間在微妙上下。于是又增加了一個臨時的case測試了其真正的耗時大約是多少。

又一個臨時的case：

func foo8() {    for i := 1; i < 10; i++ {        curTime := time.Now().UnixNano()        go func(t1 int64) {            t2 := time.Now().UnixNano()            fmt.Printf("foo8 ts = %d us 
", t2-t1)        }(curTime)    }}
foo8()

執(zhí)行下來發(fā)現(xiàn)耗時在5微秒~60微秒之間不等。 但是，以上的實驗數(shù)據(jù)都是從我的iMac本子上得到的，該本子的CPU是i7-7700K 4.2GHz；我又放在筆記本上（CPU為i5-8250U 1.6GHz 1.8GHz）運行了下，發(fā)現(xiàn)居然耗時是0微秒！起初我懷疑是時間精度的問題，于是把t1和t2時間都打印出來，精度是可以達到納秒的。抱著仍舊不信的想法，重新運行了第三組實驗，每一個都是順序輸出的！ 好吧，回頭再說我的iMac的問題?，F(xiàn)在只需要記住一點：Go Routine的匿名函數(shù)的延遲綁定本質(zhì)就是閉包，實際生成中注意下這種寫法~

寫在后面

最后，閉包是個常見的玩意兒，但是實際代碼中不太建議使用，一不小心寫了個內(nèi)存泄漏查都查不到。特別是不要為了炫技故意寫個閉包，實在沒有必要。