[轉]Go的50坑：新Golang開發者要註意的陷阱、技巧和常見錯誤-高級

阿新 • • 發佈：2017-08-25

inline pil ren todo ket blog 自定義 nec printf

from : https://levy.at/blog/11

進階篇

關閉HTTP的響應

level: intermediate

當你使用標準http庫發起請求時，你得到一個http的響應變量。如果你不讀取響應主體，你依舊需要關閉它。註意對於空的響應你也一定要這麽做。對於新的Go開發者而言，這個很容易就會忘掉。

一些新的Go開發者確實嘗試關閉響應主體，但他們在錯誤的地方做。

package main

import (  
    "fmt"
    "net/http"
    "io/ioutil"
)

func main() {  
    resp, err := http.Get("https://api.ipify.org?format=json")
    defer resp.Body.Close()//not ok
    if err != nil {
        fmt.Println(err)
        return
    }

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(string(body))
}

這段代碼對於成功的請求沒問題，但如果http的請求失敗， resp變量可能會是 nil，這將導致一個runtime panic。

最常見的關閉響應主體的方法是在http響應的錯誤檢查後調用 defer。

package main

import (  
    "fmt"
    "net/http"
    "io/ioutil"
)

func main() {  
    resp, err := http.Get("https://api.ipify.org?format=json")
    if err != nil {
        fmt.Println(err)
        return
    }

    defer resp.Body.Close()//ok, most of the time :-)
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(string(body))
}

大多數情況下，當你的http響應失敗時， resp變量將為 nil，而 err變量將是 non-nil。然而，當你得到一個重定向的錯誤時，兩個變量都將是 non-nil。這意味著你最後依然會內存泄露。

通過在http響應錯誤處理中添加一個關閉 non-nil響應主體的的調用來修復這個問題。另一個方法是使用一個 defer調用來關閉所有失敗和成功的請求的響應主體。

package main

import (  
    "fmt"
    "net/http"
    "io/ioutil"
)

func main() {  
    resp, err := http.Get("https://api.ipify.org?format=json")
    if resp != nil {
        defer resp.Body.Close()
    }

    if err != nil {
        fmt.Println(err)
        return
    }

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(string(body))
}

resp.Body.Close()的原始實現也會讀取並丟棄剩余的響應主體數據。這確保了http的鏈接在keepalive http連接行為開啟的情況下，可以被另一個請求復用。最新的http客戶端的行為是不同的。現在讀取並丟棄剩余的響應數據是你的職責。如果你不這麽做，http的連接可能會關閉，而無法被重用。這個小技巧應該會寫在Go 1.5的文檔中。

如果http連接的重用對你的應用很重要，你可能需要在響應處理邏輯的後面添加像下面的代碼：

_, err = io.Copy(ioutil.Discard, resp.Body)

如果你不立即讀取整個響應將是必要的，這可能在你處理json API響應時會發生：

json.NewDecoder(resp.Body).Decode(&data)

關閉HTTP的連接

level: intermediate

一些HTTP服務器保持會保持一段時間的網絡連接（根據HTTP 1.1的說明和服務器端的“keep-alive”配置）。默認情況下，標準http庫只在目標HTTP服務器要求關閉時才會關閉網絡連接。這意味著你的應用在某些條件下消耗完sockets/file的描述符。

你可以通過設置請求變量中的 Close域的值為 true，來讓http庫在請求完成時關閉連接。

另一個選項是添加一個 Connection的請求頭，並設置為 close。目標HTTP服務器應該也會響應一個 Connection: close的頭。當http庫看到這個響應頭時，它也將會關閉連接。

package main

import (  
    "fmt"
    "net/http"
    "io/ioutil"
)

func main() {  
    req, err := http.NewRequest("GET","http://golang.org",nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    req.Close = true
    //or do this:
    //req.Header.Add("Connection", "close")

    resp, err := http.DefaultClient.Do(req)
    if resp != nil {
        defer resp.Body.Close()
    }

    if err != nil {
        fmt.Println(err)
        return
    }

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(len(string(body)))
}

你也可以取消http的全局連接復用。你將需要為此創建一個自定義的http傳輸配置。

package main

import (  
    "fmt"
    "net/http"
    "io/ioutil"
)

func main() {  
    tr := &http.Transport{DisableKeepAlives: true}
    client := &http.Client{Transport: tr}

    resp, err := client.Get("http://golang.org")
    if resp != nil {
        defer resp.Body.Close()
    }

    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(resp.StatusCode)

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(len(string(body)))
}

如果你向同一個HTTP服務器發送大量的請求，那麽把保持網絡連接的打開是沒問題的。然而，如果你的應用在短時間內向大量不同的HTTP服務器發送一兩個請求，那麽在引用收到響應後立刻關閉網絡連接是一個好主意。增加打開文件的限制數可能也是個好主意。當然，正確的選擇源自於應用。

比較Structs, Arrays, Slices, and Maps

level: intermediate

如果結構體中的各個元素都可以用你可以使用等號來比較的話，那就可以使用相號, ==，來比較結構體變量。

package main

import "fmt"

type data struct {  
    num int
    fp float32
    complex complex64
    str string
    char rune
    yes bool
    events <-chan string
    handler interface{}
    ref *byte
    raw [10]byte
}

func main() {  
    v1 := data{}
    v2 := data{}
    fmt.Println("v1 == v2:",v1 == v2) //prints: v1 == v2: true
}

如果結構體中的元素無法比較，那使用等號將導致編譯錯誤。註意數組僅在它們的數據元素可比較的情況下才可以比較。

package main

import "fmt"

type data struct {  
    num int                //ok
    checks [10]func() bool //not comparable
    doit func() bool       //not comparable
    m map[string] string   //not comparable
    bytes []byte           //not comparable
}

func main() {  
    v1 := data{}
    v2 := data{}
    fmt.Println("v1 == v2:",v1 == v2)
}

Go確實提供了一些助手函數，用於比較那些無法使用等號比較的變量。

最常用的方法是使用 reflect包中的 DeepEqual()函數。

package main

import (  
    "fmt"
    "reflect"
)

type data struct {  
    num int                //ok
    checks [10]func() bool //not comparable
    doit func() bool       //not comparable
    m map[string] string   //not comparable
    bytes []byte           //not comparable
}

func main() {  
    v1 := data{}
    v2 := data{}
    fmt.Println("v1 == v2:",reflect.DeepEqual(v1,v2)) //prints: v1 == v2: true

    m1 := map[string]string{"one": "a","two": "b"}
    m2 := map[string]string{"two": "b", "one": "a"}
    fmt.Println("m1 == m2:",reflect.DeepEqual(m1, m2)) //prints: m1 == m2: true

    s1 := []int{1, 2, 3}
    s2 := []int{1, 2, 3}
    fmt.Println("s1 == s2:",reflect.DeepEqual(s1, s2)) //prints: s1 == s2: true
}

除了很慢（這個可能會也可能不會影響你的應用）， DeepEqual()也有其他自身的技巧。

package main

import (  
    "fmt"
    "reflect"
)

func main() {  
    var b1 []byte = nil
    b2 := []byte{}
    fmt.Println("b1 == b2:",reflect.DeepEqual(b1, b2)) //prints: b1 == b2: false
}

DeepEqual()不會認為空的slice與“nil”的slice相等。這個行為與你使用 bytes.Equal()函數的行為不同。 bytes.Equal()認為“nil”和空的slice是相等的。

package main

import (  
    "fmt"
    "bytes"
)

func main() {  
    var b1 []byte = nil
    b2 := []byte{}
    fmt.Println("b1 == b2:",bytes.Equal(b1, b2)) //prints: b1 == b2: true
}

DeepEqual()在比較slice時並不總是完美的。

package main

import (  
    "fmt"
    "reflect"
    "encoding/json"
)

func main() {  
    var str string = "one"
    var in interface{} = "one"
    fmt.Println("str == in:",str == in,reflect.DeepEqual(str, in))
    //prints: str == in: true true

    v1 := []string{"one","two"}
    v2 := []interface{}{"one","two"}
    fmt.Println("v1 == v2:",reflect.DeepEqual(v1, v2))
    //prints: v1 == v2: false (not ok)

    data := map[string]interface{}{
        "code": 200,
        "value": []string{"one","two"},
    }
    encoded, _ := json.Marshal(data)
    var decoded map[string]interface{}
    json.Unmarshal(encoded, &decoded)
    fmt.Println("data == decoded:",reflect.DeepEqual(data, decoded))
    //prints: data == decoded: false (not ok)
}

如果你的byte slice（或者字符串）中包含文字數據，而當你要不區分大小寫形式的值時（在使用 ==， bytes.Equal()，或者 bytes.Compare()），你可能會嘗試使用“bytes”和“string”包中的 ToUpper()或者 ToLower()函數。對於英語文本，這麽做是沒問題的，但對於許多其他的語言來說就不行了。這時應該使用 strings.EqualFold()和 bytes.EqualFold()。

如果你的byte slice中包含需要驗證用戶數據的隱私信息（比如，加密哈希、tokens等），不要使用 reflect.DeepEqual()、 bytes.Equal()，或者 bytes.Compare()，因為這些函數將會讓你的應用易於被定時攻擊。為了避免泄露時間信息，使用 ‘crypto/subtle‘包中的函數（即， subtle.ConstantTimeCompare()）。

從Panic中恢復

level: intermediate

recover()函數可以用於獲取/攔截panic。僅當在一個defer函數中被完成時，調用 recover()將會完成這個小技巧。

Incorrect:

ackage main

import "fmt"

func main() {  
    recover() //doesn‘t do anything
    panic("not good")
    recover() //won‘t be executed :)
    fmt.Println("ok")
}

Works:

package main

import "fmt"

func main() {  
    defer func() {
        fmt.Println("recovered:",recover())
    }()

    panic("not good")
}

recover()的調用僅當它在defer函數中被直接調用時才有效。

Fails:

package main

import "fmt"

func doRecover() {  
    fmt.Println("recovered =>",recover()) //prints: recovered => <nil>
}

func main() {  
    defer func() {
        doRecover() //panic is not recovered
    }()

    panic("not good")
}

在Slice, Array, and Map "range"語句中更新引用元素的值

level: intermediate

在“range”語句中生成的數據的值是真實集合元素的拷貝。它們不是原有元素的引用。這意味著更新這些值將不會修改原來的數據。同時也意味著使用這些值的地址將不會得到原有數據的指針。

package main

import "fmt"

func main() {  
    data := []int{1,2,3}
    for _,v := range data {
        v *= 10 //original item is not changed
    }

    fmt.Println("data:",data) //prints data: [1 2 3]
}

如果你需要更新原有集合中的數據，使用索引操作符來獲得數據。

package main

import "fmt"

func main() {  
    data := []int{1,2,3}
    for i,_ := range data {
        data[i] *= 10
    }

    fmt.Println("data:",data) //prints data: [10 20 30]
}

如果你的集合保存的是指針，那規則會稍有不同。如果要更新原有記錄指向的數據，你依然需要使用索引操作，但你可以使用 for range語句中的第二個值來更新存儲在目標位置的數據。

package main

import "fmt"

func main() {  
    data := []*struct{num int} {{1},{2},{3}}

    for _,v := range data {
        v.num *= 10
    }

    fmt.Println(data[0],data[1],data[2]) //prints &{10} &{20} &{30}
}

在Slice中"隱藏"數據

level: intermediate

當你重新劃分一個slice時，新的slice將引用原有slice的數組。如果你忘了這個行為的話，在你的應用分配大量臨時的slice用於創建新的slice來引用原有數據的一小部分時，會導致難以預期的內存使用。

package main

import "fmt"

func get() []byte {  
    raw := make([]byte,10000)
    fmt.Println(len(raw),cap(raw),&raw[0]) //prints: 10000 10000 <byte_addr_x>
    return raw[:3]
}

func main() {  
    data := get()
    fmt.Println(len(data),cap(data),&data[0]) //prints: 3 10000 <byte_addr_x>
}

為了避免這個陷阱，你需要從臨時的slice中拷貝數據（而不是重新劃分slice）。

package main

import "fmt"

func get() []byte {  
    raw := make([]byte,10000)
    fmt.Println(len(raw),cap(raw),&raw[0]) //prints: 10000 10000 <byte_addr_x>
    res := make([]byte,3)
    copy(res,raw[:3])
    return res
}

func main() {  
    data := get()
    fmt.Println(len(data),cap(data),&data[0]) //prints: 3 3 <byte_addr_y>
}

Slice的數據“毀壞”

level: intermediate

比如說你需要重新一個路徑（在slice中保存）。你通過修改第一個文件夾的名字，然後把名字合並來創建新的路勁，來重新劃分指向各個文件夾的路徑。

package main

import (  
    "fmt"
    "bytes"
)

func main() {  
    path := []byte("AAAA/BBBBBBBBB")
    sepIndex := bytes.IndexByte(path,‘/‘)
    dir1 := path[:sepIndex]
    dir2 := path[sepIndex+1:]
    fmt.Println("dir1 =>",string(dir1)) //prints: dir1 => AAAA
    fmt.Println("dir2 =>",string(dir2)) //prints: dir2 => BBBBBBBBB

    dir1 = append(dir1,"suffix"...)
    path = bytes.Join([][]byte{dir1,dir2},[]byte{‘/‘})

    fmt.Println("dir1 =>",string(dir1)) //prints: dir1 => AAAAsuffix
    fmt.Println("dir2 =>",string(dir2)) //prints: dir2 => uffixBBBB (not ok)

    fmt.Println("new path =>",string(path))
}

結果與你想的不一樣。與"AAAAsuffix/BBBBBBBBB"相反，你將會得到"AAAAsuffix/uffixBBBB"。這個情況的發生是因為兩個文件夾的slice都潛在的引用了同一個原始的路徑slice。這意味著原始路徑也被修改了。根據你的應用，這也許會是個問題。

通過分配新的slice並拷貝需要的數據，你可以修復這個問題。另一個選擇是使用完整的slice表達式。

package main

import (  
    "fmt"
    "bytes"
)

func main() {  
    path := []byte("AAAA/BBBBBBBBB")
    sepIndex := bytes.IndexByte(path,‘/‘)
    dir1 := path[:sepIndex:sepIndex] //full slice expression
    dir2 := path[sepIndex+1:]
    fmt.Println("dir1 =>",string(dir1)) //prints: dir1 => AAAA
    fmt.Println("dir2 =>",string(dir2)) //prints: dir2 => BBBBBBBBB

    dir1 = append(dir1,"suffix"...)
    path = bytes.Join([][]byte{dir1,dir2},[]byte{‘/‘})

    fmt.Println("dir1 =>",string(dir1)) //prints: dir1 => AAAAsuffix
    fmt.Println("dir2 =>",string(dir2)) //prints: dir2 => BBBBBBBBB (ok now)

    fmt.Println("new path =>",string(path))
}

完整的slice表達式中的額外參數可以控制新的slice的容量。現在在那個slice後添加元素將會觸發一個新的buffer分配，而不是覆蓋第二個slice中的數據。

"走味的"Slices

level: intermediate

多個slice可以引用同一個數據。比如，當你從一個已有的slice創建一個新的slice時，這就會發生。如果你的應用功能需要這種行為，那麽你將需要關註下“走味的”slice。

在某些情況下，在一個slice中添加新的數據，在原有數組無法保持更多新的數據時，將導致分配一個新的數組。而現在其他的slice還指向老的數組（和老的數據）。

import "fmt"

func main() {  
    s1 := []int{1,2,3}
    fmt.Println(len(s1),cap(s1),s1) //prints 3 3 [1 2 3]

    s2 := s1[1:]
    fmt.Println(len(s2),cap(s2),s2) //prints 2 2 [2 3]

    for i := range s2 { s2[i] += 20 }

    //still referencing the same array
    fmt.Println(s1) //prints [1 22 23]
    fmt.Println(s2) //prints [22 23]

    s2 = append(s2,4)

    for i := range s2 { s2[i] += 10 }

    //s1 is now "stale"
    fmt.Println(s1) //prints [1 22 23]
    fmt.Println(s2) //prints [32 33 14]
}

類型聲明和方法

level: intermediate

當你通過把一個現有（非interface）的類型定義為一個新的類型時，新的類型不會繼承現有類型的方法。

Fails:

package main

import "sync"

type myMutex sync.Mutex

func main() {  
    var mtx myMutex
    mtx.Lock() //error
    mtx.Unlock() //error  
}

Compile Errors:

/tmp/sandbox106401185/main.go:9: mtx.Lock undefined (type myMutex has no field or method Lock) /tmp/sandbox106401185/main.go:10: mtx.Unlock undefined (type myMutex has no field or method Unlock)

如果你確實需要原有類型的方法，你可以定義一個新的struct類型，用匿名方式把原有類型嵌入其中。

Works:

package main

import "sync"

type myLocker struct {  
    sync.Mutex
}

func main() {  
    var lock myLocker
    lock.Lock() //ok
    lock.Unlock() //ok
}

interface類型的聲明也會保留它們的方法集合。

Works:

package main

import "sync"

type myLocker sync.Locker

func main() {  
    var lock myLocker = new(sync.Mutex)
    lock.Lock() //ok
    lock.Unlock() //ok
}

從"for switch"和"for select"代碼塊中跳出

level: intermediate

沒有標簽的“break”聲明只能從內部的switch/select代碼塊中跳出來。如果無法使用“return”聲明的話，那就為外部循環定義一個標簽是另一個好的選擇。

package main

import "fmt"

func main() {  
    loop:
        for {
            switch {
            case true:
                fmt.Println("breaking out...")
                break loop
            }
        }

    fmt.Println("out!")
}

"goto"聲明也可以完成這個功能。。。

"for"聲明中的叠代變量和閉包

level: intermediate

這在Go中是個很常見的技巧。 for語句中的叠代變量在每次叠代時被重新使用。這就意味著你在 for循環中創建的閉包（即函數字面量）將會引用同一個變量（而在那些goroutine開始執行時就會得到那個變量的值）。

Incorrect:

package main

import (  
    "fmt"
    "time"
)

func main() {  
    data := []string{"one","two","three"}

    for _,v := range data {
        go func() {
            fmt.Println(v)
        }()
    }

    time.Sleep(3 * time.Second)
    //goroutines print: three, three, three
}

最簡單的解決方法（不需要修改goroutine）是，在 for循環代碼塊內把當前叠代的變量值保存到一個局部變量中。

Works:

package main

import (  
    "fmt"
    "time"
)

func main() {  
    data := []string{"one","two","three"}

    for _,v := range data {
        vcopy := v //
        go func() {
            fmt.Println(vcopy)
        }()
    }

    time.Sleep(3 * time.Second)
    //goroutines print: one, two, three
}

另一個解決方法是把當前的叠代變量作為匿名goroutine的參數。

Works:

package main

import (  
    "fmt"
    "time"
)

func main() {  
    data := []string{"one","two","three"}

    for _,v := range data {
        go func(in string) {
            fmt.Println(in)
        }(v)
    }

    time.Sleep(3 * time.Second)
    //goroutines print: one, two, three
}

下面這個陷阱稍微復雜一些的版本。

Incorrect:

package main

import (  
    "fmt"
    "time"
)

type field struct {  
    name string
}

func (p *field) print() {  
    fmt.Println(p.name)
}

func main() {  
    data := []field{{"one"},{"two"},{"three"}}

    for _,v := range data {
        go v.print()
    }

    time.Sleep(3 * time.Second)
    //goroutines print: three, three, three
}

Works:

package main

import (  
    "fmt"
    "time"
)

type field struct {  
    name string
}

func (p *field) print() {  
    fmt.Println(p.name)
}

func main() {  
    data := []field{{"one"},{"two"},{"three"}}

    for _,v := range data {
        v := v
        go v.print()
    }

    time.Sleep(3 * time.Second)
    //goroutines print: one, two, three
}

在運行這段代碼時你認為會看到什麽結果？（原因是什麽？）

package main

import (  
    "fmt"
    "time"
)

type field struct {  
    name string
}

func (p *field) print() {  
    fmt.Println(p.name)
}

func main() {  
    data := []*field{{"one"},{"two"},{"three"}}

    for _,v := range data {
        go v.print()
    }

    time.Sleep(3 * time.Second)
}

Defer函數調用參數的求值

level: intermediate

被defer的函數的參數會在defer聲明時求值（而不是在函數實際執行時）。
Arguments for a deferred function call are evaluated when the defer statement is evaluated (not when the function is actually executing).

package main

import "fmt"

func main() {  
    var i int = 1

    defer fmt.Println("result =>",func() int { return i * 2 }())
    i++
    //prints: result => 2 (not ok if you expected 4)
}

被Defer的函數調用執行

level: intermediate

被defer的調用會在包含的函數的末尾執行，而不是包含代碼塊的末尾。對於Go新手而言，一個很常犯的錯誤就是無法區分被defer的代碼執行規則和變量作用規則。如果你有一個長時運行的函數，而函數內有一個 for循環試圖在每次叠代時都 defer資源清理調用，那就會出現問題。

package main

import (  
    "fmt"
    "os"
    "path/filepath"
)

func main() {  
    if len(os.Args) != 2 {
        os.Exit(-1)
    }

    start, err := os.Stat(os.Args[1])
    if err != nil || !start.IsDir(){
        os.Exit(-1)
    }

    var targets []string
    filepath.Walk(os.Args[1], func(fpath string, fi os.FileInfo, err error) error {
        if err != nil {
            return err
        }

        if !fi.Mode().IsRegular() {
            return nil
        }

        targets = append(targets,fpath)
        return nil
    })

    for _,target := range targets {
        f, err := os.Open(target)
        if err != nil {
            fmt.Println("bad target:",target,"error:",err) //prints error: too many open files
            break
        }
        defer f.Close() //will not be closed at the end of this code block
        //do something with the file...
    }
}

解決這個問題的一個方法是把代碼塊寫成一個函數。

package main

import (  
    "fmt"
    "os"
    "path/filepath"
)

func main() {  
    if len(os.Args) != 2 {
        os.Exit(-1)
    }

    start, err := os.Stat(os.Args[1])
    if err != nil || !start.IsDir(){
        os.Exit(-1)
    }

    var targets []string
    filepath.Walk(os.Args[1], func(fpath string, fi os.FileInfo, err error) error {
        if err != nil {
            return err
        }

        if !fi.Mode().IsRegular() {
            return nil
        }

        targets = append(targets,fpath)
        return nil
    })

    for _,target := range targets {
        func() {
            f, err := os.Open(target)
            if err != nil {
                fmt.Println("bad target:",target,"error:",err)
                return
            }
            defer f.Close() //ok
            //do something with the file...
        }()
    }
}

另一個方法是去掉 defer語句 :-)

失敗的類型斷言

level: intermediate

失敗的類型斷言返回斷言聲明中使用的目標類型的“零值”。這在與隱藏變量混合時，會發生未知情況。

Incorrect:

package main

import "fmt"

func main() {  
    var data interface{} = "great"

    if data, ok := data.(int); ok {
        fmt.Println("[is an int] value =>",data)
    } else {
        fmt.Println("[not an int] value =>",data)
        //prints: [not an int] value => 0 (not "great")
    }
}

Works:

package main

import "fmt"

func main() {  
    var data interface{} = "great"

    if res, ok := data.(int); ok {
        fmt.Println("[is an int] value =>",res)
    } else {
        fmt.Println("[not an int] value =>",data)
        //prints: [not an int] value => great (as expected)
    }
}

阻塞的Goroutine和資源泄露

level: intermediate

Rob Pike在2012年的Google I/O大會上所做的“Go Concurrency Patterns”的演講上，說道過幾種基礎的並發模式。從一組目標中獲取第一個結果就是其中之一。

func First(query string, replicas ...Search) Result {  
    c := make(chan Result)
    searchReplica := func(i int) { c <- replicas[i](query) }
    for i := range replicas {
        go searchReplica(i)
    }
    return <-c
}

這個函數在每次搜索重復時都會起一個goroutine。每個goroutine把它的搜索結果發送到結果的channel中。結果channel的第一個值被返回。

那其他goroutine的結果會怎樣呢？還有那些goroutine自身呢？

在 First()函數中的結果channel是沒緩存的。這意味著只有第一個goroutine返回。其他的goroutine會困在嘗試發送結果的過程中。這意味著，如果你有不止一個的重復時，每個調用將會泄露資源。

為了避免泄露，你需要確保所有的goroutine退出。一個不錯的方法是使用一個有足夠保存所有緩存結果的channel。

func First(query string, replicas ...Search) Result {  
    c := make(chan Result,len(replicas))
    searchReplica := func(i int) { c <- replicas[i](query) }
    for i := range replicas {
        go searchReplica(i)
    }
    return <-c
}

另一個不錯的解決方法是使用一個有 default情況的 select語句和一個保存一個緩存結果的channel。 default情況保證了即使當結果channel無法收到消息的情況下，goroutine也不會堵塞。

func First(query string, replicas ...Search) Result {  
    c := make(chan Result,1)
    searchReplica := func(i int) {
        select {
        case c <- replicas[i](query):
        default:
        }
    }
    for i := range replicas {
        go searchReplica(i)
    }
    return <-c
}

你也可以使用特殊的取消channel來終止workers。

func First(query string, replicas ...Search) Result {  
    c := make(chan Result)
    done := make(chan struct{})
    defer close(done)
    searchReplica := func(i int) {
        select {
        case c <- replicas[i](query):
        case <- done:
        }
    }
    for i := range replicas {
        go searchReplica(i)
    }

    return <-c
}

為何在演講中會包含這些bug？Rob Pike僅僅是不想把演示復雜化。這麽作是合理的，但對於Go新手而言，可能會直接使用代碼，而不去思考它可能有問題。

高級篇

使用指針接收方法的值的實例

level: advanced

只要值是可取址的，那在這個值上調用指針接收方法是沒問題的。換句話說，在某些情況下，你不需要在有一個接收值的方法版本。

然而並不是所有的變量是可取址的。Map的元素就不是。通過interface引用的變量也不是。

package main

import "fmt"

type data struct {  
    name string
}

func (p *data) print() {  
    fmt.Println("name:",p.name)
}

type printer interface {  
    print()
}

func main() {  
    d1 := data{"one"}
    d1.print() //ok

    var in printer = data{"two"} //error
    in.print()

    m := map[string]data {"x":data{"three"}}
    m["x"].print() //error
}

Compile Errors:

/tmp/sandbox017696142/main.go:21: cannot use data literal (type data) as type printer in assignment: data does not implement printer (print method has pointer receiver)
/tmp/sandbox017696142/main.go:25: cannot call pointer method on m["x"] /tmp/sandbox017696142/main.go:25: cannot take the address of m["x"]

更新Map的值

level: advanced

如果你有一個struct值的map，你無法更新單個的struct值。

Fails:

package main

type data struct {  
    name string
}

func main() {  
    m := map[string]data {"x":{"one"}}
    m["x"].name = "two" //error
}

Compile Error:

/tmp/sandbox380452744/main.go:9: cannot assign to m["x"].name

這個操作無效是因為map元素是無法取址的。

而讓Go新手更加困惑的是slice元素是可以取址的。

package main

import "fmt"

type data struct {  
    name string
}

func main() {  
    s := []data {{"one"}}
    s[0].name = "two" //ok
    fmt.Println(s)    //prints: [{two}]
}

註意在不久之前，使用編譯器之一（gccgo）是可以更新map的元素值的，但這一行為很快就被修復了 :-)它也被認為是Go 1.3的潛在特性。在那時還不是要急需支持的，但依舊在todo list中。

第一個有效的方法是使用一個臨時變量。

package main

import "fmt"

type data struct {  
    name string
}

func main() {  
    m := map[string]data {"x":{"one"}}
    r := m["x"]
    r.name = "two"
    m["x"] = r
    fmt.Printf("%v",m) //prints: map[x:{two}]
}

另一個有效的方法是使用指針的map。

package main

import "fmt"

type data struct {  
    name string
}

func main() {  
    m := map[string]*data {"x":{"one"}}
    m["x"].name = "two" //ok
    fmt.Println(m["x"]) //prints: &{two}
}

順便說下，當你運行下面的代碼時會發生什麽？

package main

type data struct {  
    name string
}

func main() {  
    m := map[string]*data {"x":{"one"}}
    m["z"].name = "what?" //???
}

"nil" Interfaces和"nil" Interfaces的值

level: advanced

這在Go中是第二最常見的技巧，因為interface雖然看起來像指針，但並不是指針。interface變量僅在類型和值為“nil”時才為“nil”。

interface的類型和值會根據用於創建對應interface變量的類型和值的變化而變化。當你檢查一個interface變量是否等於“nil”時，這就會導致未預期的行為。

package main

import "fmt"

func main() {  
    var data *byte
    var in interface{}

    fmt.Println(data,data == nil) //prints: <nil> true
    fmt.Println(in,in == nil)     //prints: <nil> true

    in = data
    fmt.Println(in,in == nil)     //prints: <nil> false
    //‘data‘ is ‘nil‘, but ‘in‘ is not ‘nil‘
}

當你的函數返回interface時，小心這個陷阱。

Incorrect:

package main

import "fmt"

func main() {  
    doit := func(arg int) interface{} {
        var result *struct{} = nil

        if(arg > 0) {
            result = &struct{}{}
        }

        return result
    }

    if res := doit(-1); res != nil {
        fmt.Println("good result:",res) //prints: good result: <nil>
        //‘res‘ is not ‘nil‘, but its value is ‘nil‘
    }
}

Works:

package main

import "fmt"

func main() {  
    doit := func(arg int) interface{} {
        var result *struct{} = nil

        if(arg > 0) {
            result = &struct{}{}
        } else {
            return nil //return an explicit ‘nil‘
        }

        return result
    }

    if res := doit(-1); res != nil {
        fmt.Println("good result:",res)
    } else {
        fmt.Println("bad result (res is nil)") //here as expected
    }
}

棧和堆變量

level: advanced

你並不總是知道變量是分配到棧還是堆上。在C++中，使用 new創建的變量總是在堆上。在Go中，即使是使用 new()或者 make()函數來分配，變量的位置還是由編譯器決定。編譯器根據變量的大小和“泄露分析”的結果來決定其位置。這也意味著在局部變量上返回引用是沒問題的，而這在C或者C++這樣的語言中是不行的。

如果你想知道變量分配的位置，在“go build”或“go run”上傳入“-m“ gc標誌（即， go run -gcflags -m app.go）。

GOMAXPROCS, 並發, 和並行

level: advanced

默認情況下，Go僅使用一個執行上下文/OS線程（在當前的版本）。這個數量可以通過設置 GOMAXPROCS來提高。

一個常見的誤解是， GOMAXPROCS表示了CPU的數量，Go將使用這個數量來運行goroutine。而runtime.GOMAXPROCS()函數的文檔讓人更加的迷茫。 GOMAXPROCS變量描述（The Go Programming Language）所討論OS線程的內容比較好。

你可以設置 GOMAXPROCS的數量大於CPU的數量。 GOMAXPROCS的最大值是256。

package main

import (  
    "fmt"
    "runtime"
)

func main() {  
    fmt.Println(runtime.GOMAXPROCS(-1)) //prints: 1
    fmt.Println(runtime.NumCPU())       //prints: 1 (on play.golang.org)
    runtime.GOMAXPROCS(20)
    fmt.Println(runtime.GOMAXPROCS(-1)) //prints: 20
    runtime.GOMAXPROCS(300)
    fmt.Println(runtime.GOMAXPROCS(-1)) //prints: 256
}

讀寫操作的重排順序

level: advanced

Go可能會對某些操作進行重新排序，但它能保證在一個goroutine內的所有行為順序是不變的。然而，它並不保證多goroutine的執行順序。

package main

import (  
    "runtime"
    "time"
)

var _ = runtime.GOMAXPROCS(3)

var a, b int

func u1() {  
    a = 1
    b = 2
}

func u2() {  
    a = 3
    b = 4
}

func p() {  
    println(a)
    println(b)
}

func main() {  
    go u1()
    go u2()
    go p()
    time.Sleep(1 * time.Second)
}

如果你多運行幾次上面的代碼，你可能會發現 a和 b變量有多個不同的組合：

a和 b最有趣的組合式是 "02"。這表明 b在 a之前更新了。

如果你需要在多goroutine內放置讀寫順序的變化，你將需要使用channel，或者使用"sync"包構建合適的結構體。

優先調度

level: advanced

有可能會出現這種情況，一個無恥的goroutine阻止其他goroutine運行。當你有一個不讓調度器運行的 for循環時，這就會發生。

package main

import "fmt"

func main() {  
    done := false

    go func(){
        done = true
    }()

    for !done {
    }
    fmt.Println("done!")
}

for循環並不需要是空的。只要它包含了不會觸發調度執行的代碼，就會發生這種問題。

調度器會在GC、“go”聲明、阻塞channel操作、阻塞系統調用和lock操作後運行。它也會在非內聯函數調用後執行。

package main

import "fmt"

func main() {  
    done := false

    go func(){
        done = true
    }()

    for !done {
        fmt.Println("not done!") //not inlined
    }
    fmt.Println("done!")
}

要想知道你在 for循環中調用的函數是否是內聯的，你可以在“go build”或“go run”時傳入“-m” gc標誌（如， go build -gcflags -m）。

另一個選擇是顯式的喚起調度器。你可以使用“runtime”包中的 Goshed()函數。

package main

import (  
    "fmt"
    "runtime"
)

func main() {  
    done := false

    go func(){
        done = true
    }()

    for !done {
        runtime.Gosched()
    }
    fmt.Println("done!")
}

[轉]Go的50坑：新Golang開發者要註意的陷阱、技巧和常見錯誤-高級

[轉]Go的50坑：新Golang開發者要註意的陷阱、技巧和常見錯誤-高級

from : https://levy.at/blog/11

進階篇

關閉HTTP的響應

關閉HTTP的連接

比較Structs, Arrays, Slices, and Maps

從Panic中恢復

在Slice, Array, and Map "range"語句中更新引用元素的值

在Slice中"隱藏"數據

Slice的數據“毀壞”

"走味的"Slices

類型聲明和方法

從"for switch"和"for select"代碼塊中跳出

"for"聲明中的叠代變量和閉包

Defer函數調用參數的求值

被Defer的函數調用執行

失敗的類型斷言

阻塞的Goroutine和資源泄露

高級篇

使用指針接收方法的值的實例

更新Map的值

"nil" Interfaces和"nil" Interfaces的值

棧和堆變量

GOMAXPROCS, 並發, 和並行

讀寫操作的重排順序

優先調度

相關推薦