《Go语言实战》William Kennedy中文版学习笔记
第1章 Go語言的介紹
本章主要內(nèi)容：用Go解決現(xiàn)代計算難題，使用 Go 語言工具。C 和 C++這類語言提供了很快的執(zhí)行速度,而 Ruby 和 Python 這類語言則擅長快速開發(fā)。Go 語言在這兩者間架起了橋梁,不僅提供了高性能的語言,同時也讓開發(fā)更快速。
1.1.1 開發(fā)速度
Go 語言使用了更加智能的編譯器,并簡化了解決依賴的算法,最終提供了更快的編譯速度。編譯 Go 程序時,編譯器只會關(guān)注那些直接被引用的庫,而不是像 Java、C 和 C++那樣,要遍歷依賴鏈中所有依賴的庫。
1.1.2 并發(fā)
Go 語言對并發(fā)的支持是這門語言最重要的特性之一。goroutine 很像線程,但是它占用的內(nèi)存遠(yuǎn)少于線程,使用它需要的代碼更少。通道(channel)是一種內(nèi)置的數(shù)據(jù)結(jié)構(gòu),可以讓用戶在不同的 goroutine 之間同步發(fā)送具有類型的消息。這讓編程模型更傾向于在 goroutine之間發(fā)送消息,而不是讓多個 goroutine 爭奪同一個數(shù)據(jù)的使用權(quán)。
1.goroutine
圖 1-2 在單一系統(tǒng)線程上執(zhí)行多個 goroutine
goroutine 是可以與其他 goroutine 并行執(zhí)行的函數(shù),同時也會與主程序(程序的入口)并執(zhí)行。在其他編程語言中,你需要用線程來完成同樣的事情,而在 Go 語言中會使用同一個線程來執(zhí)行多個 goroutine。如果想在執(zhí)行一段代碼的同時,并行去做另外一些事情,goroutine 是很好的選擇。下面是一個簡單的例子:
func log(msg string) {
? ? //這里是一些記錄日志的代碼
}
//代碼里有些地方檢測到了錯誤
go log("發(fā)生了可怕的事情")
2.通道
圖 1-3 使用通道在 goroutine 之間安全地發(fā)送數(shù)據(jù)
通道是一種數(shù)據(jù)結(jié)構(gòu)，可以讓goroutine之間進(jìn)行安全的數(shù)據(jù)通信。通道可以幫助用戶避免其他語言里常見的共享內(nèi)存訪問的問題。通道這一模式保證同一時刻只會有一個goroutine修改數(shù)據(jù)。通道用于幾個運行的goroutine之間發(fā)送數(shù)據(jù)。
1.1.3 Go 語言的類型系統(tǒng)
Go 語言提供了靈活的、無繼承的類型系統(tǒng),Go 開發(fā)者使用組合(composition)設(shè)計模式,只需簡單地將一個類型嵌入到另一個類型,就能復(fù)用所有的功能。
1.類型簡單
Go 開發(fā)者構(gòu)建更小的類型——Customer 和 Admin,然后把這些小類型組合成更大的類型。圖 1-4
展示了繼承和組合之間的不同。
2.Go 接口對一組行為建模
圖 1-4 繼承和組合的對比
Go 語言的接口一般只會描述一個單一的動作。在 Go 語言中,最常使用的接口之一是 io.Reader 。這個接口提供了一個簡單的方法,來聲明一個類型有數(shù)據(jù)可以讀取。標(biāo)準(zhǔn)庫內(nèi)的其他函數(shù)都能理解這個接口。這個接口的定義如下:
type Reader interface {
? ? Read(p []byte) (n int, err error)
}
為了實現(xiàn) io.Reader 這個接口,你只需要實現(xiàn)一個 Read 方法,這個方法接受一個 byte切片,返回一個整數(shù)和可能出現(xiàn)的錯誤。
1.1.4 內(nèi)存管理
Go 語言把無趣的內(nèi)存管理交給專業(yè)的編譯器去做,而讓程序員專注于更有趣的事情。
1.2 你好，Go
用Go語言編寫經(jīng)典的Hello World！應(yīng)用程序：
package main
import "fmt"
func main() {
? ? ? fmt.Printf("%s\n","Hello World!");
}
1.3 小結(jié)
Go語言是現(xiàn)代的、快速的，帶有一個強大的標(biāo)準(zhǔn)庫；Go語言內(nèi)置對并發(fā)的支持；Go語言使用接口作為代碼復(fù)用的基礎(chǔ)模塊。
第2章 快速開始一個Go程序
本章主要內(nèi)容：學(xué)習(xí)如何寫一個復(fù)雜的 Go 程序；聲明類型、變量、函數(shù)和方法；啟動并同步操作 goroutine；使用接口寫通用的代碼；處理程序邏輯和錯誤。
通過一個完整的 Go 語言程序,來看看 Go 語言是如何實現(xiàn)一些功能的。這個程序從不同的數(shù)據(jù)源拉取數(shù)據(jù),將數(shù)據(jù)內(nèi)容與一組搜索項做對比,然后將匹配的內(nèi)容顯示在終端窗口。這個程序會讀取文本文件,進(jìn)行網(wǎng)絡(luò)調(diào)用,解碼 XML 和 JSON 成為結(jié)構(gòu)化類型數(shù)據(jù),并且利用 Go 語言的并發(fā)機制保證這些操作的速度。代碼存放在這個代碼庫:
https://github.com/goinaction/code/tree/master/chapter2/sample
2.1 程序架
圖 2-1 程序架構(gòu)流程圖
這個應(yīng)用的代碼使用了 4 個文件夾,按字母順序列出。文件夾 data 中有一個 JSON 文檔,其內(nèi)容是程序要拉取和處理的數(shù)據(jù)源。文件夾 matchers 中包含程序里用于支持搜索不同數(shù)據(jù)源的代碼。目前程序只完成了支持處理 RSS 類型的數(shù)據(jù)源的匹配器。文件夾 search 中包含使用不同匹配器進(jìn)行搜索的業(yè)務(wù)邏輯，default.go用于搜索數(shù)據(jù)用的默認(rèn)匹配器，feed.go用于讀取 json 數(shù)據(jù)文件，
match.go用于支持不同匹配器的接口，search.go執(zhí)行搜索的主控制邏輯。最后,父級文件夾 sample 中有個 main.go 文件,這是整個程序的入口。
2.2 main 包
main.go文件，每個可執(zhí)行的 Go 程序都有兩個明顯的特征。一個特征是第 18 行聲明的名為 main 的函數(shù)。
構(gòu)建程序在構(gòu)建可執(zhí)行文件時,需要找到這個已經(jīng)聲明的 main 函數(shù),把它作為程序的入口。第二個特征是程序的第 01 行的包名 main 。
package main
import (
? ? "log"
? ? "os"
? ??
? ? _ "github.com/goinaction/code/chapter2/sample/matchers"
? ? ?"github.com/goinaction/code/chapter2/sample/search"
)
//init在main之前調(diào)用
func init() {
? ? //將日志輸出到標(biāo)準(zhǔn)輸出
? ? log.SetOutput(os.Stdout)
}
//main是整個程序的入口
func main() {
? ? //使用特定的項做搜索
? ? search.Run("president")
}
Go 語言的每個代碼文件都屬于一個包,main.go 也不例外。包這個特性對于 Go 語言來說很重要,一個包定義一組編譯過的代碼,包的名字類似命名空間,可以用來間接訪問包內(nèi)聲明的標(biāo)識符。這個特性可以把不同包中定義的同名標(biāo)識符區(qū)別開。
2.3 search 包
這個程序使用的框架和業(yè)務(wù)邏輯都在 search 包里。由于整個程序都圍繞匹配器來運作,這個程序里的匹配器,是指包含特定信息、用于處理某類數(shù)據(jù)源的實例。在這個示例程序中有兩個匹配器。框架本身實現(xiàn)了一個無法獲取任何信息的默認(rèn)匹配器,而在 matchers 包里實現(xiàn)了 RSS 匹配器。RSS匹配器知道如何獲取、讀入并查找 RSS 數(shù)據(jù)源。
2.3.1 search.go
package search
import (
? ? ? ? "log"
? ? ? ? "sync"
)
//注冊用于搜索的匹配器的映射
var matchers = make(map[string]Matcher)
在 Go 語言里,標(biāo)識符要么從包里公開,要么不從包里公開。當(dāng)代碼導(dǎo)入了一個包時,程序可以直接訪問這個包中任意一個公開的標(biāo)識符。這些標(biāo)識符以大寫字母開頭。以小寫字母開頭的標(biāo)識符是不公開的,不能被其他包中的代碼直接訪問。但是,其他包可以間接訪問不公開的標(biāo)識符。例如,一個函數(shù)可以返回一個未公開類型的值,那么這個函數(shù)的任何調(diào)用者,哪怕調(diào)用者不是在這個包里聲明的,都可以訪問這個值。
//Run執(zhí)行搜索邏輯
func Run(searchTherm string) {
? ? //獲取需要搜索的數(shù)據(jù)源列表
? ? //?第一個返回值是一組 Feed 類型的切片。切片是一種實現(xiàn)了一個動態(tài)數(shù)組的引用類型。第二個返回值是一個錯誤值。
? ? feed, err := RetrieveFeeds()
? ? if err != nil {
? ? ? ? ? ? log.Fatal(err)
? ? }
? ??
? ? //創(chuàng)建一個無緩沖的通道，接收匹配后的結(jié)果
? ? results := make(chan *Result)
? ??
? ? //構(gòu)造一個waitGroup,以便處理所有的數(shù)據(jù)源
? ? var waitGroup sync.waitGroup
? ??
? ? //設(shè)置需要等待處理
? ? //每個數(shù)據(jù)源的goroutine數(shù)量
? ? waitGroup.add(len(feeds))
? ??
? ? //為每一個數(shù)據(jù)源啟動一個gorpuntine來查找結(jié)果
? ? for _, feed := range feeds {
? ? ? ? ? ? //獲取一個匹配器用于查找
? ? ? ? ? ? matcher, exits := matchers[feed.Type]
? ? ? ? ? ? if !exits {
? ? ? ? ? ? ? ? ? ? matcher = matchers["default"]
? ? ? ? ? ? }
? ? ? ? ? ??
? ? ? ? ? ? //啟動一個gorountine來執(zhí)行搜索
? ? ? ? ? ? go func(matcher Matcher, feed *Feed) {
? ? ? ? ? ? ? ? ? ? Match(matcher, feed, searchTerm, results)
? ? ? ? ? ? ? ? ? ? waitGroup.done()
? ? ? ? ? ? }(matcher, feed)
? ? }
? ??
? ? //啟動一個gorountine來監(jiān)控是否所有的工作都做完了
? ? go func() {
? ? ? ? ? ? //等待所有任務(wù)完成
? ? ? ? ? ? waitGroup.wait()
? ? ? ? ? ??
? ? ? ? ? ? //用關(guān)閉通道的方式，通知Display函數(shù)
? ? ? ? ? ? //可以退出程序了
? ? ? ? ? ? close(results)
? ? }()
? ??
? ? //啟動函數(shù)，顯示返回的結(jié)果，并且
? ? //在最后一個結(jié)果顯示完成后返回
? ? Display(results)
}
//Register調(diào)用時，會注冊一個匹配器，提供給后面的程序使用
func Register(feedType string, matcher Matcher) {
? ? if _, exists := matchers[feedType]; exists {
? ? ? ? log.Fatalln(feedType, "Matcher already registered")
? ? }
? ??
? ? log.Println("Register", feedType, "matcher")
? ? matcher[feedType] = matcher
}
在 Go 語言中,通道(channel)和映射(map)與切片(slice)一樣,也是引用類型,不過通道本身實現(xiàn)的是一組帶類型的值,這組值用于在 goroutine 之間傳遞數(shù)據(jù)。通道內(nèi)置同步機制,從而保證通信安全。
這個程序使用 sync 包的 WaitGroup 跟蹤所有啟動的 goroutine。WaitGroup 是一個計數(shù)信號量,我們可以利用它來統(tǒng)計所有的
goroutine 是不是都完成了工作。
我們使用關(guān)鍵字 for range 對 feeds 切片做迭代。關(guān)鍵字 range 可以用于迭代數(shù)組、字符串、切片、映射和通道。使用 for range 迭代切片時,每次迭代會返回兩個值。第一個值是迭代的元素在切片里的索引位置,第二個值是元素值的一個副本。
Go 語言支持閉包,在匿名函數(shù)內(nèi)訪問 searchTerm 和 results變量,也是通過閉包的形式訪問的。因為有了閉包,函數(shù)可以直接訪問到那些沒有作為參數(shù)傳入的變量。匿名函數(shù)并沒有拿到這些變量的副本,而是直接訪問外層函數(shù)作用域中聲明的這些變量本身。
我們以 goroutine的方式啟動了另一個匿名函數(shù)。這個匿名函數(shù)沒有輸入?yún)?shù),使用閉包訪問了 WaitGroup 和results 變量。這個 goroutine 里面調(diào)用了 WaitGroup 的 Wait 方法。這個方法會導(dǎo)致 goroutine阻塞,直到 WaitGroup 內(nèi)部的計數(shù)到達(dá) 0。之后,goroutine 調(diào)用了內(nèi)置的 close 函數(shù),關(guān)閉了通道,最終導(dǎo)致程序終止。
2.3.2 feed.go
package search
import (
? ? "encoding/json"
? ? "os"
)
const dataFile = "data/data.json"
//Feed包含我們需要處理的數(shù)據(jù)源的信息
type Feed struct {
? ? Name string 'json:"site"'
? ? URI string 'json:"link"'
? ? type string 'json:"type"'
}
//RetrieveFeeds讀取并反序列化源數(shù)據(jù)文件
func RetrieveFeeds() ([]*Feed, error) {
? ? //打開文件
? ? file, err := os.Open(dataFile)
? ? if err != nil {
? ? ? ? return nil, err
? ? }
? ??
? ? //當(dāng)函數(shù)返回時
? ? //關(guān)閉文件
? ? defer file.Close()
? ??
? ? //將文件解碼到一個切片里
? ? //這個切片的每一項是一個指向一個Feed類型值的指針
? ? var feeds []*feed
? ? err = json.NewDecoder(file).Decode(&feedss)
? ??
? ? //這個函數(shù)不需要檢查錯誤，調(diào)用者會做這件事
? ? return feeds, err
}
2.3.3 match.go/default.go
search/match.go
package search
import (
? ? "log"
)
//Result 保存搜索的結(jié)果
type Result strut {
? ? Field string
? ? Content string
}
//Matcher定義要實現(xiàn)的
//新搜索類型的行為
type Matcher interface {
? ? Search(feed *Feed, searchTerm string ) ([]*Result, error)
}
//Match函數(shù)，為每個數(shù)據(jù)源單獨啟動goroutine來執(zhí)行這個函數(shù)
// 并發(fā)地執(zhí)行搜索
func Match(matcher Matcher, feed *Feed, searchTerm string, result chan<- *Result) {
? ? //對特定的疲累器執(zhí)行搜索
? ? searchTerm, err := matcher.Search(feed, searchTerm)
? ? if err != nil {
? ? ? ? log.Println(err)
? ? ? ? return
? ? }
? ??
? ? //將結(jié)果寫入通道
? ? for _, result := range searchTerm {
? ? ? ? result <- result
? ? }
}
//Display從每個單獨的gorountine接收到結(jié)果后
//在終端窗口輸出
func Dissplay(results chan *Resssult) {
? ? //通道會一直阻塞，直到有結(jié)果寫入
? ? //一旦通道被關(guān)閉，for循環(huán)就會終止
? ? for result := range results {
? ? ? ? fmt.Printf("%s:\n%s\n\n", result.Field, result.Content)
? ? }
}
interface 關(guān)鍵字聲明了一個接口,這個接口聲明了結(jié)構(gòu)類型或者具名類型需要實現(xiàn)的行為。一個接口的行為最終由在這個接口類型中聲明的方法決定。如果要讓一個用戶定義的類型實現(xiàn)一個接口,這個用戶定義的類型要實現(xiàn)接口類型里聲明的所有方法。
search/default.go
package search
//defaultMatcer實現(xiàn)了默認(rèn)匹配器
type defaultMatcher struct{}
// init函數(shù)將默認(rèn)匹配器注冊到程序里
func init() {
? ? var matcher defaultMatcher
? ? Register("default", matcher)
}
//Search 實現(xiàn)了默認(rèn)匹配器的行為
func (m defaultMatcher) Search(feed *Feed, searchTerm string) ([]*Result, err) {
? ? return nil, nil
}
如果聲明函數(shù)的時候帶有接收者,則意味著聲明了一個方法。這個方法會和指定的接收者的類型綁在一起。在我們的例子里, Search 方法與 defaultMatcher 類型的值綁在一起。這意味著我們可以使用 defaultMatcher 類型的值或者指向這個類型值的指針來調(diào)用 Search 方法。無論我們是使用接收者類型的值來調(diào)用這個方,還是使用接收者類型值的指針來調(diào)用這個方法,編譯器都會正確地引用或者解引用對應(yīng)的值,作為接收者傳遞給 Search 方法。
調(diào)用方法的例子
//方法聲明為使用defaultMatcher類型的值作為接收者
func (m defaultMatcher) Search(feed *Feed, searchTerm string)
//聲明一個指向defaultMatcher類型值的指針
dm := new(defaultMatch)
//編譯器會解開dm指針的引用，使用對應(yīng)的值調(diào)用方法
dm.Search(feed, "test"
//方法聲明為使用指向defaultMatcher類型值的指針作為接收者
func (m ×defaultMatcher) Search(feed *Feed, searchTerm string)
//聲明一個指向defaultMatcher類型的值
var dm defaultMatch
//編譯器會自動生成指針引用dm值，使用指針調(diào)用方法
dm.Search(feed, "test")
與直接通過值或者指針調(diào)用方法不同,如果通過接口類型的值調(diào)用方法,規(guī)則有很大不同,使用指針作為接收者聲明的方法,只能在接口類型的值是一個指針的時候被調(diào)用。使用值作為接收者聲明的方法,在接口類型的值為值或者指針時,都可以被調(diào)用。
接口方法調(diào)用所受限制的例子
//方法聲明為使用指向defaultMatcher類型值的指針作為接收者
func (m *defaultMatcher) Search(feed *Feed, searchTerm string)
//通過interface類型的值來調(diào)用方法
var dm defaultMatcher
var matcher Matcher = dm //將值賦值給接口類型
matcher.Search(feed, "test") //使用值來調(diào)用接口方法
> go build
cannot use dm (type defaultMatcher) as type Matcher in assignment
//方法聲明為使用defaultMatcher類型的值作為接收者
func (m defaultMatcher) Search(feed *Feed, searchTerm string)
//通過interface類型的值來調(diào)用方法
var dm defaultMatcher
var matcher Matcher = &dm //將指針賦值給接口類型
matcher.Search(feed, "test") //使用指針來調(diào)用接口方法
> go build
Build Successful
2.4 RSS 匹配器
matchers/rss.go
package matchers
import (
? ? "encoding/xml"
? ? "errors"
? ? "fmt"
? ? "log"
? ? "net/http"
? ? "regexp"
? ??
? ? "github.com/goinaction/code/chapter2/sample/search"
)
type (
? ? //item根據(jù)item字段的標(biāo)簽，將定義的字段
? ? //與rss文擋的字段關(guān)聯(lián)起來
? ? item struct {
? ? ? ? XMLName ? ? xml.Name ?’xml:"item"‘
? ? ? ? PubDate ? ? string ? ?’xml:"pubDate"‘
? ? ? ? Title ? ? ? string ? ?’xml:"title"‘
? ? ? ? Description string ? ?’xml:"description"‘
? ? ? ? Link ? ? ? ?string ? ?’xml:"link"‘
? ? ? ? GUID ? ? ? ?string ? ?’xml:"guid"‘
? ? ? ? GeoRssPoint string ? ?’xml:"georss:point"‘
? ? }
? ??
? ? //image根據(jù)image字段的標(biāo)簽，將定義的字段
? ? //與rss文檔的字段關(guān)聯(lián)起來
? ? image struct {
? ? ? ? XMLName xml.Name ?’xml:"image"‘
? ? ? ? URL ? ? string ? ?’xml:"url"‘
? ? ? ? Title ? string ? ?’xml:"title"‘
? ? ? ? Link ? ?string ? ?’xml:"link"‘
? ? }
? ??
? ? //channel根據(jù)channel字段的標(biāo)簽，將定義的字段
? ? //與rss文檔的字段關(guān)聯(lián)起來
? ? channel struct {
? ? ? ? XMLName ? ? ? ?xml.Name ?’xml:"channel"‘
? ? ? ? Title ? ? ? ? ?string ? ?’xml:"title"‘
? ? ? ? Description ? ?string ? ?’xml:"description"‘
? ? ? ? Link ? ? ? ? ? string ? ?’xml:"link"‘
? ? ? ? PubDate ? ? ? ?string ? ?’xml:"pubDate"‘
? ? ? ? LastBuildDate ?string ? ?’xml:"lastBuildDate"‘
? ? ? ? TTL ? ? ? ? ? ?string ? ?’xml:"ttl"‘
? ? ? ? Language ? ? ? string ? ?’xml:"language"‘
? ? ? ? ManagingEditor string ? ?’xml:"managingEditor"‘
? ? ? ? WebMaster ? ? ?string ? ?’xml:"webMaster"‘
? ? ? ? Image ? ? ? ? ?image ? ? 'xml:"image"'
? ? ? ? Item ? ? ? ? ? []item ? ?'xml:"item"'
? ? }
? ??
? ? //rssDocument定義了與rss文檔關(guān)聯(lián)的字段
? ? rssDocument struct {
? ? ? ? XMLName xml.Name ?’xml:"rss"‘?
? ? ? ? Channel channel ? ’xml:"channel"‘
? ? }
)
//rssMatcher實現(xiàn)了Matcher接口
type rssMaster struct{}
//init將匹配器注冊到程序里
func init() {
? ? var matcher rssMatcher
? ? search.Register("rss", matcher)
}
//Search在文檔中查找特定的搜索項
func (m rssMatcher) Search(feed *search.Feed, searchTerm string)
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ([]*search.Result, error) {
? ? //我們使用關(guān)鍵字 var 聲明了一個值為 nil 的切片,切片每一項都是指向 Result 類型值的指針。
? ? var result []*search.Result
? ? log.Printf("Search Feed Type[%s] Site[%s] For Uri[%s]\n",
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? feed.Type, feed.Name, feed.URI)
? ? //獲取要搜索的數(shù)據(jù)
? ? document, err := m.retrieve(feed)
? ? if err != nil {
? ? ? ? return nil, err
? ? }
? ??
? ? for _, channelItem := range document.Channel.Item {
? ? ? ? //檢查標(biāo)題部分是否包含搜索項
? ? ? ? matched, err := regexp.MatchString(searchTerm, channelItem.Title)
? ? ? ? if err != nil {
? ? ? ? ? ? return nil, err
? ? ? ? }
? ? ? ??
? ? ? ? //如果找到匹配的項，將其作為結(jié)果保存
? ? ? ? if matched {
? ? ? ? ? ? results = append(results, &search.Result){
? ? ? ? ? ? ? ? Field: "Title",
? ? ? ? ? ? ? ? Content: channelItem.Tile,
? ? ? ? ? ? })
? ? ? ? }
? ? ? ??
? ? ? ? //檢查描述部分是否包含搜索項
? ? ? ? matched, err = regexp.MatchString(searchTern, channelTerm.Description)
? ? ? ? if err != nil {
? ? ? ? ? ? return nil, err
? ? ? ? }
? ? ? ??
? ? ? ? ?//如果找到匹配的項， 將其作為結(jié)果保存
? ? ? ? ?if matched {
? ? ? ? ? ? ?results = append(results, &search.Result{
? ? ? ? ? ? ? ? ?Field: "Description",
? ? ? ? ? ? ? ? ?Content: channelItem.Description,
? ? ? ? ? ? ?})
? ? ? ? ?}
? ? }
? ??
? ? return results, nil
}
//retrieve發(fā)送HTTP Get請求獲取rss數(shù)據(jù)源并解碼
Func (m rssMatcher) retrieve(feed *search.Feed) (*rssDocument, error) {
? ? if feed.URI == "" {
? ? ? ? return nil, errors.New("No rss feed URI provided")
? ? }
? ??
? ? //從網(wǎng)絡(luò)獲得rss數(shù)據(jù)源文檔
? ? resp, err := http.Get(feed.URI)
? ? if err != nil {
? ? ? ? return nil, err
? ? }
? ??
? ? //一旦從函數(shù)返回，關(guān)閉返回的響應(yīng)鏈接
? ? defer resp.Body.Close()
? ??
? ? //檢查狀態(tài)碼是不是200，這樣就知道
? ? //是不是收到了正確的響應(yīng)
? ? if resp.StatusCode != 200 {
? ? ? ? return nil, fmt.Errorf("HTTP Response Error %d\n", resp.StatusCode)
? ? }
? ??
? ? //將rss數(shù)據(jù)源文檔解碼到我們定義的結(jié)構(gòu)類型里
? ? //不需要檢查錯誤，調(diào)用者會做這件事
? ? var document rssDocument
? ? err = xml.NewDecoder(resp.Body).Decode(&document)
? ? return &document, err
}
2.5 小結(jié)
每個代碼文件都屬于一個包,而包名應(yīng)該與代碼文件所在的文件夾同名;Go 語言提供了多種聲明和初始化變量的方式。如果變量的值沒有顯式初始化,編譯器會將變量初始化為零值;使用指針可以在函數(shù)間或者 goroutine 間共享數(shù)據(jù);通過啟動 goroutine 和使用通道完成并發(fā)和同步;Go 語言提供了內(nèi)置函數(shù)來支持 Go 語言內(nèi)部的數(shù)據(jù)結(jié)構(gòu);標(biāo)準(zhǔn)庫包含很多包,能做很多很有用的事情;使用 Go 接口可以編寫通用的代碼和框架。
第 3 章 打包和工具鏈
本章主要內(nèi)容：如何組織 Go 代碼；使用 Go 語言自帶的相關(guān)命令；使用其他開發(fā)者提供的工具；與其他開發(fā)者合作。
在 Go 語言里,包是個非常重要的概念。其設(shè)計理念是使用包來封裝不同語義單元的功能。這樣做,能夠更好地復(fù)用代碼,并對每個包內(nèi)的數(shù)據(jù)的使用有更好的控制。所有的.go 文件,除了空行和注釋,都應(yīng)該在第一行聲明自己所屬的包。每個包都在一個單獨的目錄里。不能把多個包放到同一個目錄中,也不能把同一個包的文件分拆到多個不同目錄中。這意味著,同一個目錄下的所有.go 文件必須聲明同一個包名。
3.1 main包
經(jīng)典的“Hello World!”程序
hello.go
package main
import "fmt"
func main() {
? ? fmt.Println("Hello World!"):
}
3.2 導(dǎo)入
如果需要導(dǎo)入多個包,習(xí)慣上是將import 語句包裝在一個導(dǎo)入塊中。strings 包提供了很多關(guān)于字符串的操作,如查找、替換或
者變換。
import (
? ? ? ? "fmt"
? ? ? ? "strings"
)
3.2.1 遠(yuǎn)程導(dǎo)入?
Go 工具鏈會使用導(dǎo)入路徑確定需要獲取的代碼在網(wǎng)絡(luò)的什么地方。
例如:import "github.com/spf13/viper
3.2.2 命名導(dǎo)入
重命名導(dǎo)入。有時,用戶可能需要導(dǎo)入一個包,但是不需要引用這個包的標(biāo)識符。在這種情況,可以使用空白標(biāo)識符_來重命名這個導(dǎo)入。
3.3 函數(shù) init
init 函數(shù)的用法
package postgres
import (
? ? "database/sql"
)
func init() {
? ? //創(chuàng)建一個 postgres 驅(qū)動的實例。這里為了展現(xiàn) init 的作用,沒有展現(xiàn)其定義細(xì)節(jié)。
? ? sql.Register("postgres", new(PostgresDriver))
}
在使用這個新的數(shù)據(jù)庫驅(qū)動寫程序時,我們使用空白標(biāo)識符來導(dǎo)入包,以便新的驅(qū)動會包含到 sql 包。如前所述,不能導(dǎo)入不使用的包,為此使用空白標(biāo)識符重命名這個導(dǎo)入可以讓 init函數(shù)發(fā)現(xiàn)并被調(diào)度運行,讓編譯器不會因為包未被使用而產(chǎn)生錯誤。我們可以調(diào)用 sql.Open 方法來使用這個驅(qū)動。
導(dǎo)入時使用空白標(biāo)識符作為包的別名：
package main
import (
? ? "database/sql"
? ? //使用空白標(biāo)識符導(dǎo)入包,避免編譯錯誤。
? ? _"github.com/goinaction/code/chapter3/dbdriver/postgres"
)
func main() {
? ? //調(diào)用sql包提供的open方法。該方法能工作的關(guān)鍵在于postgres驅(qū)動通過自己的init函數(shù)將自身注冊到了sql包。
? ? sql.Open("postgres","mydb")
}
3.4 使用 Go 的工具
build 和 clean 命令會執(zhí)行編譯和清理的工作。go build hello.go
調(diào)用 clean 后會刪除編譯生成的可執(zhí)行文件。go clean hello.go
使用 io 包的工作
package main
import (
? ? "fmt"
? ? "io/ioutil"
? ? "os"
? ??
? ? "github.com/goinaction/code/chapter3/words"
)
// main 是應(yīng)用程序的入口
func main() {
? ? filename := os.Args[1]
? ??
? ? contents, err := ioutil.ReadFile(filename)
? ? if err != nil {
? ? ? ? fmt.Println(err)
? ? ? ? return
? ? }
? ? text := string(contents)
? ? count := words.CountWords(text)
? ??
? ? fmt.Printf("There are %d words in your text.\n", count)
}
做開發(fā)會經(jīng)常使用 go build 和 go run 命令。go build wordcount.go
go run 命令會先構(gòu)建 wordcount.go 里包含的程序,然后執(zhí)行構(gòu)建后的程序。go run wordcount.go
3.5 進(jìn)一步介紹 Go 開發(fā)工具
vet 命令會幫開發(fā)人員檢測代碼的常見錯誤：Printf 類函數(shù)調(diào)用時,類型匹配錯誤的參數(shù)；定義常用的方法時,方法簽名的錯誤；錯誤的結(jié)構(gòu)標(biāo)簽；沒有指定字段名的結(jié)構(gòu)字面量。
使用 go vet工具不能讓開發(fā)者避免嚴(yán)重的邏輯錯誤,或者避免編寫充滿小錯的代碼。
package main
import "fmt"
func main() {
? ? fmt.Printf("The quick brown fox jumped over lazy dogs", 3.14)
}
這個程序要輸出一個浮點數(shù) 3.14,但是在格式化字符串里并沒有對應(yīng)的格式化參數(shù)。
3.5.2 Go 代碼格式化
fmt 命令會自動格式化開發(fā)人員指定的源代碼文件并保存。
3.5.3 Go 語言的文檔
Go 語言有兩種方法為開發(fā)者生成文檔。如果開發(fā)人員使用命令行提示符工作,可以在終端上直接使用 go doc 命令來打印文檔。
1.從命令行獲取文檔go doc tar；2.瀏覽文檔godoc -http=:6060
3.6 與其他 Go 開發(fā)者合作
以分享為目的創(chuàng)建代碼庫
1.包應(yīng)該在代碼庫的根目錄中（使用 go get 的時候,開發(fā)人員指定了要導(dǎo)入包的全路徑）；2.包可以非常小；
3.對代碼執(zhí)行 go fmt；4.給代碼寫文檔。
3.7 依賴管理
最流行的依賴管理工具有g(shù)odep、vender、gopkg.in 工具
3.7.1 第三方依賴
像 godep 和 vender 這種社區(qū)工具已經(jīng)使用第三方(verdoring)導(dǎo)入路徑重寫這種特性解決了依賴問題。其思想是把所有的依賴包復(fù)制到工程代碼庫中的目錄里,然后使用工程內(nèi)部的依賴包所在目錄來重寫所有的導(dǎo)入路徑。
3.7.2 對 gb 的介紹
gb 背后的原理源自理解到 Go 語言的 import 語句并沒有提供可重復(fù)構(gòu)建的能力。 import語句可以驅(qū)動 go get ,但是 import 本身并沒有包含足夠的信息來決定到底要獲取包的哪個修改的版本。 go get 無法定位待獲取代碼的問題,導(dǎo)致 Go 工具在解決重復(fù)構(gòu)建時,不得不使用復(fù)雜且難看的方法。
gb 的創(chuàng)建源于上述理解。gb 既不包裝 Go 工具鏈,也不使用 GOPATH 。gb 基于工程將 Go 工具鏈工作空間的元信息做替換。這種依賴管理的方法不需要重寫工程內(nèi)代碼的導(dǎo)入路徑。而且導(dǎo)入路徑依舊通過 go get 和 GOPATH 工作空間來管理。gb 工程與 Go 官方工具鏈(包括 go get )并不兼容。
3.8 小結(jié)
在 Go 語言中包是組織代碼的基本單位;?環(huán)境變量 GOPATH 決定了 Go 源代碼在磁盤上被保存、編譯和安裝的位置;可以為每個工程設(shè)置不同的 GOPATH ,以保持源代碼和依賴的隔離;go 工具是在命令行上工作的最好工具;開發(fā)人員可以使用 go get 來獲取別人的包并將其安裝到自己的 GOPATH 指定的目錄;想要為別人創(chuàng)建包很簡單,只要把源代碼放到公用代碼庫,并遵守一些簡單規(guī)則就可以了;Go 語言在設(shè)計時將分享代碼作為語言的核心特性和驅(qū)動力;推薦使用依賴管理工具來管理依賴;有很多社區(qū)開發(fā)的依賴管理工具,如 godep、vender 和 gb。
第4章 數(shù)組、切片、映射
本章主要內(nèi)容：數(shù)組的內(nèi)部實現(xiàn)和基礎(chǔ)功能；使用切片管理數(shù)據(jù)集合；使用映射管理鍵值對。
4.1 數(shù)組的內(nèi)部實現(xiàn)和基礎(chǔ)功能
數(shù)組是切片和映射的基礎(chǔ)數(shù)據(jù)結(jié)構(gòu)。
4.1.1 內(nèi)部實現(xiàn)
數(shù)組存儲的類型可以是內(nèi)置類型,如整型或者字符串,也可以是某種結(jié)構(gòu)類型。數(shù)組的類型信息可以提供每次訪問一個元素時需要在內(nèi)存中移動的距離。
4.1.2 聲明和初始化
聲明一個數(shù)組,并設(shè)置為零值;使用數(shù)組字面量聲明數(shù)組;讓 Go 自動計算聲明數(shù)組的長度；聲明數(shù)組并指定特定元素的值。
4.1.3 使用數(shù)組
訪問數(shù)組元素；訪問指針數(shù)組的元素；把同樣類型的一個數(shù)組賦值給另外一個數(shù)組；把一個指針數(shù)組賦值給另一個指針數(shù)組。
數(shù)組變量的類型包括數(shù)組長度和每個元素的類型。只有這兩部分都相同的數(shù)組,才是類型相同的數(shù)組,才能互相賦值。編譯器會阻止類型不同的數(shù)組互相賦值。
4.1.4 多維數(shù)組
聲明二維數(shù)組，訪問二維數(shù)組的元素，同樣類型的多維數(shù)組賦值，使用索引為多維數(shù)組賦值。
4.1.5 在函數(shù)間傳遞數(shù)組
使用值傳遞,在foo函數(shù)間傳遞大數(shù)組。每次函數(shù) foo 被調(diào)用時,必須在棧上分配 8 MB 的內(nèi)存。之后,整個數(shù)組的值(8 MB 的內(nèi)存)被復(fù)制到剛分配的內(nèi)存里。只傳入指向數(shù)組的指針,這樣只需要復(fù)制 8 字節(jié)的數(shù)據(jù)而不是8 MB 的內(nèi)存數(shù)據(jù)到棧上，使用指針在函數(shù)間傳遞大數(shù)組，這個操作會更有效地利用內(nèi)存,性能也更好。不過要意識到,因為現(xiàn)在傳遞的是指針,所以如果改變指針指向的值,會改變共享的內(nèi)存。如你所見,使用切片能更好地處理這類共享問題。
4.2 切片的內(nèi)部實現(xiàn)和基礎(chǔ)功能
切片是圍繞動態(tài)數(shù)組的概念構(gòu)建的,可以按需自動增長和縮小。切片的動態(tài)增長是通過內(nèi)置函數(shù) append 來實現(xiàn)的。切片的底層內(nèi)存也是在連續(xù)塊中分配的,所以切片還能獲得索引、迭代以及為垃圾回收優(yōu)化的好處。
切片有 3 個字段的數(shù)據(jù)結(jié)構(gòu),這些數(shù)據(jù)結(jié)構(gòu)包含 Go 語言需要操作底層數(shù)組的元數(shù)據(jù)，這 3 個字段分別是指向底層數(shù)組的指針、切片訪問的元素的個數(shù)(即長度)和切片允許增長到的元素個數(shù)(即容量)。
4.2.2 創(chuàng)建和初始化
1.make 和切片字面量?
使用長度聲明一個字符串切片；使用長度和容量聲明整型切片。容量小于長度的切片會在編譯時報錯。
通過切片字面量來聲明切片；使用索引聲明切片；
2.nil 和空切片
只要在聲明時不做任何初始化,就會創(chuàng)建一個 nil 切片。nil 切片可以用于很多標(biāo)準(zhǔn)庫和內(nèi)置函數(shù)。在需要描述一個不存在的切片時, nil 切片會很好用。例如,函數(shù)要求返回一個切片但是發(fā)生異常的時候。
利用初始化,通過聲明一個切片可以創(chuàng)建一個空切片。空切片在底層數(shù)組包含 0 個元素,也沒有分配任何存儲空間。想表示空集合時空切片很有用,例如,數(shù)據(jù)庫查詢返回 0 個查詢結(jié)果時。
4.2.3 使用切片
1.賦值和切片
使用切片字面量來聲明切片；使用切片創(chuàng)建切片。
如何計算長度和容量：
對底層數(shù)組容量是 k 的切片 slice[i:j]來說
長度: j - i
容量: k - i
修改切片內(nèi)容可能導(dǎo)致的結(jié)果。與切片的容量相關(guān)聯(lián)的元素只能用于增長切片。在使用這部分元素前,必須將其合并到切片的長度里。
2.切片增長
使用 append 向切片增加元素；使用 append 同時增加切片的長度和容量；使用 append 同時增加切片的長度和容量。
3.創(chuàng)建切片時的 3 個索引
使用切片字面量聲明一個字符串切片；使用 3 個索引創(chuàng)建切片；
如果試圖設(shè)置的容量比可用的容量還大,就會得到一個語言運行時錯誤。內(nèi)置函數(shù) append 會首先使用可用容量。一旦沒有可用容量,會分配一個
新的底層數(shù)組。這導(dǎo)致很容易忘記切片間正在共享同一個底層數(shù)組。一旦發(fā)生這種情況,對切片
進(jìn)行修改,很可能會導(dǎo)致隨機且奇怪的問題。對切片內(nèi)容的修改會影響多個切片,卻很難找到問
題的原因。
如果在創(chuàng)建切片時設(shè)置切片的容量和長度一樣,就可以強制讓新切片的第一個 append 操作創(chuàng)建新的底層數(shù)組,與原有的底層數(shù)組分離。新切片與原有的底層數(shù)組分離后,可以安全地進(jìn)行后續(xù)修改。內(nèi)置函數(shù) append 也是一個可變參數(shù)的函數(shù)。這意味著可以在一次調(diào)用傳遞多個追加的值。如果使用 ... 運算符,可以將一個切片的所有元素追加到另一個切片里。
4.迭代切片
使用 for range 迭代切片，當(dāng)?shù)衅瑫r,關(guān)鍵字 range 會返回兩個值。第一個值是當(dāng)前迭代到的索引位置,第二個值是該位置對應(yīng)元素值的一份副本。range 創(chuàng)建了每個元素的副本,而不是直接返回對該元素的引用,如果使用該值變量的地址作為指向每個元素的指針,就會造成錯誤。
使用空白標(biāo)識符(下劃線)來忽略索引值。關(guān)鍵字 range 總是會從切片頭部開始迭代。如果想對迭代做更多的控制,依舊可以使用傳
統(tǒng)的 for 循環(huán)，有兩個特殊的內(nèi)置函數(shù) len 和 cap ,可以用于處理數(shù)組、切片和通道。對于切片,函數(shù) len返回切片的長度,函數(shù) cap 返回切片的容量。
4.2.4 多維切片
組合切片的切片
4.2.5 在函數(shù)間傳遞切片
在函數(shù)間傳遞切片就是要在函數(shù)間以值的方式傳遞切片。由于切片的尺寸很小,在函數(shù)間復(fù)制和傳遞切片成本也很低。
4.3 映射的內(nèi)部實現(xiàn)和基礎(chǔ)功能
4.3.1 內(nèi)部實現(xiàn)
映射是無序的集合,意味著沒有辦法預(yù)測鍵值對被返回的順序。無序的原因是映射的實現(xiàn)使用了散列表。映射的散列表包含一組桶。在存儲、刪除或者查找鍵值對的時候,所有操作都要先選擇一個桶。把操作映射時指定的鍵傳給映射的散列函數(shù),就能選中對應(yīng)的桶。這個散列函數(shù)的目的是生成一個索引,這個索引最終將鍵值對分布到所有可用的桶里。
4.3.2 創(chuàng)建和初始化
使用 make 聲明映射，創(chuàng)建映射時,更常用的方法是使用映射字面量。映射的初始長度會根據(jù)初始化時指定的鍵值
對的數(shù)量來確定。
映射的鍵可以是任何值。這個值的類型可以是內(nèi)置的類型,也可以是結(jié)構(gòu)類型,只要這個值可以使用 == 運算符做比較。切片、函數(shù)以及包含切片的結(jié)構(gòu)類型這些類型由于具有引用語義,不能作為映射的鍵,使用這些類型會造成編譯錯誤。
使用映射字面量聲明空映射:
// 創(chuàng)建一個映射,使用字符串切片作為映射的鍵
dict := map[[ ]string]int{ };
聲明一個存儲字符串切片的映射:
// 創(chuàng)建一個映射,使用字符串切片作為值
dict := map[int][ ]string{ }
4.3.3 使用映射
從映射獲取值并判斷鍵是否存在:
// 獲取鍵 Blue 對應(yīng)的值
value, exists := colors["Blue"]
// 這個鍵存在嗎?
if exists {
fmt.Println(value)
}
從映射獲取值,并通過該值判斷鍵是否存在:
// 獲取鍵 Blue 對應(yīng)的值
value := colors["Blue"]
// 這個鍵存在嗎?
if value != "" {
? ? fmt.Println(value)
}
使用 range 迭代映射;
從映射中刪除一項:
// 刪除鍵為 Coral 的鍵值對
delete(colors, "Coral")
// 顯示映射里的所有顏色
for key, value := range colors {
? ? ?fmt.Printf("Key: %s Value: %s\n", key, value)
}
4.3.4 在函數(shù)間傳遞映射
當(dāng)傳遞映射給一個函數(shù),并對這個映射做了修改時,所有對這個映射的引用都會察覺到這個修改。
4.4 小結(jié)
數(shù)組是構(gòu)造切片和映射的基石;
Go 語言里切片經(jīng)常用來處理數(shù)據(jù)的集合,映射用來處理具有鍵值對結(jié)構(gòu)的數(shù)據(jù);內(nèi)置函數(shù) make 可以創(chuàng)建切片和映射,并指定原始的長度和容量。也可以直接使用切片和映射字面量,或者使用字面量作為變量的初始值;切片有容量限制,不過可以使用內(nèi)置的 append 函數(shù)擴展容量;映射的增長沒有容量或者任何限制;內(nèi)置函數(shù) len 可以用來獲取切片或者映射的長度;內(nèi)置函數(shù) cap 只能用于切片;通過組合,可以創(chuàng)建多維數(shù)組和多維切片。也可以使用切片或者其他映射作為映射的值;但是切片不能用作映射的鍵;?將切片或者映射傳遞給函數(shù)成本很小,并且不會復(fù)制底層的數(shù)據(jù)結(jié)構(gòu)。
第 5 章 Go 語言的類型系統(tǒng)
本章主要內(nèi)容：?聲明新的用戶定義的類型；使用方法,為類型增加新的行為；了解何時使用指針,何時使用值；通過接口實現(xiàn)多態(tài)；通過組合來擴展或改變類型；公開或者未公開的標(biāo)識符。
Go 語言是一種靜態(tài)類型的編程語言。值的類型給編譯器提供兩部分信息:第一部分,需要分配多少內(nèi)存給這個值(即值的規(guī)模)
;第二部分,這段內(nèi)存表示什么。對于許多內(nèi)置類型的情況來說,規(guī)模和表示是類型名的一部分。
5.1 用戶定義的類型
//user 在程序里定義一個用戶類型
type user struct {
? ? name ? ?string
? ? email ? string
? ? ext ? ? int
? ? privileged, bool
}?
使用結(jié)構(gòu)類型聲明變量,并初始化為其零值
聲明user類型的變量
var bill user
任何時候,創(chuàng)建一個變量并初始化為其零值,習(xí)慣是使用關(guān)鍵字 var 。如果變量被初始化為某個非零值,就配合結(jié)構(gòu)字面量和短變量
聲明操作符來創(chuàng)建變量。一個短變量(:=)聲明操作符在一次操作中完成兩件事情:聲明一個變量,并初始化。短變量聲明操作符會使用右側(cè)給出的類型信息作為聲明變量的類型。
使用結(jié)構(gòu)字面量創(chuàng)建結(jié)構(gòu)類型的值；不使用字段名,創(chuàng)建結(jié)構(gòu)類型的值；
使用其他結(jié)構(gòu)類型聲明字段:
//admin需要一個user類型作為管理者，并附加權(quán)限
type admin struct {
? ? person user?
? ? level string
}
使用結(jié)構(gòu)字面量來創(chuàng)建字段的值:
// 聲明 admin 類型的變量
fred := admin{
? ? person: user{
? ? name: ? ? ? "Lisa",
? ? email: ? ? ?"lisa@email.com",
? ? ext: ? ? ? ?123,
? ? privileged: true,
? ? },
? ? level: "super",
}
另一種聲明用戶定義的類型的方法是,基于一個已有的類型,將其作為新類型的類型說明。
基于 int64 聲明一個新類型:
type Duration int64
Duration 是一種描述時間間隔的類型,單位是納秒(ns)。這個類型使用內(nèi)置的 int64 類型作為其表示。在 Duration類型的聲明中,我們把 int64 類型叫作 Duration 的基礎(chǔ)類型。不過,雖然 int64 是基礎(chǔ)類型,Go 并不認(rèn)為 Duration 和 int64 是同一種類型。這兩個類型是完全不同的有區(qū)別的類型。
給不同類型的變量賦值會產(chǎn)生編譯錯誤:
package main
type Duration int64
func mian() {
? ? var dur Duration
? ? dur = int64(1000)
}
5.2 方法
方法能給用戶定義的類型添加新的行為。方法實際上也是函數(shù),只是在聲明時,在關(guān)鍵字func 和方法名之間增加了一個參數(shù)
listing11.go
//這個示例程序展示如何聲明
//并使用方法
package main
import (
? ? "fmt"
)
//user在程序里定義一個用戶類型
type user struct {
? ? name string
? ? email string
}
//notify使用值接收者實現(xiàn)了一個方法
func (u user) notify() {
? ? fmt.Printf("Sending User Email To %s<%s>\n",
? ? u.name,
? ? u.email)
}
//changeEmail使用指針接收者實現(xiàn)了一個方法
func (u *user) changeEmail(email string) {
? ? u.email = email
}
//main是應(yīng)用程序的入口
func main() {
? ? //user類型的值可以用來調(diào)用
? ? //使用值接收者聲明的方法
? ? bill := user{"Bill", "bill@email.com"}
? ? bill.notify()
? ??
? ? //指向user類型值的指針也可以用來調(diào)用
? ? //使用值接收者聲明的方法
? ? lisa := &user{"Lisa", "lisa@email.com"}
? ? lisa.notify()
? ??
? ? //user類型的值可以用來調(diào)用
? ? //使用指針接收者聲明方法
? ? bill.changeEmail("bill@newdomain.com")
? ? bill.notify()
? ??
? ? //指向user類型值的指針也可以用來調(diào)用
? ? //使用指針接收者聲明的方法
? ? lisa.changeEmail("lisa@newdomain.com")
? ? lisa.notify()
}
Go 語言里有兩種類型的接收者:值接收者和指針接收者。notify 方法的接收者被聲明為 user 類型的值。如果使用值接收者聲明方法,調(diào)用時會使用這個值的一個副本來執(zhí)行。
使用變量來調(diào)用方法:
bill.notify()
這個語法與調(diào)用一個包里的函數(shù)看起來很類似。但在這個例子里, bill 不是包名,而是變量名。這段程序在調(diào)用 notify 方法時,使用 bill 的值作為接收者進(jìn)行調(diào)用,方法 notify會接收到 bill 的值的一個副本。
值接收者使用值的副本來調(diào)用方法,而指針接受者使用實際值來調(diào)用方法。
5.3 類型的本質(zhì)
在聲明一個新類型之后,聲明一個該類型的方法之前,果給這個類型增加或者刪除某個值,是要創(chuàng)建一個新值,還是要更改當(dāng)前的值?如果是要創(chuàng)建一個新值,該類型的方法就使用值接收者。如果是要修改當(dāng)前值,就使用指針接收者。
5.3.1 內(nèi)置類型
內(nèi)置類型是由語言提供的一組類型,分別是數(shù)值類型、字符串類型和布爾類型。當(dāng)對這些值進(jìn)行增加或者刪除的時候,會創(chuàng)建一個新值。當(dāng)把這些類型的值傳遞給方法或者函數(shù)時,應(yīng)該傳遞一個對應(yīng)值的副本。
5.3.2 引用類型
Go 語言里的引用類型有如下幾個:切片、映射、通道、接口和函數(shù)類型。當(dāng)聲明上述類型當(dāng)聲明上述類型的變量時,創(chuàng)建的變量被稱作標(biāo)頭(header)值。
5.3.3 結(jié)構(gòu)類型
type Time struct {
? ? // sec 給出自公元 1 年 1 月 1 日 00:00:00
? ? // 開始的秒數(shù)
? ? sec int64
? ? // nsec 指定了一秒內(nèi)的納秒偏移,
? ? // 這個值是非零值,
? ? // 必須在[0, 999999999]范圍內(nèi)
? ? nsec int32
? ? // loc 指定了一個 Location,
? ? // 用于決定該時間對應(yīng)的當(dāng)?shù)氐姆帧⑿r、
? ? // 天和年的值
? ? // 只有 Time 的零值,其 loc 的值是 nil
? ? // 這種情況下,認(rèn)為處于 UTC 時區(qū)
? ? loc *Location
}
Time 結(jié)構(gòu)選自 time 包。當(dāng)思考時間的值時,你應(yīng)該意識到給定的一個時間點的時間是不能修改的。
func Now() Time {
? ? sec, nsec := now()
? ? return Time{sec + unixToInternal, nsec, Local}
}
展示了 Now 函數(shù)的實現(xiàn)。這個函數(shù)創(chuàng)建了一個 Time 類型的值,并給調(diào)用者返回了 Time 值的副本。這個函數(shù)沒有使用指針來共享 Time 值。
func (t Time) Add(d Duration) Time {
? ? t.sec += int64(d / 1e9)
? ? nsec := int32(t.nsec) + int32(d%1e9)
? ? if nsec >= 1e9 {
? ? ? ? t.sec++
? ? ? ? nsec -= 1e9
? ? } else if nsec < 0 {
? ? ? ? t.sec--
? ? ? ? nsec += 1e9
? ? }
? ? t.nsec = nsec
? ? return t
}func (t Time) Add(d Duration) Time {
? ? t.sec += int64(d / 1e9)
? ? nsec := int32(t.nsec) + int32(d%1e9)
? ? if nsec >= 1e9 {
? ? ? ? t.sec++
? ? ? ? nsec -= 1e9
? ? } else if nsec < 0 {
? ? ? ? t.sec--
? ? ? ? nsec += 1e9
? ? }
? ? t.nsec = nsec
? ? return t
}
這個方法使用值接收者,并返回了一個新的 Time 值。該方法操作的是調(diào)用者傳入的 Time 值的副本,并且給調(diào)用者返回了一個方法內(nèi)的 Time 值的副本。至于是使用返回的值替換原來的 Time 值,還是創(chuàng)建一個新的 Time 變量來保存結(jié)果,是由調(diào)用者決定的事情。
golang.org/src/os/file_unix.go:
// File 表示一個打開的文件描述符
type File struct {
? ? *file
}
// file 是*File 的實際表示
// 額外的一層結(jié)構(gòu)保證沒有哪個 os 的客戶端
// 能夠覆蓋這些數(shù)據(jù)。如果覆蓋這些數(shù)據(jù),
// 可能在變量終結(jié)時關(guān)閉錯誤的文件描述符
type file struct {
? ? fd int
? ? name string
? ? dirinfo *dirInfo // 除了目錄結(jié)構(gòu),此字段為 nil
? ? nepipe int32 // Write 操作時遇到連續(xù) EPIPE 的次數(shù)
}
標(biāo)準(zhǔn)庫中聲明的 File 類型。這個類型的本質(zhì)是非原始的。這個類型的值實際上不能安全復(fù)制。對內(nèi)部未公開的類型的注釋,解釋了不安全的原因。因為沒有方法阻止程序員進(jìn)行復(fù)制,所以 File 類型的實現(xiàn)使用了一個嵌入的指針,指向一個未公開的類型。
golang.org/src/os/file.go:
func Open(name string) (file *File, err error) {
? ? return OpenFile(name, O_RDONLY, 0)
}
展示了 Open 函數(shù)的實現(xiàn),調(diào)用者得到的是一個指向 File 類型值的指針。Open 創(chuàng)建了 File 類型的值,并返回指向這個值的指針。如果一個創(chuàng)建用的工廠函數(shù)返回了一個指針,就表示這個被返回的值的本質(zhì)是非原始的。即便函數(shù)或者方法沒有直接改變非原始的值的狀態(tài),依舊應(yīng)該使用共享的方式傳遞。
func (f *File) Chdir() error {
? ? if f == nil {
? ? return ErrInvalid
? ? }
? ? if e := syscall.Fchdir(f.fd); e != nil {
? ? return &PathError{"chdir", f.name, e}
? ? }
? ? return nil
}
Chdir 方法展示了,即使沒有修改接收者的值,依然是用指針接收者來聲明的。因為 File 類型的值具備非原始的本質(zhì),所以總是應(yīng)該被共享,而不是被復(fù)制。是使用值接收者還是指針接收者,不應(yīng)該由該方法是否修改了接收到的值來決定。這個決策應(yīng)該基于該類型的本質(zhì)。這條規(guī)則的一個例外是,需要讓類型值符合某個接口的時候,即便類型的本質(zhì)是非原始本質(zhì)的,也可以選擇使用值接收者聲明方法。這樣做完全符合接口值調(diào)用方法的機制。
5.4 接口
多態(tài)是指代碼可以根據(jù)類型的具體實現(xiàn)采取不同行為的能力。如果一個類型實現(xiàn)了某個接口,所有使用這個接口的地方,都可以支持這種類型的值。
5.4.1 標(biāo)準(zhǔn)庫
示例程序?qū)崿F(xiàn)了流行程序 curl 的功能：
listing34.go
//這個示例程序展示如何使用io.Reader和io.Writer接口
//寫一個簡單版本的curl程序
package main
import (
? ? "fmt"
? ? "io"
? ? "net/http"
? ? "os"
)
//init在main函數(shù)之前調(diào)用
func init() {
? ? if len(os.Args) != 2 {
? ? ? ? fmt.Println("Usage: ./example2 <url>")
? ? ? ? os.Exit(-1)
? ? }
}
//main是應(yīng)用程序的入口
func main() {
? ? //從web服務(wù)器得到響應(yīng)
? ? r, err := http.Get(os.Args[1])
? ? if err != nil {
? ? ? ? fmt.Println(err)
? ? ? ? return
? ? }
? ??
? ? //從Body復(fù)制到Stdout
? ? io.Copy(os.Stdout, r.Body)
? ? if err := r.Body.close(); err != nil {
? ? ? ? fmt.Println(err)
? ? }
}
listing35.go
//這個示例程序展示bytes.Buffer也可以
//用于io.Copy函數(shù)
package main
import (
? ? "bytes"
? ? "fmt"
? ? "io"
? ? "os"
)
//main是應(yīng)用程序的入口
func main() {
? ? var b bytes.Buffer
? ??
? ? //將字符串寫入Buffer
? ? b.Writer([]byte("Hello"))
? ??
? ? //使用Fprintf將字符串拼接到Buffer
? ? fmt.Fprintf(&b, "world!")
? ??
? ? //將Buffer的內(nèi)容寫到Stdout
? ? io.Copy(os.Stdout, &b)
}
這個程序使用接口來拼接字符串,并將數(shù)據(jù)以流的方式輸出到標(biāo)準(zhǔn)輸出設(shè)備。
5.4.2 實現(xiàn)
接口是用來定義行為的類型。這些被定義的行為不由接口直接實現(xiàn),而是通過方法由用戶定義的類型實現(xiàn)。
圖 5-1 實體值賦值后接口值的簡圖
圖 5-2 實體指針賦值后接口值的簡圖
5.4.3 方法集
方法集定義了接口的接受規(guī)則。
listing36.go
//這個示例程序展示Go語言里如何使用接口
package main
import (
? ? "fmt"
)
//notifier是一個定義了
//通知類行為的接口
type notifier interface {
? ? notify()
}
//user在程序里定義一個用戶類型
type user struct {
? ? name string
? ? email string
}
//notify是使用指針接收者實現(xiàn)的方法
func (u *user) notify() {
? ? fmt.Printf("Sending user email to %s<%s>\n",
? ? ? ? u.name,
? ? ? ? u.email)
}
//main是應(yīng)用程序的入口
func main() {
? ? //創(chuàng)建一個user類型的值，并發(fā)送通知
? ? u := user{"Bill", "bill@email.com"}
? ??
? ? sendNotification(u)
? ??
? ? // ./listing36.go:32: 不能將u（類型是user）作為
? ? // ? ? ? ? ? ? ? ? ? ? ?sendNotification的參數(shù)類型notifier：
? ? // user類型并沒有實現(xiàn)notifier
? ? // ? ? ? ? ? ? ? ? ? ? ?（notifier方法使用指針接收者聲明）
}
//sendNotification接受一個實現(xiàn)了notifier接口的值
//并發(fā)送通知
func sendNotification(n notifier) {
? ? n.notify()
}
程序雖然看起來沒問題,但實際上卻無法通過編譯。用指針接收者來實現(xiàn)接口時為什么 user 類型的值無法實現(xiàn)該接口,需要先了解方法集。方法集定義了一組關(guān)聯(lián)到給定類型的值或者指針的方法。定義方法時使用的接收者的類型決定了這個方法是關(guān)聯(lián)到值,還是關(guān)聯(lián)到指針,還是兩個都關(guān)聯(lián)。
規(guī)范里描述的方法集
Values ? ? ?Methods Receivers
-----------------------------------------------
T ? ? ? ? ? (t T)
*T ? ? ? ? ?(t T) and (t *T)
從接收者類型的角度來看方法集
Methods Receivers ? Values
-----------------------------------------------
(t T) ? ? ? ? ? ? ? T and *T
(t *T) ? ? ? ? ? ? ?*T
編譯器并不是總能自動獲得一個值的地址
package main
import "fmt"
//duration是一個給予int類型的類型
type duration int
//duration是一個基于int類型的類型
type duration int
//使用更可讀的方式格式化duration值
func (d *duration) pretty() string {
? ? return fmt.Springf("Duration:%d", *d)
}
//main是應(yīng)用程序的入口
func main() {
? ? duration(42).pretty()
? ??
? ? // ./listing46.go:17: 不能通過指針調(diào)用duration(42)的方法
? ? // ./listing46.go:17: 不能獲取duration(42)的方法
}
5.4.4 多態(tài)
//這個示例程序使用接口展示多態(tài)行為
package main
import (
? ? "fmt"
)
//notifier是一個定義了
//通知類行為的接口
type notifier interface {
? ? notify()
}
//user在程序定義了一個用戶類型
type user struct {
? ? name string
? ? email string
}
//notify使用指針接收者實現(xiàn)了notifier接口
func (u *user) notify() {
? ? fmt.Printf("Sending user email to %s<%s>\n",
? ? ? ? u.name,
? ? ? ? u.email)
}
//admin定義了程序里的管理員
type admin struct {
? ? name string
? ? email string
}
//notify使用指針接收者實現(xiàn)了notifier接口
func (a *admin) notify() {
? ? fmt.Printf("Sending admin email to %s<%s>\n",
? ? ? ? a.name,
? ? ? ? a.email)
}
//main是應(yīng)用程序的入口
func main() {
? ? //創(chuàng)建一個user值并傳給sendNotificcation
? ? bill := user{"Bill", "bill@email.com"}
? ? sendNotification(&lisa)
}
//sendNotification接受一個實現(xiàn)了notifier接口的值
//并發(fā)送通知
func sendNotification(n notifier) {
? ? n.notify()
}
5.5 嵌入類型
Go 語言允許用戶擴展或者修改已有類型的行為。這個功能對代碼復(fù)用很重要,在修改已有類型以符合新類型的時候也很重要。嵌入類型是將已有的類型直接聲明在新的結(jié)構(gòu)類型里。被嵌入的類型被稱為新的外部類型的內(nèi)部類型。通過嵌入類型,與內(nèi)部類型相關(guān)的標(biāo)識符會提升到外部類型上。
//這個示例程序展示如何將一個類型嵌入另一個類型，以及
//內(nèi)部類型和外部類型之間的關(guān)系
package main
import (
? ? "fmt"
)
//user在程序里定義一個用戶類型
type user struct {
? ? name string
? ? email string
}
//notify實現(xiàn)了一個可以通過user類型值的指針
//調(diào)用的方法
func (u *user) notify() {
? ? fmt.Printf("Sending user email to %s<%s>\n",
? ? u.name,
? ? u.email)
}
//admin 代表一個擁有權(quán)限的管理員用戶
type admin struct {
? ? user //嵌入類型?
? ? level string?
}
//main是應(yīng)用程序的入口
func main() {
? ? //創(chuàng)建一個admin用戶
? ? ad := admin{
? ? ? ? user : user{
? ? ? ? ? ? name: "john smith",
? ? ? ? ? ? email: "john@yahoo.com",
? ? ? ? },
? ? ? ? level: "super",
? ? }
? ??
? ? //我們可以直接訪問內(nèi)部類型的方法
? ? ad.user.notify()
? ??
? ? //內(nèi)部類型的方法也被提升到外部類型
? ? ad.notify()
}
如何將嵌入類類型應(yīng)用于接口
package main
import (
? ? "fmt"
)
//notifier是一個定義了
//通知類行為的接口
type notifier interface {
? ? notify()
}
//user在程序里定義一個用戶類型
type user struct {
? ? name string
? ? email string
}
//通過user類型值的指針
//調(diào)用的方法
func (u *user) notify() {
? ? fmt.Printf("Sending user email to %s<%s>\n",
? ? u.name,
? ? u.email)
}
//admin代表一個擁有權(quán)限的管理員用戶
type admin struct {
? ? user
? ? level string
}
//main是應(yīng)用程序的入口
func main() {
? ? //創(chuàng)建一個admin用戶
? ? ad := admin{
? ? ? ? user: user{
? ? ? ? ? ? name: "john smith",
? ? ? ? ? ? email: "john@yahoo.com",
? ? ? ? },
? ? ? ? level: "super",
? ? }
? ??
? ? //給admin用戶發(fā)送一個通知
? ? //用于實現(xiàn)接口的內(nèi)部類型的方法，被提升到
? ? //外部類型
? ? sendNotification(&ad)
}
//sendNotification接受一個實現(xiàn)了notifier接口的值
//并發(fā)送通話
func sendNotification(n notifier) {
? ? n.notify()
}
示例程序展示當(dāng)內(nèi)部類型和外部類型要實現(xiàn)同一個接口時的做法
package main
import (
? ? "fmt"
)
//notifier是一個定義了
//通知類行為的接口
type notifier interface {
? ? notify()
}
//user在程序里定義一個用戶類型
type user struct {
? ? name string
? ? email string
}
//通過user類型值的指針
//調(diào)用的方法
func (u *user) notify() {
? ? fmt.Printf("Sending user email to %s<%s>\n",
? ? ? ? u.name,
? ? ? ? u.email)
}
//admin代表一個擁有權(quán)限的管理員用戶
type admin struct {
? ? user
? ? level string
}
//通過admin類型值的指針
//調(diào)用的方法
func (a *admin) notify() {
? ? fmt.Printf("Sending admin email to %s<%s>\n",
? ? ? ? a.name,
? ? ? ? a.email)
}
//main是應(yīng)用程序的入口
func main() {
? ? //創(chuàng)建一個admin用戶
? ? ad := admin{
? ? ? ? user: user{
? ? ? ? ? ? name: "john smith",
? ? ? ? ? ? email: "john@yahoo.com",
? ? ? ? },
? ? ? ? level: "super",
? ? }
? ??
? ? //給admin用戶發(fā)送一個通知
? ? //接口的嵌入的內(nèi)部類型實現(xiàn)并沒有替升到
? ? //外部類型
? ? sendNotification(&ad)
? ??
? ? //我們可以直接訪問內(nèi)部類型的方法
? ? ad.user.notify()
? ??
? ? //內(nèi)部類型的方法沒有被提升
? ? ad.notify()
}
//sendNotification接受一個實現(xiàn)了notifier接口的值
//并發(fā)送通知
func sendNotification(n notifier) {
? ? n.notify()
}
listing60.go 的輸出
Sending admin email to john smith<john@yahoo.com>
Sending user email to john smith<john@yahoo.com>
Sending admin email to john smith<john@yahoo.com>
這次我們看到了 admin 類型是如何實現(xiàn) notifier 接口的,以及如何由 sendNotification函數(shù)以及直接使用外部類型的變量 ad 來執(zhí)行 admin 類型實現(xiàn)的方法。這表明,如果外部類型實現(xiàn)了 notify 方法,內(nèi)部類型的實現(xiàn)就不會被提升。不過內(nèi)部類型的值一直存在,因此還可以通過直接訪問內(nèi)部類型的值,來調(diào)用沒有被提升的內(nèi)部類型實現(xiàn)的方法。
5.6 公開或未公開的標(biāo)識符
當(dāng)一個標(biāo)識符的名字以小寫字母開頭時,這個標(biāo)識符就是未公開的,即包外的代碼不可見。如果一個標(biāo)識符以大寫字母開頭,這個標(biāo)識符就是公開的,即被包外的代碼可見。
例子已經(jīng)修改為使用工廠函數(shù)來創(chuàng)建一個未公開的 alertCounter 類型的值。
// counters 包提供告警計數(shù)器的功能
package counters
// alertCounter 是一個未公開的類型05
// 這個類型用于保存告警計數(shù)
type alertCounter int
// New 創(chuàng)建并返回一個未公開的
// alertCounter 類型的值
func New(value int) alertCounter {
? ? return alertCounter(value)
}
將工廠函數(shù)命名為 New 是 Go 語言的一個習(xí)慣。這個 New 函數(shù)做了些有意思的事情:它創(chuàng)建了一個未公開的類型的值,并將這個值返回給調(diào)用者。
/ main 是應(yīng)用程序的入口
func main() {
? ? // 使用 counters 包公開的 New 函數(shù)來創(chuàng)建
? ? // 一個未公開的類型的變量
? ? counter := counters.New(10)
? ? fmt.Printf("Counter: %d\n", counter)
?}
這個 New 函數(shù)返回的值被賦給一個名為 counter 的變量。這個程序可以編譯并且運行,要讓這個行為可行,需要兩個理由。第一,公開或者未公開的標(biāo)識符,不是一個值。第二,短變量聲明操作符,有能力捕獲引用的類型,并創(chuàng)建一個未公開的類型的變量。永遠(yuǎn)不能顯式創(chuàng)建一個未公開的類型的變量,不過短變量聲明操作符可以這么做。
由于內(nèi)部類型 user 是未公開的,這段代碼無法直接通過結(jié)構(gòu)字面量的方式初始化該內(nèi)部類型。不過,即便內(nèi)部類型是未公開的,內(nèi)部類型里聲明的字段依舊是公開的。既然內(nèi)部類型的標(biāo)識符提升到了外部類型,這些公開的字段也可以通過外部類型的字段的值來訪問。
5.7 小結(jié)
使用關(guān)鍵字 struct 或者通過指定已經(jīng)存在的類型,可以聲明用戶定義的類型;方法提供了一種給用戶定義的類型增加行為的方式;設(shè)計類型時需要確認(rèn)類型的本質(zhì)是原始的,還是非原始的;接口是聲明了一組行為并支持多態(tài)的類型;嵌入類型提供了擴展類型的能力,而無需使用繼承;?標(biāo)識符要么是從包里公開的,要么是在包里未公開的。
第6章 并發(fā)
本章主要內(nèi)容：使用 goroutine 運行程序；檢測并修正競爭狀態(tài)；利用通道共享數(shù)據(jù)。
Web 服務(wù)需要在各自獨立的套接字(socket)上同時接收多個數(shù)據(jù)請求。每個套接字請求都是獨立的,可以完全獨立于其他套接字進(jìn)行處理 。具有并行執(zhí)行多個請求的能力可以顯著提高這類系統(tǒng)的性能。Go 語言里的并發(fā)指的是能讓某個函數(shù)獨立于其他函數(shù)運行的能力。當(dāng)一個函數(shù)創(chuàng)建為 goroutine時,Go 會將其視為一個獨立的工作單元。
Go 語言里的并發(fā)指的是能讓某個函數(shù)獨立于其他函數(shù)運行的能力。Go 語言的并發(fā)同步模型來自一個叫作通信順序進(jìn)程(Communicating Sequential Processes, CSP)的范型(paradigm)。CSP 是一種消息傳遞模型,通過在 goroutine 之間傳遞數(shù)據(jù)來傳遞消息,而不是對數(shù)據(jù)進(jìn)行加鎖來實現(xiàn)同步訪問。用于在 goroutine 之間同步和傳遞數(shù)據(jù)的關(guān)鍵數(shù)據(jù)類型叫作通道(channel)。
6.1 并發(fā)與并行
什么是操作系統(tǒng)的線程(thread)和進(jìn)程(process)。一個線程是一個執(zhí)行空間,這個空間會被操作系統(tǒng)調(diào)度來運行函數(shù)中所寫的代碼。每個進(jìn)程至少包含一個線程,每個進(jìn)程的初始線程被稱作主線程。因為執(zhí)行這個線程的空間是應(yīng)用程序的本身的空間,所以當(dāng)主線程終止時,應(yīng)用程序也會終止。
FIFO:先進(jìn)先出調(diào)度算法LRU:最近最久未使用調(diào)度算法兩者都是緩存調(diào)度算法,經(jīng)常用作內(nèi)存的頁面置換算法。
線程調(diào)度算法：1、先來先服務(wù)(FCFS) ?2、最短作業(yè)優(yōu)先（SJF） 3、基于優(yōu)先權(quán)的調(diào)度算法（FPPS） 4、時間片輪轉(zhuǎn)（RR） 5、多級隊列調(diào)度（Multilevel feedback queue）
搶占式、非搶占式
圖 6-1 一個運行的應(yīng)用程序的進(jìn)程和線程的簡要描繪
在圖 6-2 中,可以看到操作系統(tǒng)線程、邏輯處理器和本地運行隊列之間的關(guān)系。
圖 6-2 Go 調(diào)度器如何管理 goroutine?
并發(fā)(concurrency)不是并行(parallelism)。并行是讓不同的代碼片段同時在不同的物理處理器上執(zhí)行。并行的關(guān)鍵是同時做很多事情,而并發(fā)是指同時管理很多事情,這些事情可能只做了一半就被暫停去做別的事情了。
6.2 goroutine
深入了解一下調(diào)度器的行為,以及調(diào)度器是如何創(chuàng)建 goroutine 并管理其壽命的。
//這個示例程序展示如何創(chuàng)建goroutine
//以及調(diào)度器的行為\
package main
import (
? ? "fmt"
????"runtime"
????"sync"
)
//main是所有Go程序的入口
func main() {
????//分配一個邏輯處理器給調(diào)度器使用
????runtime.GOMAXPROCS(1)
????
????//wg用來等待程序完成
????//計數(shù)加2，表示要等待兩個goroutine
????var wg sync.WaitGroup
????wg.add(2)
????
????fmt.Println("Start Goroutines")
????go func() {
????????//在函數(shù)退出時調(diào)用Done來通知main函數(shù)工作已經(jīng)完成
????????defer wg.Done()
????????
????????//顯示字母表3次
????????for count := 0; count < 3; count++ {
????????????for char := 'a'; char < 'a'+26; char++ {
????????????????fmt.Printf("%c, char")
????????????}
????????}
????}()
????
????//聲明一個匿名函數(shù)，并創(chuàng)建一個goroutine
????go func() {
????????//在函數(shù)退出時調(diào)用Done來通知mian函數(shù)工作已經(jīng)完成
????????defer wg.Done()
????????
????????//顯示字母表3次
????????for count := 0; count < 3; count++ {
????????????for char := 'A'; char < 'A'+26; char++ {
????????????????fmt.Printf("%c", char)
????????????}
????????}
????}()
????
????//等待goroutine結(jié)束
????fmt.Println("Waiting to Finish")
????wg.Wait()
????
????fmt.Println("\nTerminating Program")
}
基于調(diào)度器的內(nèi)部算法,一個正運行的 goroutine 在工作結(jié)束前,可以被停止并重新調(diào)度。調(diào)度器這樣做的目的是防止某個 goroutine 長時間占用邏輯處理器。當(dāng) goroutine 占用時間過長時,調(diào)度器會停止當(dāng)前正運行的 goroutine,并給其他可運行的 goroutine 運行的機會。
//這個示例程序展示goroutine調(diào)度器是如何在單個程序上
//切分時間片的
package main
import (
????"fmt"
????"runtime"
????"sync"
)
//wg用來等待程序完成
var wg sync.WaitGroup
//main是所有Go程序的入口
func main() {
????//分配一個邏輯處理器給調(diào)度器使用
????runtime.GOMAXPROCX(1)
????//計數(shù)加2，表示要等待兩個goroutine
????wg.Add(2)
????
????//創(chuàng)建兩個goroutine
????fmt.Println("Create Goroutines")
????go printPrime("A")
????go printPrime("B")
????
????//等待goroutine結(jié)束
????fmt.Println("Waiting To Finish")
????wg.Wait()
????
????fmt.Println("Terminating Program")
}
//printPrime顯示5000以內(nèi)的素數(shù)值
func printPrime(prefix string) {
????//函數(shù)退出時調(diào)用Done來通知main函數(shù)工作已經(jīng)完成
????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", prefix, outer)
????}
????fmt.Println("Completed", prefix)
}
6.3 競爭狀態(tài)
如果兩個或者多個 goroutine 在沒有互相同步的情況下,訪問某個共享的資源,并試圖同時讀和寫這個資源,就處于相互競爭的狀態(tài),這種情況被稱作競爭狀態(tài)(race candition)。對一個共享資源的讀和寫操作必須是原子化的,換句話說,同一時刻只能有一個 goroutine 對共享資源進(jìn)行讀和寫操作。
// 這個示例程序展示如何在程序里造成競爭狀態(tài)
// 實際上不希望出現(xiàn)這種情況
package main
import (
????"fmt"
????"runtime"
????"sync"
)
var (
????//counter是所有g(shù)oroutine都要增加其值的變量
????counter int
????//wg用來等待程序結(jié)束
????wg.sync.WaitGroup
)
//main是所有Go程序的入口
func main() {
????//計數(shù)加2，表示要等待兩個goroutine
????wg.Add(2)
????
????//創(chuàng)建兩個goroutine
????go printPrime("A")
????go printPrime("B")
????
????//等待goroutine結(jié)束
????wg.Wait()
????
????fmt.Println("Final Counter:", counter)
}
//incCounter增加包里counter變量的值
func incCounter(id int) {
????//在函數(shù)退出時調(diào)用Done來通知main函數(shù)工作已經(jīng)完成
????defer wg.Done()
????
????for count := 0; count < 2; count++ {
????????//捕獲counter的值
????????value := counter
????????
????????//當(dāng)前goroutine從線程退出，并放回到隊列
????????runtime.Gosched()
????????
????????//增加本地value變量的值
????????value++
????????
????????//將改值保存回counter
????????counter = value
????}
}
go build -race // 用競爭檢測器標(biāo)志來編譯程序
./example ???// 運行程序
一種修正代碼、消除競爭狀態(tài)的辦法是,使用 Go 語言提供的鎖機制,來鎖住共享資源,從而保證 goroutine 的同步狀態(tài)。
6.4 鎖住共享資源
6.4.1 原子函數(shù)
原子函數(shù)能夠以很底層的加鎖機制來同步訪問整型變量和指針。我們可以用原子函數(shù)來修正代碼清單創(chuàng)建的競爭狀態(tài)。
// 這個示例程序展示如何使用 atomic 包來提供
// 對數(shù)值類型的安全訪問
package main
import (
????"fmt"
????"runtime"
????"sync"
????"sync/atomic"
)
var (
????//counter是所有g(shù)oroutine都要增加其值的變量
????counter int64
????//wg用來等待程序結(jié)束
????wg.sync.WaitGroup
)
//main是所有Go程序的入口
func main() {
????//計數(shù)加2，表示要等待兩個goroutine
????wg.Add(2)
????
????//創(chuàng)建兩個goroutine
????go incCounter(1)
????go incCounter(2)
????
????//等待goroutine結(jié)束
????wg.Wait()
????//現(xiàn)實最終的值
????fmt.Println("Final Counter:", counter)
}
//incCounter增加包里counter變量的值
func incCounter(id int) {
????//在函數(shù)退出時調(diào)用Done來通知main函數(shù)工作已經(jīng)完成
????defer wg.Done()
????
????for count := 0; count < 2; count++ {
????????//安全地對counter加1
????????atomic.AddInt64(&counter, 1)
????????
????????//當(dāng)前goroutine從線程退出，并放回到隊列
????????runtime.Gosched()
????}
}
Final Counter: 4
現(xiàn)在,程序的第 43 行使用了 atmoic 包的 AddInt64 函數(shù)。這個函數(shù)會同步整型值的加法,方法是強制同一時刻只能有一個 goroutine 運行并完成這個加法操作。當(dāng) goroutine 試圖去調(diào)用任何原子函數(shù)時,這些 goroutine 都會自動根據(jù)所引用的變量做同步處理。現(xiàn)在我們得到了正確的值 4。
另外兩個有用的原子函數(shù)是 LoadInt64 和 StoreInt64 。這兩個函數(shù)提供了一種安全地讀和寫一個整型值的方式。
// 這個示例程序展示如何使用 atomic 包里的
// Store 和 Load 類函數(shù)來提供對數(shù)值類型
package main
import (
????"fmt"
????"sync"
????"sync/atomic"
????"time"
)
var (
????//shutdown是通知正在執(zhí)行的goroutine停止工作的標(biāo)志
????shutdown int64
????
????//wg用來等待程序結(jié)束
????wg.sync.WaitGroup
)
//main是所有Go程序的入口
func main() {
????//計數(shù)加2，表示要等待兩個goroutine
????wg.Add(2)
????
????//創(chuàng)建兩個goroutine
????go doWork("A")
????go doWork("B")
????
????//給定goroutine執(zhí)行的時間
????time.Sleep(1 * time.Second)
????
????//該停止工作了，安全地設(shè)置shutdown標(biāo)志
????fmt.Println("Shutdown Now")
????atomic.StoreInt64(&shutdown, 1)
????
????//等待goroutine結(jié)束
????wg.Wait()
}
//doWork用來模擬執(zhí)行工作的goroutine，
//檢測之前的shutdown標(biāo)志來決定是否提前終止
func doWork(name string) {
????//在函數(shù)退出時調(diào)用Done來通知main函數(shù)工作已經(jīng)完成
????defer wg.Done()
????
????for {
????????fmt.Printf("Doing %s Work\n", name)
????????time.Sleep(250* time.Millisecod)
????????//要停止工作了嗎
????????if ?atomic.AddInt64(&counter, 1) == 1 {
????????????fmt.Printf("Shutting %sl0wen", name)
????????????break
????????}
????}
}
6.4.2 互斥鎖
另一種同步訪問共享資源的方式是使用互斥鎖( mutex )。互斥鎖用于在代碼上創(chuàng)建一個臨界區(qū),保證同一時間只有一個 goroutine 可以執(zhí)行這個臨界區(qū)代碼。
// 這個示例程序展示如何使用互斥鎖來
// 定義一段需要同步訪問的代碼臨界區(qū)
// 資源的同步訪問
package main
import (
????"fmt"
????"runtime"
????"sync"
)
var (
????//counter是所有g(shù)oroutine都要增加其值的變量
????counter int
????
????//wg用來等待程序結(jié)束
????wg.sync.WaitGroup
)
//main是所有Go程序的入口
func main() {
????//計數(shù)加2，表示要等待兩個goroutine
????wg.Add(2)
????
????//創(chuàng)建兩個goroutine
????go incCounter(1)
????go incCounter(2)
????
????//等待goroutine結(jié)束
????wg.Wait()
????fmt.Printf("Final Counter: %d\\n", counter)
}
//incCounter使用互斥鎖來同步并保證安全訪問
//增加包里counter變量的值
func incCounter(id int) {
????//在函數(shù)退出時調(diào)用Done來通知main函數(shù)工作已經(jīng)完成
????defer wg.Done()
????
????for count := 0; count < 2; counter++ {
????????//同一時刻只允許一個goroutine進(jìn)入
????????//這個臨界區(qū)
????????mutex.Lock()
????????{
????????????//捕獲counter的值
????????????value := counter
????????????
????????????//當(dāng)前goroutine從線程退出，并放回到隊列
????????????runtime.Gosched()
????????????
????????????//增加本地value變量的值
????????????value++
????????????
????????????//將該值保存回counter
????????????counter = value
????????}
????????mutex.Unlock()
????????//釋放鎖，允許其他正在等待的goroutine
????????//進(jìn)入臨界區(qū)
????}
}
6.5 通道
在 Go 語言里,你不僅可以使用原子函數(shù)和互斥鎖來保證對共享資源的安全訪
問以及消除競爭狀態(tài),還可以使用通道,通過發(fā)送和接收需要共享的資源,在 goroutine 之間做同步。
使用 make 創(chuàng)建通道
//無緩沖的整型通道
unbuffered := make(chan int)
//有緩沖的整型通道
buffered := make(chan string, 10)
//向通道發(fā)送值
// 通過通道發(fā)送一個字符串
buffered <- "Gopher"
// 從通道接收一個字符串
value := <-buffered
6.5.1 無緩沖的通道
無緩沖的通道(unbuffered channel)是指在接收前沒有能力保存任何值的通道。這種類型的通道要求發(fā)送 goroutine 和接收 goroutine 同時準(zhǔn)備好,才能完成發(fā)送和接收操作。如果兩個 goroutine沒有同時準(zhǔn)備好,通道會導(dǎo)致先執(zhí)行發(fā)送或接收操作的 goroutine 阻塞等待。這種對通道進(jìn)行發(fā)送和接收的交互行為本身就是同步的。其中任意一個操作都無法離開另一個操作單獨存在。
// 這個示例程序展示如何用無緩沖的通道來模擬
// 2 個 goroutine 間的網(wǎng)球比賽
package main
import (
????"fmt"
????"math/rand"
????"sync"
????"time"
)
//wg用來等待程序結(jié)束
var wg sync.WaitGroup
func init() {
????rand.Seed(time.Now().UnixNano())
}
//main是所有Go程序的入口
func main() {
????//創(chuàng)建一個無緩沖的通道
????court := make(chan int)
????
????//計數(shù)加2，表示要等待兩個goroutine
????wg.Add(2)
????
????//啟動兩個選手
????go player("Nadal", court)
????go player("Djokovic", court)
????
????//發(fā)球(將球發(fā)到通道里)
????court <- -1
????
????//等待游戲結(jié)束
????wg.Wait()
}
//player模擬一個選手在打網(wǎng)球
func player(name string, court chan int) {
????//在函數(shù)退出時調(diào)用Done來通知main函數(shù)工作已經(jīng)完成
????defer wg.Done()
????
????for {
????????//等待球被擊打過來
//goroutine 從通道接收數(shù)據(jù),用來表示等待接球。這個接收動作會鎖住//goroutine,直到有數(shù)據(jù)發(fā)送到通道里。
????????ball, ok := <-court
????????if !ok {
????????????//如果通道被關(guān)閉，我們就贏了
????????????fmt.Printf("Player %s Won\n", name)
????????????return
????????}
????????
????????//選隨機數(shù)，然后用這個數(shù)來判斷我們是否丟球
????????n := rand.Intn(100)
????????if n%13 == 0 {
????????????fmt.Printf("Player %s Missed\n", name)
????????
????????????//關(guān)閉通道，表示我們輸了
????????????close(court)
????????????return
????????}
????????//顯示擊球數(shù)，并將擊球數(shù)加1
????????fmt.Printf("Player %s Hit %d\n", name, ball)
????????ball++
????????
????????//將球打向?qū)κ?/p>
????????court <- ball
????}
}
// 這個示例程序展示如何用無緩沖的通道來模擬
// 4 個 goroutine 間的接力比賽
package main
import (
????"fmt"
????"sync"
????"time"
)
//wg用來等待程序結(jié)束
var wg sync.WaitGroup
//main是所有Go程序的入口
func main() {
????//創(chuàng)建一個無緩沖的通道
????court := make(chan int)
????
????//為最后一位跑步者將計數(shù)加1
????wg.Add(1)
????
????//第一位跑步者持有接力棒
????go Runner(baton)
????
????//開始比賽
????baton <- -1
????
????//等待比賽結(jié)束
????wg.Wait()
}
//Runner模擬一個選手在打網(wǎng)球
func Runner(baton chan int) {
????var newRunner int
????
????//等待接力棒
????runner := <-baton
????
????//開始繞著跑道跑步
????fmt.Printf("Runner %d Running With Baton\n", runner)
????
????//創(chuàng)建下一位跑步者
????if runner != 4 {
????????newRunner = runer + 100
????????fmt.Printf("Runner %d To The Line\n", newRunner)
????????go Runner(baton)
????}
????
????//圍繞跑到跑
????time.Sleep(100 * time.Millisecond)
????
????//比賽結(jié)束了嗎？
????if runner == 4 {
????????????fmt.Printf("Runner %d Finished, Race Over\n", runner)
????????????wg.Done()
????????????return
????????}
????????
????????//將接力棒交給下一位跑步者
????????fmt.Printf("Runner %d Exchange With Runner %d\n",
????????????runner,
????????????newRunner)
????????
????????baton <- newRunner
????}
}
6.5.2 有緩沖的通道
有緩沖的通道(buffered channel)是一種在被接收前能存儲一個或者多個值的通道。這種類型的通道并不強制要求 goroutine 之間必須同時完成發(fā)送和接收。通道會阻塞發(fā)送和接收動作的條件也會不同。只有在通道中沒有要接收的值時,接收動作才會阻塞。只有在通道沒有可用緩沖區(qū)容納被發(fā)送的值時,發(fā)送動作才會阻塞。這導(dǎo)致有緩沖的通道和無緩沖的通道之間的一個很大的不同:無緩沖的通道保證進(jìn)行發(fā)送和接收的 goroutine 會在同一時間進(jìn)行數(shù)據(jù)交換;有緩沖的通道沒有這種保證。
// 這個示例程序展示如何使用
// 有緩沖的通道和固定數(shù)目的
// goroutine 來處理一堆工作
package main
import (
????"fmt"
????"math/rand"
????"sync"
????"time"
)
const (
????numberGoroutines = 4 //要使用的goroutine的數(shù)量
????taskLoad ????????= 10 //要處理的工作的數(shù)量
)
//wg用來等待程序結(jié)束
var wg sync.WaitGroup
//init初始化包，Go語言運行時會在其他代碼執(zhí)行之前
//優(yōu)先執(zhí)行這個函數(shù)
func init() {
????//初始化隨機數(shù)種子
????rand.Seed(time.Now().Unix())
}
//main是所有Go程序的入口
func main() {
????//創(chuàng)建一個有緩沖的通道來管理工作
????task := make(chan string, taskLoad)
????
????//啟動goroutine來處理工作
????wg.Add(numberGoroutines)
????for gr := 1; gr <= numberGoroutines; gr++ {
????????go worker(tasks, gr)
????}
????
????//增加一組要完成的工作
????for post := 1; post <= taskLoad; post++ {
????????tasks <- fmt.Sprintf("Task : %d", post)
????}
????
????//當(dāng)所有工作都處理完時關(guān)閉通道
????//以便所有g(shù)oroutine退出
????close(tasks)
????
????
????//等待所有工作完成
????wg.Wait()
}
//worker作為goroutine啟動處理
//從有緩存的通道傳入的工作
func worker(tasks chan string, worker int) {
????//通知函數(shù)已經(jīng)返回
????defer wg.Done()
????
????for {
????????//等待分配工作
????????task, ok := <-tasks
????????if !ok {
????????????//這意味著通道已經(jīng)空了，并且已被關(guān)閉
????????????fmt.Printf("Worker: %d : Shutting Down\n", worker)
????????????return
????????}
????????
????????//顯示我們開始工作了
????????fmt.Printf("Worker: %d : Started %s\n", worker, task)
????????
????????//隨機等一段時間來模擬工作
????????sleep := rand.Int63n(100)
????????time.Sleep(time.Duration(sleep) * time.Millisecond)
????????
????????//顯示我們完成了工作
????????fmt.Printf("Worker: %d : Completed %s\n", worker, task)
????}
}
當(dāng)通道關(guān)閉后,goroutine 依舊可以從通道接收數(shù)據(jù),但是不能再向通道里發(fā)送數(shù)據(jù)。能夠從已經(jīng)關(guān)閉的通道接收數(shù)據(jù)這一點非常重要,因為這允許通道關(guān)閉后依舊能取出其中緩沖的全部值,而不會有數(shù)據(jù)丟失。從一個已經(jīng)關(guān)閉且沒有數(shù)據(jù)的通道
里獲取數(shù)據(jù),總會立刻返回,并返回一個通道類型的零值。如果在獲取通道時還加入了可選的標(biāo)志,就能得到通道的狀態(tài)信息。
6.6 小結(jié)
并發(fā)是指 goroutine 運行的時候是相互獨立的;使用關(guān)鍵字 go 創(chuàng)建 goroutine 來運行函數(shù);goroutine 在邏輯處理器上執(zhí)行,而邏輯處理器具有獨立的系統(tǒng)線程和運行隊列;競爭狀態(tài)是指兩個或者多個 goroutine 試圖訪問同一個資源;原子函數(shù)和互斥鎖提供了一種防止出現(xiàn)競爭狀態(tài)的辦法;通道提供了一種在兩個 goroutine 之間共享數(shù)據(jù)的簡單方法;無緩沖的通道保證同時交換數(shù)據(jù),而有緩沖的通道不做這種保證。
第7章 并發(fā)模式
本章主要內(nèi)容：控制程序的生命周期；管理可復(fù)用的資源池；創(chuàng)建可以處理任務(wù)的 goroutine 池。
7.1 runner
runner 包用于展示如何使用通道來監(jiān)視程序的執(zhí)行時間,如果程序運行時間太長,也可以用 runner 包來終止程序。
// Gabriel Aszalos 協(xié)助完成了這個示例
// runner 包管理處理任務(wù)的運行和生命周期
package runner
import (
????"errors"
????"os"
????"os/signal"
????"time"
)
//Runner在給定的超時間內(nèi)執(zhí)行一組任務(wù)，
//并且在操作系統(tǒng)發(fā)送中斷信號時結(jié)束這些任務(wù)
type Runner struct {
????//interrupt通道報告從操作系統(tǒng)
????//發(fā)送的信號
????interrupt chan os.signal
????
????//complete通道報告處理任務(wù)已經(jīng)完成
????complete chan error
????
????//timeout報告處理任務(wù)已經(jīng)超時
????timeout <-chan time.time
????
????//task持有一組以索引順序依次執(zhí)行的
????//函數(shù)
????task []func(int)
}
//ErrTimeout會在任務(wù)執(zhí)行超時時返回
var ErrTimeout = errors.New("received timeout")
//ErrTimeout會在接收到操作系統(tǒng)的事件時返回
var ErrInterrupt = errors.New("received interrupt")
//New返回一個新的準(zhǔn)備使用的Runner
func New(d time.Duration) *Runner {
????return &Runner{
????????interrupt: make(chan os.Signal, 1),
????????complete: make(chan error),
????????timeout: time.After(d),
????}
}
//Add將一個任務(wù)附加到Runner上。這個任務(wù)是一個
//接收一個int類型的ID作為參數(shù)的函數(shù)
func (r *Runner) Add(tasks ...func(int)) {
????r.tasks = append(r.tasks, tasks...)
}
//Start執(zhí)行所有任務(wù)，并監(jiān)視通道事件
func (r *Runner) Start() error {
????//我們希望接收所有中斷信號
????sinal.Notify(r.interrupt, os.Interrupt)
????
????//用不同的goroutine執(zhí)行不同的任務(wù)
????go func() {
????????r.complete <- r.run()
????}()
????
????select {
????//當(dāng)任務(wù)處理完成時發(fā)出的信號
????case err := <-r.complete:
????????return err
????//當(dāng)任務(wù)處理程序運行超時發(fā)出的信號
????case <-r.timeout:
????????return ErrTimeout
????}
}
//run執(zhí)行每一個已注冊的任務(wù)
func (r *Runner) run() error {
????for id, task := range r.tasks {
????????//檢測操作系統(tǒng)的中斷信號
????????if r.gotInterrupt() {
????????????return ErrInterrupt
????????}
????????
????????//執(zhí)行已注冊的新任務(wù)
????????task(id)
????}
????
????return nil
}
//gotInterrupt驗證是否接收到了中斷信號
func (r *Runner) gotInterrupt() bool {
????select {
????//當(dāng)中斷事件被觸發(fā)時發(fā)出的信號
????case <-r.interrupt:
????????//停止接收后續(xù)的任何信號
????????sinal.Stop(r.interrupt)
????????return true
????
????//繼續(xù)正常運行
????default:
????????return false
????}
}
程序展示了依據(jù)調(diào)度運行的無人值守的面向任務(wù)的程序,及其所使用的并發(fā)模式。在設(shè)計上,可支持以下終止點:程序可以在分配的時間內(nèi)完成工作,正常終止;程序沒有及時完成工作,“自殺”;接收到操作系統(tǒng)發(fā)送的中斷事件,程序立刻試圖清理狀態(tài)并停止工作。
// 這個示例程序演示如何使用通道來監(jiān)視
// 程序運行的時間,以在程序運行時間過長
// 時如何終止程序
package main
import (
???"log"
???"time"
???"github.com/goinaction/code/chapter7/patterns/runner"
???"os"
)
//timeout規(guī)定了必須在多少秒內(nèi)處理完成
const timeout = 3 * time.Second
//main是程序的入口
func main() {
???log.Println("Starting work.")
???//為本次執(zhí)行分配超時時間
???r := runner.New(timeout)
???//加入要執(zhí)行的任務(wù)
???r.Add(createTask(), createTask(), createTask())
???//執(zhí)行任務(wù)并處理結(jié)果
???if err := r.Start(); err != nil {
??????switch err {
??????case runner.ErrTimeout:
?????????log.Println("Terminating dur to timeout.")
?????????os.Exit(1)
??????case runner.ErrInterrupt:
?????????log.Println("Terminating dur to interrupt.")
?????????os.Exit(2)
??????}
???}
???
???log.Println("Process ended.")
}
//createTask返回一個根據(jù)id
//休眠指定秒數(shù)的示例任務(wù)
func createTask() func(int) {
???return func(id int) {
??????log.Printf("Processor - Task #%d.", id)
??????time.Sleep(time.Duration(id) * time.Second)
???}
}
7.2 pool
pool這個包用于展示如何使用有緩沖的通道實現(xiàn)資源池,來管理可以在任意數(shù)量的goroutine之間共享及獨立使用的資源。在 Go 1.6 及之后的版本中,標(biāo)準(zhǔn)庫里自帶了資源池的實現(xiàn)(sync.Pool)。
7.3 work
work 包的目的是展示如何使用無緩沖的通道來創(chuàng)建一個 goroutine 池,這些 goroutine 執(zhí)行并控制一組工作,讓其并發(fā)執(zhí)行。
// work 包管理一個?goroutine 池來完成工作
package work
import "sync"
//Worker必須滿足接口類型，
//才能使用工作池
type Worker interface {
???Task()
}
//Pool提供一個goroutine池，這個池可以完成
//任何已提交的Worker任務(wù)
type Pool struct {
???work chan Worker
???wg ??sync.WaitGroup
}
//New創(chuàng)建一個新工作池
func New(maxGoroutines int) *Pool {
???p := Pool{
??????work: make(chan Worker),
???}
???p.wg.Add(maxGoroutines)
???for i := 0; i < maxGoroutines; i++ {
??????go func() {
?????????for w := range p.work {
????????????w.Task()
?????????}
?????????p.wg.Done()
??????}()
???}
???return &p
}
//Run提交到工作池
func (p *Pool) Run(w Worker) {
???p.work <- w
}
//Shutdown等待所有goroutine停止工作
func (p *Pool) Shuntdown() {
???close(p.work)
???p.wg.Wait()
}
7.4 小結(jié)
可以使用通道來控制程序的生命周期； 帶 default 分支的 select 語句可以用來嘗試向通道發(fā)送或者接收數(shù)據(jù)，而不會阻塞；有緩沖的通道可以用來管理一組可復(fù)用的資源；語言運行時會處理好通道的協(xié)作和同步；使用無緩沖的通道來創(chuàng)建完成工作的 goroutine 池；任何時間都可以用無緩沖的通道來讓兩個 goroutine 交換數(shù)據(jù),在通道操作完成時一定保證對方接收到了數(shù)據(jù)。
本章主要內(nèi)容：輸出數(shù)據(jù)以及記錄日志；對 JSON 進(jìn)行編碼和解碼；處理輸入/輸出,并以流的方式處理數(shù)據(jù)；讓標(biāo)準(zhǔn)庫里多個包協(xié)同工作。
8.1 文檔與源代碼
標(biāo)準(zhǔn)庫里總共有超過100 個包,這些包被分到 38 個類別里。標(biāo)準(zhǔn)庫里的頂級目錄和包：
archive debug hash mime sort Time bufio encoding html net strconv unicode bytes errors image os strings unsafe compress expvar index path sync container flag io reflect syscall crypto fmt log regexp testing database go math runtime text
8.2.1 log 包
記錄日志的目的是跟蹤程序什么時候在什么位置做了什么。
聲明 Ldate 常量
// 日期: 2009/01/23
Ldate = 1 << iota
關(guān)鍵字 iota 在常量聲明區(qū)里有特殊的作用。這個關(guān)鍵字讓編譯器為每個常量復(fù)制相同的表達(dá)式,直到聲明區(qū)結(jié)束,或者遇到一個新的賦值語句。關(guān)鍵字 iota 的另一個功能是, iota 的初始值為 0,之后 iota 的值在每次處理為常量后,都會自增 1。
初始完 log 包后,可以看一下 main() 函數(shù),看它是是如何寫消息的。
func main() {
???//Println寫到標(biāo)準(zhǔn)日志記錄器
???log.Println("message")
???//Fatalln在調(diào)用Println()之后會接著調(diào)用os.Exit(1)
???log.Fatalln("fatal message")
???
???//Panicln在調(diào)用Println()之后會接著調(diào)用panic()
???log.Panicln("panic message")
}
8.2.2 定制的日志記錄器
要想創(chuàng)建一個定制的日志記錄器,需要創(chuàng)建一個 Logger 類型值。可以給每個日志記錄器配置一個單獨的目的地,并獨立設(shè)置其前綴和標(biāo)志。
// 這個示例程序展示如何創(chuàng)建定制的日志記錄器
package main
import (
???"io"
???"io/ioutil"
???"log"
???"os"
???"sync"
)
var (
???Trace ??*log.Logger // 記錄所有日志
???Info ???*log.Logger // 重要的信息
???Warning *log.Logger // 需要注意的信息
???Error ??*log.Logger // 非常嚴(yán)重的問題
)
func init() {
???filr, err := os.OpenFile("errors.txt",
??????os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
???if err != nil {
??????log.Fatalln("Failed to open error log file:", err)
???}
???Trace = log.New(ioutil.Discard,
??????"TRACE:",
?????????log.Ldate|log.Ltime|log.Lshortfile)
???Info = log.New(os.Stdout,
??????"INFO:",
??????log.Ldate|log.Ltime|log.Lshortfile)
???Warning = log.New(os.Stdout,
??????"Warning:",
??????log.Ldate|log.Ltime|log.Lshortfile)
???Error = log.New(os.Stdout,
??????"Error:",
??????log.Ldate|log.Ltime|log.Lshortfile)
}
func main() {
???Trace.Println("I have something standard to say")
???Info.Println("Special Information")
???Warning.Println("There is something you need to know about")
???Error.Println("Something has failed")
}
8.3 編碼 / 解碼
8.3.1 解碼 JSON
使用 json 包的 NewDecoder 函數(shù)以及 Decode方法進(jìn)行解碼。如果要處理來自網(wǎng)絡(luò)響應(yīng)或者文件的 JSON,那么一定會用到這個函數(shù)及方法。
// 這個示例程序展示如何使用?json 包和?NewDecoder 函數(shù)
// 來解碼?JSON 響應(yīng)
package main
import (
???"net/http"
???"log"
???"encoding/json"
???"fmt"
)
type (
???//gResult映射從搜索拿到的結(jié)果文檔
???gResult struct {
??????GsearchResultClass string 'json:"GsearchResultClass"'
??????unescapedURL ?????string 'json:"unescapedURL"'
??????URL ?????????????string 'json:"url"'
??????VisibleURL ??????????string 'json:"VisibleUrl"'
??????CacheURl ??????????string 'json:"cacheUrl"'
??????Title ?????????????string 'json:"title"'
??????TitleNoFormatting ?string 'json:"titleNoFormatting"'
??????Content ???????????string 'json:"content"'
???}
???//gResponse包含頂級的文檔
???gResponse struct {
??????ResponseData struct {
?????????Results []gResult 'json:"results"'
??????} 'json:"responseData"'
???}
)
func main() {
???uri := "http://ajax.googleapis.com/ajax/services/search/web?v=1.0&rsz=8&q=golang"
???//向Google發(fā)起搜索
???resp, err := http.Get(uri)
???if err != nil {
??????log.Println("ERROR:", err)
??????return
???}
???defer resp.Body.Close()
???
???//將JSON響應(yīng)解碼到結(jié)構(gòu)類型
???var gr gResponse
???err = json.NewDecoder(resp.Body).Decode(&gr)
???if err != nil {
??????log.Println("ERROR", err)
??????return
???}
???
???fmt.Println(gr)
}
// 這個示例程序展示如何解碼?JSON 字符串
package main
import (
???"log"
???"encoding/json"
???"fmt"
)
//Contact結(jié)構(gòu)代表我們的JSON字符串
type Contact struct {
????Name ???string 'json:"name"'
????Title ??string 'json:"title"'
????Contact struct {
??????Home string ‘json:"home"’
??????Cell string 'json:"cell"'
?????} 'json:"contact"'
}
//JSON包含用于反序列化的演示字符串
var JSON = '{
???"name": "Gopher",
???"title":"programmer",
???"contact":{
??????"home": "415.333.3333",
??????"cell": "415.555.5555"
???}
}'
func main() {
???//將JSON字符串反序列化到變量
???var c Contact
???err := json.Unmarshal([]byte(JSON), &c)
???if err != nil {
??????log.Println("ERROR:", err)
??????return
???}
???fmt.Println(c)
}
有時,無法為 JSON 的格式聲明一個結(jié)構(gòu)類型,而是需要更加靈活的方式來處理 JSON 文檔。在這種情況下,可以將 JSON 文檔解碼到一個 map 變量中。
// 這個示例程序展示如何解碼?JSON 字符串
package main
import (
???"log"
???"encoding/json"
???"fmt"
)
//JSON包含用于反序列化的演示字符串
var JSON = '{
???"name": "Gopher",
???"title":"programmer",
???"contact":{
??????"home": "415.333.3333",
??????"cell": "415.555.5555"
???}
}'
func main() {
???//將JSON字符串反序列化到map變量
???var c map[string]interface{}
???err := json.Unmarshal([]byte(JSON), &c)
???if err != nil {
??????log.Println("ERROR:", err)
??????return
???}
???fmt.Println("Name:", c["name"])
???fmt.Println("Title:", c["title"])
???fmt.Println("Contact")
???fmt.Println("H:", c["contact"].(map[string]interface{})["home"])
???fmt.Println("C:", c["contact"].(map[string]interface{})["cell"])
}
8.3.2 編碼 JSON
我們要學(xué)習(xí)的處理 JSON 的第二個方面是,使用 json 包的 MarshalIndent 函數(shù)進(jìn)行編碼。這個函數(shù)可以很方便地將 Go 語言的 map 類型的值或者結(jié)構(gòu)類型的值轉(zhuǎn)換為易讀格式的 JSON 文檔。 序列化 (marshal)是指將數(shù)據(jù)轉(zhuǎn)換為 JSON 字符串的過程。
// 這個示例程序展示如何序列化?JSON 字符串
package main
import (
???"encoding/json"
???"log"
???"fmt"
)
func main() {
???//創(chuàng)建一個保存鍵值對的映射
???c := make(map[string]interface{})
???c["name"] = "Gopher"
???c["title"] = "programmer"
???c["contact"] = map[string]interface{}{
??????"home": "415.333.3333"
??????"cell": "415.555.5555"
???}
???
???//將這個映射序列化到JSON字符串
???data, err := json.MarshalIndent(c, "", " ??")
???if err != nil {
??????log.Println("ERROR:", err)
??????return
???}
???
???fmt.Println(string(data))
}
// MarshalIndent 很像 Marshal,只是用縮進(jìn)對輸出進(jìn)行格式化
func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
在 MarshalIndent 函 數(shù) 里 再 一 次 看 到 使 用 了 空 接 口 類 型 interface{} 。 函 數(shù)MarshalIndent 會使用反射來確定如何將 map 類型轉(zhuǎn)換為 JSON 字符串。
8.4 輸入和輸出
8.4.1 Writer 和 Reader 接口
// 這個示例程序展示來自不同標(biāo)準(zhǔn)庫的不同函數(shù)是如何
// 使用?io.Writer 接口的
package main
import (
???"bytes"
???"fmt"
???"os"
)
//main是應(yīng)用程序的入口
func main() {
???//創(chuàng)建一個Buffer值，并將一個字符串寫入Buffer
???//使用實現(xiàn)io.Writer的Write方法
???var b bytes.Buffer
???b.Write([]byte("Hello "))
???
???//使用Fprintf來將一個字符串拼接到Buffer里
???//將bytes.Buffer的地址作為io.Writer類型值傳入
???fmt.Fprintf(&b, "World!")
???
???//將Buffer的內(nèi)容輸出到標(biāo)準(zhǔn)輸出設(shè)備
???//將os.File值的地址作為io.Writer類型值傳入
???b.WriteTo(os.Stdout)
}
8.4.3?簡單的 curl
curl這個工具可以對指定的 URL 發(fā)起 HTTP 請求,并保存返回的內(nèi)容。
// 這個示例程序展示來自不同標(biāo)準(zhǔn)庫的不同函數(shù)是如何
// 使用?io.Writer 接口的
package main
import (
???"net/http"
???"os"
???"log"
???"io"
)
//main是應(yīng)用程序的入口
func main() {
???//這里的r是一個響應(yīng)，r.Body是io.Reader
???r, err := ?http.Get(os.Args[1])
???if err != nil {
??????log.Fatalln(err)
???}
???//創(chuàng)建文件來保存響應(yīng)內(nèi)容
???file, err := os.Create(os.Args[2])
???if err != nil {
??????log.Fatalln(err)
???}
???defer file.Close()
???//使用MultiWriter，這樣就可以同時向文件和標(biāo)準(zhǔn)輸出設(shè)備
???//進(jìn)行寫操作
???dest := io.MultiWriter(os.Stdout, file)
???//從響應(yīng)的結(jié)果讀出響應(yīng)的內(nèi)容，并寫道兩個目的地
???io.Copy(dest, r.Body)
???if err := r.Body.Close(); err != nil {
??????log.Println(err)
???}
}
8.5?小結(jié)
標(biāo)準(zhǔn)庫有特殊的保證,并且被社區(qū)廣泛應(yīng)用;使用標(biāo)準(zhǔn)庫的包會讓你的代碼更易于管理,別人也會更信任你的代碼;100 余個包被合理組織,分布在 38 個類別里;標(biāo)準(zhǔn)庫里的 log 包擁有記錄日志所需的一切功能;標(biāo)準(zhǔn)庫里的 xml 和 json 包讓處理這兩種數(shù)據(jù)格式變得很簡單;io 包支持以流的方式高效處理數(shù)據(jù);接口允許你的代碼組合已有的功能;閱讀標(biāo)準(zhǔn)庫的代碼是熟悉 Go 語言習(xí)慣的好方法。
第9章 測試和性能
本章主要內(nèi)容：編寫單元測試來驗證代碼的正確性；使用 httptest 來模擬基于 HTTP 的請求和響應(yīng)；使用示例代碼來給包寫文檔；通過基準(zhǔn)測試來檢查性能。
9.1 單元測試
單元測試是用來測試包或者程序的一部分代碼或者一組代碼的函數(shù)。測試的目的是確認(rèn)目標(biāo)代碼在給定的場景下,有沒有按照期望工作。另外一些單元測試可能會測試負(fù)向路徑的場景,保證代碼不僅會產(chǎn)生錯誤,而且是預(yù)期的錯誤。
在 Go 語言里有幾種方法寫單元測試。基礎(chǔ)測試(basic test)只使用一組參數(shù)和結(jié)果來測試一段代碼。表組測試(table test)也會測試一段代碼,但是會使用多組參數(shù)和結(jié)果進(jìn)行測試。也可以使用一些方法來模仿(mock)測試代碼需要使用到的外部資源,如數(shù)據(jù)庫或者網(wǎng)絡(luò)服務(wù)器。
// 這個示例程序展示如何寫基礎(chǔ)單元測試
package listing01
import (
???"net/http"
???"testing"
)
const chechMark = "\u2713"
const ballotX = "\u2717"
//TestDownload確認(rèn)http包的Get函數(shù)可以下載內(nèi)容
func TestDownload(t *testing.T) {
???url := "http://www.goinggo.net/feeds/posts/default?alt=rss"
???statusCode := 200
???t.Log("Given the need to test downloadig content.")
???{
??????t.Logf("\tWhen checking \"%s\" for status code \"%d\"",
?????????url, statusCode)
??????{
?????????resp, err := http.Get(url)
?????????if err != nil {
????????????t.Fatal("\t\tShould be able to make the Get call.",
???????????????ballotX, err)
?????????}
?????????t.Log("\t\tShould be able to make the Get call.",
????????????checkMark)
?????????defer resp.Body.Close()
?????????if resp.StatusCode == statusCode {
????????????t.Logf("\t\tShould receive a \"%d\" status. %v",
???????????????statusCode, checkMark)
?????????} else {
????????????t.Errorf("\t\tShould receive a \"%d\" status. %v %v",
???????????????statusCode, ballotX, resp.StatusCode")
?????????}
??????}
???}
}
展示了測試 http 包的 Get 函數(shù)的單元測試。測試的內(nèi)容是確保可以從網(wǎng)絡(luò)正常下載 goinggo.net 的 RSS 列表。通過調(diào)用 go test -v 來運行這個測試( -v 表示提供冗余輸出）。
9.1.2 表組測試
如果測試可以接受一組不同的輸入并產(chǎn)生不同的輸出的代碼,那么應(yīng)該使用表組測試的方法進(jìn)行測試。
9.1.3 模仿調(diào)用
標(biāo)準(zhǔn)庫包含一個名為 httptest 的包,它讓開發(fā)人員可以模仿基于HTTP 的網(wǎng)絡(luò)調(diào)用。
9.3 基準(zhǔn)測試
基準(zhǔn)測試是一種測試代碼性能的方法。
9.4 小結(jié)
測試功能被內(nèi)置到 Go 語言中,Go 語言提供了必要的測試工具；go test 工具用來運行測試；測試文件總是以_test.go 作為文件名的結(jié)尾；表組測試是利用一個測試函數(shù)測試多組值的好辦法；包中的示例代碼,既能用于測試,也能用于文檔；基準(zhǔn)測試提供了探查代碼性能的機制。
總結(jié)
以上是生活随笔為你收集整理的《Go语言实战》William Kennedy中文版学习笔记的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 肺功能曲线图怎么看_如何看肺功能结果报告
- 下一篇： 2013年c语言课后作业答案,2013年