go語言堆棧,go內(nèi)存模型 堆棧

GO語言商業(yè)案例（十八）：stream

切換到新語言始終是一大步，尤其是當(dāng)您的團(tuán)隊(duì)成員只有一個(gè)時(shí)有該語言的先前經(jīng)驗(yàn)?，F(xiàn)在，Stream 的主要編程語言從 Python 切換到了 Go。這篇文章將解釋stream決定放棄 Python 并轉(zhuǎn)向 Go 的一些原因。

成都創(chuàng)新互聯(lián)公司是專業(yè)的璧山網(wǎng)站建設(shè)公司，璧山接單;提供成都做網(wǎng)站、網(wǎng)站建設(shè),網(wǎng)頁設(shè)計(jì),網(wǎng)站設(shè)計(jì),建網(wǎng)站,PHP網(wǎng)站建設(shè)等專業(yè)做網(wǎng)站服務(wù);采用PHP框架,可快速的進(jìn)行璧山網(wǎng)站開發(fā)網(wǎng)頁制作和功能擴(kuò)展;專業(yè)做搜索引擎喜愛的網(wǎng)站,專業(yè)的做網(wǎng)站團(tuán)隊(duì),希望更多企業(yè)前來合作!

Go 非?？臁Ｐ阅茴愃朴?Java 或 C++。對(duì)于用例，Go 通常比 Python 快 40 倍。

對(duì)于許多應(yīng)用程序來說，編程語言只是應(yīng)用程序和數(shù)據(jù)庫之間的粘合劑。語言本身的性能通常并不重要。然而，Stream 是一個(gè)API 提供商，為 700 家公司和超過 5 億最終用戶提供提要和聊天平臺(tái)。多年來，我們一直在優(yōu)化 Cassandra、PostgreSQL、Redis 等，但最終，您會(huì)達(dá)到所使用語言的極限。Python 是一門很棒的語言，但對(duì)于序列化/反序列化、排名和聚合等用例，它的性能相當(dāng)緩慢。我們經(jīng)常遇到性能問題，Cassandra 需要 1 毫秒來檢索數(shù)據(jù)，而 Python 會(huì)花費(fèi)接下來的 10 毫秒將其轉(zhuǎn)換為對(duì)象。

看看我如何開始 Go 教程中的一小段 Go 代碼。（這是一個(gè)很棒的教程，也是學(xué)習(xí) Go 的一個(gè)很好的起點(diǎn)。）

如果您是 Go 新手，那么在閱讀那個(gè)小代碼片段時(shí)不會(huì)有太多讓您感到驚訝的事情。它展示了多個(gè)賦值、數(shù)據(jù)結(jié)構(gòu)、指針、格式和一個(gè)內(nèi)置的 HTTP 庫。當(dāng)我第一次開始編程時(shí)，我一直喜歡使用 Python 更高級(jí)的功能。Python 允許您在編寫代碼時(shí)獲得相當(dāng)?shù)膭?chuàng)意。例如，您可以：

這些功能玩起來很有趣，但是，正如大多數(shù)程序員會(huì)同意的那樣，在閱讀別人的作品時(shí)，它們通常會(huì)使代碼更難理解。Go 迫使你堅(jiān)持基礎(chǔ)。這使得閱讀任何人的代碼并立即了解發(fā)生了什么變得非常容易。 注意：當(dāng)然，它實(shí)際上有多“容易”取決于您的用例。如果你想創(chuàng)建一個(gè)基本的 CRUD API，我仍然推薦 Django + DRF或 Rails。

作為一門語言，Go 試圖讓事情變得簡單。它沒有引入許多新概念。重點(diǎn)是創(chuàng)建一種非?？焖偾乙子谑褂玫暮唵握Z言。它唯一具有創(chuàng)新性的領(lǐng)域是 goroutine 和通道。（100% 正確CSP的概念始于 1977 年，所以這項(xiàng)創(chuàng)新更多是對(duì)舊思想的一種新方法。）Goroutines 是 Go 的輕量級(jí)線程方法，通道是 goroutines 之間通信的首選方式。Goroutines 的創(chuàng)建非常便宜，并且只需要幾 KB 的額外內(nèi)存。因?yàn)?Goroutine 非常輕量，所以有可能同時(shí)運(yùn)行數(shù)百甚至數(shù)千個(gè)。您可以使用通道在 goroutine 之間進(jìn)行通信。Go 運(yùn)行時(shí)處理所有復(fù)雜性。goroutines 和基于通道的并發(fā)方法使得使用所有可用的 CPU 內(nèi)核和處理并發(fā) IO 變得非常容易——所有這些都不會(huì)使開發(fā)復(fù)雜化。與 Python/Java 相比，在 goroutine 上運(yùn)行函數(shù)需要最少的樣板代碼。您只需在函數(shù)調(diào)用前加上關(guān)鍵字“go”：

Go 的并發(fā)方法很容易使用。與 Node 相比，這是一種有趣的方法，開發(fā)人員必須密切關(guān)注異步代碼的處理方式。Go 中并發(fā)的另一個(gè)重要方面是競爭檢測器。這樣可以很容易地確定異步代碼中是否存在任何競爭條件。

我們目前用 Go 編寫的最大的微服務(wù)編譯需要 4 秒。與以編譯速度慢而聞名的 Java 和 C++ 等語言相比，Go 的快速編譯時(shí)間是一項(xiàng)重大的生產(chǎn)力勝利。我喜歡在程序編譯的時(shí)候摸魚，但在我還記得代碼應(yīng)該做什么的同時(shí)完成事情會(huì)更好。

首先，讓我們從顯而易見的開始：與 C++ 和 Java 等舊語言相比，Go 開發(fā)人員的數(shù)量并不多。根據(jù)StackOverflow的數(shù)據(jù)， 38% 的開發(fā)人員知道 Java， 19.3% 的人知道 C++，只有 4.6% 的人知道 Go。GitHub 數(shù)據(jù)顯示了類似的趨勢：Go 比 Erlang、Scala 和 Elixir 等語言使用更廣泛，但不如 Java 和 C++ 流行。幸運(yùn)的是，Go 是一種非常簡單易學(xué)的語言。它提供了您需要的基本功能，僅此而已。它引入的新概念是“延遲”聲明和內(nèi)置的并發(fā)管理與“goroutines”和通道。（對(duì)于純粹主義者來說：Go 并不是第一種實(shí)現(xiàn)這些概念的語言，只是第一種使它們流行起來的語言。）任何加入團(tuán)隊(duì)的 Python、Elixir、C++、Scala 或 Java 開發(fā)人員都可以在一個(gè)月內(nèi)在 Go 上發(fā)揮作用，因?yàn)樗暮唵涡浴Ｅc許多其他語言相比，我們發(fā)現(xiàn)組建 Go 開發(fā)人員團(tuán)隊(duì)更容易。如果您在博爾德和阿姆斯特丹等競爭激烈的生態(tài)系統(tǒng)中招聘人員，這是一項(xiàng)重要的優(yōu)勢。

對(duì)于我們這樣規(guī)模的團(tuán)隊(duì)（約 20 人）來說，生態(tài)系統(tǒng)很重要。如果您必須重新發(fā)明每一個(gè)小功能，您根本無法為您的客戶創(chuàng)造價(jià)值。Go 對(duì)我們使用的工具有很好的支持。實(shí)體庫已經(jīng)可用于 Redis、RabbitMQ、PostgreSQL、模板解析、任務(wù)調(diào)度、表達(dá)式解析和 RocksDB。與 Rust 或 Elixir 等其他較新的語言相比，Go 的生態(tài)系統(tǒng)是一個(gè)重大勝利。它當(dāng)然不如 Java、Python 或 Node 之類的語言好，但它很可靠，而且對(duì)于許多基本需求，你會(huì)發(fā)現(xiàn)已經(jīng)有高質(zhì)量的包可用。

Gofmt 是一個(gè)很棒的命令行實(shí)用程序，內(nèi)置在 Go 編譯器中，用于格式化代碼。就功能而言，它與 Python 的 autopep8 非常相似。我們大多數(shù)人并不真正喜歡爭論制表符與空格。格式的一致性很重要，但實(shí)際的格式標(biāo)準(zhǔn)并不那么重要。Gofmt 通過使用一種正式的方式來格式化您的代碼來避免所有這些討論。

Go 對(duì)協(xié)議緩沖區(qū)和 gRPC 具有一流的支持。這兩個(gè)工具非常適合構(gòu)建需要通過 RPC 通信的微服務(wù)。您只需要編寫一個(gè)清單，在其中定義可以進(jìn)行的 RPC 調(diào)用以及它們采用的參數(shù)。然后從這個(gè)清單中自動(dòng)生成服務(wù)器和客戶端代碼。生成的代碼既快速又具有非常小的網(wǎng)絡(luò)占用空間并且易于使用。從同一個(gè)清單中，您甚至可以為許多不同的語言生成客戶端代碼，例如 C++、Java、Python 和 Ruby。因此，內(nèi)部流量不再有模棱兩可的 REST 端點(diǎn)，您每次都必須編寫幾乎相同的客戶端和服務(wù)器代碼。.

Go 沒有像 Rails 用于 Ruby、Django 用于 Python 或 Laravel 用于 PHP 那樣的單一主導(dǎo)框架。這是 Go 社區(qū)內(nèi)激烈爭論的話題，因?yàn)樵S多人主張你不應(yīng)該一開始就使用框架。我完全同意這對(duì)于某些用例是正確的。但是，如果有人想構(gòu)建一個(gè)簡單的 CRUD API，他們將更容易使用 Django/DJRF、Rails Laravel 或Phoenix。對(duì)于 Stream 的用例，我們更喜歡不使用框架。然而，對(duì)于許多希望提供簡單 CRUD API 的新項(xiàng)目來說，缺乏主導(dǎo)框架將是一個(gè)嚴(yán)重的劣勢。

Go 通過簡單地從函數(shù)返回錯(cuò)誤并期望調(diào)用代碼來處理錯(cuò)誤（或?qū)⑵浞祷氐秸{(diào)用堆棧）來處理錯(cuò)誤。雖然這種方法有效，但很容易失去問題的范圍，以確保您可以向用戶提供有意義的錯(cuò)誤。錯(cuò)誤包通過允許您向錯(cuò)誤添加上下文和堆棧跟蹤來解決此問題。另一個(gè)問題是很容易忘記處理錯(cuò)誤。像 errcheck 和 megacheck 這樣的靜態(tài)分析工具可以方便地避免犯這些錯(cuò)誤。雖然這些變通辦法效果很好，但感覺不太對(duì)勁。您希望該語言支持正確的錯(cuò)誤處理。

Go 的包管理絕不是完美的。默認(rèn)情況下，它無法指定特定版本的依賴項(xiàng)，也無法創(chuàng)建可重現(xiàn)的構(gòu)建。Python、Node 和 Ruby 都有更好的包管理系統(tǒng)。但是，使用正確的工具，Go 的包管理工作得很好。您可以使用Dep來管理您的依賴項(xiàng)，以允許指定和固定版本。除此之外，我們還貢獻(xiàn)了一個(gè)名為的開源工具VirtualGo，它可以更輕松地處理用 Go 編寫的多個(gè)項(xiàng)目。

我們進(jìn)行的一個(gè)有趣的實(shí)驗(yàn)是在 Python 中使用我們的排名提要功能并在 Go 中重寫它?？纯催@個(gè)排名方法的例子：

Python 和 Go 代碼都需要執(zhí)行以下操作來支持這種排名方法：

開發(fā) Python 版本的排名代碼大約花了 3 天時(shí)間。這包括編寫代碼、單元測試和文檔。接下來，我們花了大約 2 周的時(shí)間優(yōu)化代碼。其中一項(xiàng)優(yōu)化是將分?jǐn)?shù)表達(dá)式 (simple_gauss(time)*popularity) 轉(zhuǎn)換為抽象語法樹. 我們還實(shí)現(xiàn)了緩存邏輯，可以在未來的特定時(shí)間預(yù)先計(jì)算分?jǐn)?shù)。相比之下，開發(fā)此代碼的 Go 版本大約需要 4 天時(shí)間。性能不需要任何進(jìn)一步的優(yōu)化。因此，雖然 Python 的最初開發(fā)速度更快，但基于 Go 的版本最終需要我們團(tuán)隊(duì)的工作量大大減少。另外一個(gè)好處是，Go 代碼的執(zhí)行速度比我們高度優(yōu)化的 Python 代碼快大約 40 倍?，F(xiàn)在，這只是我們通過切換到 Go 體驗(yàn)到的性能提升的一個(gè)示例。

與 Python 相比，我們系統(tǒng)的其他一些組件在 Go 中構(gòu)建所需的時(shí)間要多得多。作為一個(gè)總體趨勢，我們看到 開發(fā) Go 代碼需要更多的努力。但是，我們花更少的時(shí)間 優(yōu)化 代碼以提高性能。

我們?cè)u(píng)估的另一種語言是Elixir.。Elixir 建立在 Erlang 虛擬機(jī)之上。這是一種迷人的語言，我們之所以考慮它，是因?yàn)槲覀兊囊幻麍F(tuán)隊(duì)成員在 Erlang 方面擁有豐富的經(jīng)驗(yàn)。對(duì)于我們的用例，我們注意到 Go 的原始性能要好得多。Go 和 Elixir 都可以很好地服務(wù)數(shù)千個(gè)并發(fā)請(qǐng)求。但是，如果您查看單個(gè)請(qǐng)求的性能，Go 對(duì)于我們的用例來說要快得多。我們選擇 Go 而不是 Elixir 的另一個(gè)原因是生態(tài)系統(tǒng)。對(duì)于我們需要的組件，Go 有更成熟的庫，而在許多情況下，Elixir 庫還沒有準(zhǔn)備好用于生產(chǎn)環(huán)境。培訓(xùn)/尋找開發(fā)人員使用 Elixir 也更加困難。這些原因使天平向 Go 傾斜。Elixir 的 Phoenix 框架看起來很棒，絕對(duì)值得一看。

Go 是一種非常高性能的語言，對(duì)并發(fā)有很好的支持。它幾乎與 C++ 和 Java 等語言一樣快。雖然與 Python 或 Ruby 相比，使用 Go 構(gòu)建東西確實(shí)需要更多時(shí)間，但您將節(jié)省大量用于優(yōu)化代碼的時(shí)間。我們?cè)赟tream有一個(gè)小型開發(fā)團(tuán)隊(duì)，為超過 5 億最終用戶提供動(dòng)力和聊天。Go 結(jié)合了 強(qiáng)大的生態(tài)系統(tǒng) 、新開發(fā)人員的 輕松入門、快速的性能 、對(duì)并發(fā)的 可靠支持和高效的編程環(huán)境 ，使其成為一個(gè)不錯(cuò)的選擇。Stream 仍然在我們的儀表板、站點(diǎn)和機(jī)器學(xué)習(xí)中利用 Python 來提供個(gè)性化的訂閱源. 我們不會(huì)很快與 Python 說再見，但今后所有性能密集型代碼都將使用 Go 編寫。我們新的聊天 API也完全用 Go 編寫。

go程序如何分配堆棧的

在Go語言中有一些調(diào)試技巧能幫助我們快速找到問題，有時(shí)候你想盡可能多的記錄異常但仍覺得不夠，搞清楚堆棧的意義有助于定位Bug或者記錄更完整的信息。

本文將討論堆棧跟蹤信息以及如何在堆棧中識(shí)別函數(shù)所傳遞的參數(shù)。

Functions

先從這段代碼開始：

Listing 1

01 package main

02

03 func main() {

04 ? ? slice := make([]string, 2, 4)

05 ? ? Example(slice, "hello", 10)

06 }

07

08 func Example(slice []string, str string, i int) {

09 ? ? panic("Want stack trace")

10 }

Example函數(shù)定義了3個(gè)參數(shù)，1個(gè)string類型的slice, 1個(gè)string和1個(gè)integer, 并且拋出了panic，運(yùn)行這段代碼可以看到這樣的結(jié)果：

Listing 2

Panic: Want stack trace

goroutine 1 [running]:

main.Example(0x2080c3f50, 0x2, 0x4, 0x425c0, 0x5, 0xa)

/Users/bill/Spaces/Go/Projects/src/github.com/goinaction/code/

temp/main.go:9 +0x64

main.main()

/Users/bill/Spaces/Go/Projects/src/github.com/goinaction/code/

temp/main.go:5 +0x85

goroutine 2 [runnable]:

runtime.forcegchelper()

/Users/bill/go/src/runtime/proc.go:90

runtime.goexit()

/Users/bill/go/src/runtime/asm_amd64.s:2232 +0x1

goroutine 3 [runnable]:

runtime.bgsweep()

/Users/bill/go/src/runtime/mgc0.go:82

runtime.goexit()

/Users/bill/go/src/runtime/asm_amd64.s:2232 +0x1

堆棧信息中顯示了在panic拋出這個(gè)時(shí)間所有的goroutines狀態(tài)，發(fā)生的panic的goroutine會(huì)顯示在最上面。

Listing 3

01 goroutine 1 [running]:

02 main.Example(0x2080c3f50, 0x2, 0x4, 0x425c0, 0x5, 0xa)

/Users/bill/Spaces/Go/Projects/src/github.com/goinaction/code/

temp/main.go:9 +0x64

03 main.main()

/Users/bill/Spaces/Go/Projects/src/github.com/goinaction/code/

temp/main.go:5 +0x85

第1行顯示最先發(fā)出panic的是goroutine 1, 第二行顯示panic位于main.Example中, 并能定位到該行代碼，在本例中第9行引發(fā)了panic。

下面我們關(guān)注參數(shù)是如何傳遞的：

Listing 4

// Declaration

main.Example(slice []string, str string, i int)

// Call to Example by main.

slice := make([]string, 2, 4)

Example(slice, "hello", 10)

// Stack trace

main.Example(0x2080c3f50, 0x2, 0x4, 0x425c0, 0x5, 0xa)

這里展示了在main中帶參數(shù)調(diào)用Example函數(shù)時(shí)的堆棧信息，比較就能發(fā)現(xiàn)兩者的參數(shù)數(shù)量并不相同，Example定義了3個(gè)參數(shù)，堆棧中顯示了6個(gè)參數(shù)?，F(xiàn)在的關(guān)鍵問題是我們要弄清楚它們是如何匹配的。

第1個(gè)參數(shù)是string類型的slice，我們知道在Go語言中slice是引用類型，即slice變量結(jié)構(gòu)會(huì)包含三個(gè)部分：指針、長度(Lengthe)、容量(Capacity)

Listing 5

// Slice parameter value

slice := make([]string, 2, 4)

// Slice header values

Pointer: ?0x2080c3f50

Length: ? 0x2

Capacity: 0x4

// Declaration

main.Example(slice []string, str string, i int)

// Stack trace

main.Example(0x2080c3f50, 0x2, 0x4, 0x425c0, 0x5, 0xa)

因此，前面3個(gè)參數(shù)會(huì)匹配slice， 如下圖所示：

Figure 1

figure provided by Georgi Knox

我們現(xiàn)在來看第二個(gè)參數(shù)，它是string類型，string類型也是引用類型，它包括兩部分：指針、長度。

Listing 6

// String parameter value

"hello"

// String header values

Pointer: 0x425c0

Length: ?0x5

// Declaration

main.Example(slice []string,?str string, i int)

// Stack trace

main.Example(0x2080c3f50, 0x2, 0x4,?0x425c0, 0x5, 0xa)

可以確定，堆棧信息中第4、5兩個(gè)參數(shù)對(duì)應(yīng)代碼中的string參數(shù)，如下圖所示：

Figure 2

figure provided by Georgi Knox

最后一個(gè)參數(shù)integer是single word值。

Listing 7

// Integer parameter value

10

// Integer value

Base 16: 0xa

// Declaration

main.Example(slice []string, str string,?i int)

// Stack trace

main.Example(0x2080c3f50, 0x2, 0x4, 0x425c0, 0x5,?0xa)

現(xiàn)在我們可以匹配代碼中的參數(shù)到堆棧信息了。

Figure 3

figure provided by Georgi Knox

Methods

如果我們將Example作為結(jié)構(gòu)體的方法會(huì)怎么樣呢?

Listing 8

01 package main

02

03 import "fmt"

04

05 type trace struct{}

06

07 func main() {

08 ? ? slice := make([]string, 2, 4)

09

10 ? ? var t trace

11 ? ? t.Example(slice, "hello", 10)

12 }

13

14 func (t *trace) Example(slice []string, str string, i int) {

15 ? ? fmt.Printf("Receiver Address: %p\n", t)

16 ? ? panic("Want stack trace")

17 }

如上所示修改代碼，將Example定義為trace的方法，并通過trace的實(shí)例t來調(diào)用Example。

再次運(yùn)行程序，會(huì)發(fā)現(xiàn)堆棧信息有一點(diǎn)不同：

Listing 9

Receiver Address:?0x1553a8

panic: Want stack trace

01 goroutine 1 [running]:

02 main.(*trace).Example(0x1553a8, 0x2081b7f50, 0x2, 0x4, 0xdc1d0, 0x5, 0xa)

/Users/bill/Spaces/Go/Projects/src/github.com/goinaction/code/

temp/main.go:16 +0x116

03 main.main()

/Users/bill/Spaces/Go/Projects/src/github.com/goinaction/code/

temp/main.go:11 +0xae

首先注意第2行的方法調(diào)用使用了pointer receiver，在package名字和方法名之間多出了"*trace"字樣。另外，參數(shù)列表的第1個(gè)參數(shù)標(biāo)明了結(jié)構(gòu)體(t)地址。我們從堆棧信息中看到了內(nèi)部實(shí)現(xiàn)細(xì)節(jié)。

Packing

如果有多個(gè)參數(shù)可以填充到一個(gè)single word, 則這些參數(shù)值會(huì)合并打包：

Listing 10

01 package main

02

03 func main() {

04 ? ? Example(true, false, true, 25)

05 }

06?

07 func Example(b1, b2, b3 bool, i uint8) {

08 ? ? panic("Want stack trace")

09 }

這個(gè)例子修改Example函數(shù)為4個(gè)參數(shù)：3個(gè)bool型和1個(gè)八位無符號(hào)整型。bool值也是用8個(gè)bit表示，所以在32位和64位架構(gòu)下，4個(gè)參數(shù)可以合并為一個(gè)single word。

Listing 11

01 goroutine 1 [running]:

02 main.Example(0x19010001)

/Users/bill/Spaces/Go/Projects/src/github.com/goinaction/code/

temp/main.go:8 +0x64

03 main.main()

/Users/bill/Spaces/Go/Projects/src/github.com/goinaction/code/

temp/main.go:4 +0x32

這是本例的堆棧信息，看下圖的具體分析：

Listing 12

// Parameter values

true, false, true, 25

// Word value

Bits ? ?Binary ? ? ?Hex ? Value

00-07 ? 0000 0001 ??01? ??true

08-15 ? 0000 0000 ??00? ? false

16-23 ? 0000 0001 ??01? ? true

24-31 ? 0001 1001 ??19? ? 25

// Declaration

main.Example(b1, b2, b3 bool, i uint8)

// Stack trace

main.Example(0x19010001)

以上展示了參數(shù)值是如何匹配到4個(gè)參數(shù)的。當(dāng)我們看到堆棧信息中包括十六進(jìn)制值，需要知道這些值是如何傳遞的。

如何看待go語言泛型的最新設(shè)計(jì)？

Go 由于不支持泛型而臭名昭著，但最近，泛型已接近成為現(xiàn)實(shí)。Go 團(tuán)隊(duì)實(shí)施了一個(gè)看起來比較穩(wěn)定的設(shè)計(jì)草案，并且正以源到源翻譯器原型的形式獲得關(guān)注。本文講述的是泛型的最新設(shè)計(jì)，以及如何自己嘗試泛型。

例子

FIFO Stack

假設(shè)你要?jiǎng)?chuàng)建一個(gè)先進(jìn)先出堆棧。沒有泛型，你可能會(huì)這樣實(shí)現(xiàn)：

type?Stack?[]interface{}func?(s?Stack)?Peek()?interface{}?{

return?s[len(s)-1]

}

func?(s?*Stack)?Pop()?{

*s?=?(*s)[:

len(*s)-1]

}

func?(s?*Stack)?Push(value?interface{})?{

*s?=?

append(*s,?value)

}

但是，這里存在一個(gè)問題：每當(dāng)你 Peek 項(xiàng)時(shí)，都必須使用類型斷言將其從 interface{} 轉(zhuǎn)換為你需要的類型。如果你的堆棧是 *MyObject 的堆棧，則意味著很多 s.Peek().(*MyObject)這樣的代碼。這不僅讓人眼花繚亂，而且還可能引發(fā)錯(cuò)誤。比如忘記 * 怎么辦？或者如果您輸入錯(cuò)誤的類型怎么辦？s.Push(MyObject{})` 可以順利編譯，而且你可能不會(huì)發(fā)現(xiàn)到自己的錯(cuò)誤，直到它影響到你的整個(gè)服務(wù)為止。

通常，使用 interface{} 是相對(duì)危險(xiǎn)的。使用更多受限制的類型總是更安全，因?yàn)榭梢栽诰幾g時(shí)而不是運(yùn)行時(shí)發(fā)現(xiàn)問題。

泛型通過允許類型具有類型參數(shù)來解決此問題：

type?Stack(type?T)?[]Tfunc?(s?Stack(T))?Peek()?T?{

return?s[len(s)-1]

}

func?(s?*Stack(T))?Pop()?{

*s?=?(*s)[:

len(*s)-1]

}

func?(s?*Stack(T))?Push(value?T)?{

*s?=?

append(*s,?value)

}

這會(huì)向 Stack 添加一個(gè)類型參數(shù)，從而完全不需要 interface{}?，F(xiàn)在，當(dāng)你使用 Peek() 時(shí)，返回的值已經(jīng)是原始類型，并且沒有機(jī)會(huì)返回錯(cuò)誤的值類型。這種方式更安全，更容易使用。（譯注：就是看起來更丑陋，^-^）

此外，泛型代碼通常更易于編譯器優(yōu)化，從而獲得更好的性能（以二進(jìn)制大小為代價(jià)）。如果我們對(duì)上面的非泛型代碼和泛型代碼進(jìn)行基準(zhǔn)測試，我們可以看到區(qū)別：

type?MyObject?struct?{

X?

int

}

var?sink?MyObjectfunc?BenchmarkGo1(b?*testing.B)?{

for?i?:=?0;?i??b.N;?i++?{

var?s?Stack

s.Push(MyObject{})

s.Push(MyObject{})

s.Pop()

sink?=?s.Peek().(MyObject)

}

}

func?BenchmarkGo2(b?*testing.B)?{

for?i?:=?0;?i??b.N;?i++?{

var?s?Stack(MyObject)

s.Push(MyObject{})

s.Push(MyObject{})

s.Pop()

sink?=?s.Peek()

}

}

結(jié)果：

BenchmarkGo1BenchmarkGo1-16?????12837528?????????87.0?ns/op???????48?B/op????????2?allocs/opBenchmarkGo2BenchmarkGo2-16?????28406479?????????41.9?ns/op???????24?B/op????????2?allocs/op

在這種情況下，我們分配更少的內(nèi)存，同時(shí)泛型的速度是非泛型的兩倍。

合約（Contracts）

上面的堆棧示例適用于任何類型。但是，在許多情況下，你需要編寫僅適用于具有某些特征的類型的代碼。例如，你可能希望堆棧要求類型實(shí)現(xiàn) String() 函數(shù)

調(diào)試Go語言的核心轉(zhuǎn)儲(chǔ)（Core Dumps）

英文原文鏈接【Go, the unwritten parts】 發(fā)表于2017/05/22 作者JBD是Go語言開發(fā)小組成員

檢查程序的執(zhí)行路徑和當(dāng)前狀態(tài)是非常有用的調(diào)試手段。核心文件（core file）包含了一個(gè)運(yùn)行進(jìn)程的內(nèi)存轉(zhuǎn)儲(chǔ)和狀態(tài)。它主要是用來作為事后調(diào)試程序用的。它也可以被用來查看一個(gè)運(yùn)行中的程序的狀態(tài)。這兩個(gè)使用場景使調(diào)試文件轉(zhuǎn)儲(chǔ)成為一個(gè)非常好的診斷手段。我們可以用這個(gè)方法來做事后診斷和分析線上的服務(wù)（production services）。

在這篇文章中，我們將用一個(gè)簡單的hello world網(wǎng)站服務(wù)作為例子。在現(xiàn)實(shí)中，我們的程序很容易就會(huì)變得很復(fù)雜。分析核心轉(zhuǎn)儲(chǔ)給我們提供了一個(gè)機(jī)會(huì)去重構(gòu)程序的狀態(tài)并且查看只有在某些條件／環(huán)境下才能重現(xiàn)的案例。

作者注 : 這個(gè)調(diào)試流程只在Linux上可行。我不是很確定它是否在其它Unixs系統(tǒng)上工作。macOS對(duì)此還不支持。Windows現(xiàn)在也不支持。

在我們開始前，需要確保核心轉(zhuǎn)儲(chǔ)的ulimit設(shè)置在合適的范圍。它的缺省值是0，意味著最大的核心文件大小是0。我通常在我的開發(fā)機(jī)器上將它設(shè)置成unlimited。使用以下命令：

接下來，你需要在你的機(jī)器上安裝 delve 。

下面我們使用的 main.go 文件。它注冊(cè)了一個(gè)簡單的請(qǐng)求處理函數(shù)（handler）然后啟動(dòng)了HTTP服務(wù)。

讓我們編譯并生產(chǎn)二進(jìn)制文件。

現(xiàn)在讓我們假設(shè)，這個(gè)服務(wù)器出了些問題，但是我們并不是很確定問題的根源。你可能已經(jīng)在程序里加了很多輔助信息，但還是無法從這些調(diào)試信息中找出線索。通常在這種情況下，當(dāng)前進(jìn)程的快照會(huì)非常有用。我們可以用這個(gè)快照深入查看程序的當(dāng)前狀態(tài)。

有幾個(gè)方式來獲取核心文件。你可能已經(jīng)熟悉了奔潰轉(zhuǎn)儲(chǔ)（crash dumps）。它們是在一個(gè)程序奔潰的時(shí)候?qū)懭氪疟P的核心轉(zhuǎn)儲(chǔ)。Go語言在缺省設(shè)置下不會(huì)生產(chǎn)奔潰轉(zhuǎn)儲(chǔ)。但是當(dāng)你把 GOTRACEBACK 環(huán)境變量設(shè)置成“crash”，你就可以用 Ctrl+backslash 才觸發(fā)奔潰轉(zhuǎn)儲(chǔ)。如下圖所示：

上面的操作會(huì)使程序終止，將堆棧跟蹤（stack trace）打印出來，并把核心轉(zhuǎn)儲(chǔ)文件寫入磁盤。

另外個(gè)方法可以從一個(gè)運(yùn)行的程序獲得核心轉(zhuǎn)儲(chǔ)而不需要終止相應(yīng)的進(jìn)程。 gcore 可以生產(chǎn)核心文件而無需使運(yùn)行中的程序退出。

根據(jù)上面的操作，我們獲得了轉(zhuǎn)儲(chǔ)而沒有終止對(duì)應(yīng)的進(jìn)程。下一步就是把核心文件加載進(jìn)delve并開始分析。

差不多就這些。delve的常用操作都可以使用。你可以backtrace，list，查看變量等等。有些功能不可用因?yàn)槲覀兪褂玫暮诵霓D(zhuǎn)儲(chǔ)是一個(gè)快照而不是正在運(yùn)行的進(jìn)程。但是程序執(zhí)行路徑和狀態(tài)全部可以訪問。

go語言tcp協(xié)議push指令怎么用

PUSH指令主要用于編寫子程序和中斷服務(wù)程序，可以臨時(shí)保存程序狀態(tài)字PSW和累加器ACC的內(nèi)容 或其它寄存器和存儲(chǔ)器單元的內(nèi)容。

在子程序和中斷服務(wù)程序結(jié)束返回主程序前，要用POP彈棧指令，從堆棧中取出被保護(hù)的數(shù)據(jù)，恢復(fù)程序狀態(tài)字PSW和累加器ACC的內(nèi)容 或其它寄存器和存儲(chǔ)器單元的內(nèi)容。

呵呵 滿意 就選滿意回答啊

Go 語言內(nèi)存管理（三）：逃逸分析

Go 語言較之 C 語言一個(gè)很大的優(yōu)勢就是自帶 GC 功能，可 GC 并不是沒有代價(jià)的。寫 C 語言的時(shí)候，在一個(gè)函數(shù)內(nèi)聲明的變量，在函數(shù)退出后會(huì)自動(dòng)釋放掉，因?yàn)檫@些變量分配在棧上。如果你期望變量的數(shù)據(jù)可以在函數(shù)退出后仍然能被訪問，就需要調(diào)用 malloc 方法在堆上申請(qǐng)內(nèi)存，如果程序不再需要這塊內(nèi)存了，再調(diào)用 free 方法釋放掉。Go 語言不需要你主動(dòng)調(diào)用 malloc 來分配堆空間，編譯器會(huì)自動(dòng)分析，找出需要 malloc 的變量，使用堆內(nèi)存。編譯器的這個(gè)分析過程就叫做逃逸分析。

所以你在一個(gè)函數(shù)中通過 dict := make(map[string]int) 創(chuàng)建一個(gè) map 變量，其背后的數(shù)據(jù)是放在?？臻g上還是堆空間上，是不一定的。這要看編譯器分析的結(jié)果。

可逃逸分析并不是百分百準(zhǔn)確的，它有缺陷。有的時(shí)候你會(huì)發(fā)現(xiàn)有些變量其實(shí)在?？臻g上分配完全沒問題的，但編譯后程序還是把這些數(shù)據(jù)放在了堆上。如果你了解 Go 語言編譯器逃逸分析的機(jī)制，在寫代碼的時(shí)候就可以有意識(shí)地繞開這些缺陷，使你的程序更高效。

Go 語言雖然在內(nèi)存管理方面降低了編程門檻，即使你不了解堆棧也能正常開發(fā)，但如果你要在性能上較真的話，還是要掌握這些基礎(chǔ)知識(shí)。

這里不對(duì)堆內(nèi)存和棧內(nèi)存的區(qū)別做太多闡述。簡單來說就是， 棧分配廉價(jià)，堆分配昂貴。 ?？臻g會(huì)隨著一個(gè)函數(shù)的結(jié)束自動(dòng)釋放，堆空間需要時(shí)間 GC 模塊不斷地跟蹤掃描回收。如果對(duì)這兩個(gè)概念有些迷糊，建議閱讀下面 2 個(gè)文章：

這里舉一個(gè)小例子，來對(duì)比下堆棧的差別：

stack 函數(shù)中的變量 i 在函數(shù)退出會(huì)自動(dòng)釋放；而 heap 函數(shù)返回的是對(duì)變量 i 的引用，也就是說 heap() 退出后，表示變量 i 還要能被訪問，它會(huì)自動(dòng)被分配到堆空間上。

他們編譯出來的代碼如下：

邏輯的復(fù)雜度不言而喻，從上面的匯編中可看到， heap() 函數(shù)調(diào)用了 runtime.newobject() 方法，它會(huì)調(diào)用 mallocgc 方法從 mcache 上申請(qǐng)內(nèi)存，申請(qǐng)的內(nèi)部邏輯前面文章已經(jīng)講述過。堆內(nèi)存分配不僅分配上邏輯比?？臻g分配復(fù)雜，它最致命的是會(huì)帶來很大的管理成本，Go 語言要消耗很多的計(jì)算資源對(duì)其進(jìn)行標(biāo)記回收（也就是 GC 成本）。

Go 編輯器會(huì)自動(dòng)幫我們找出需要進(jìn)行動(dòng)態(tài)分配的變量，它是在編譯時(shí)追蹤一個(gè)變量的生命周期，如果能確認(rèn)一個(gè)數(shù)據(jù)只在函數(shù)空間內(nèi)訪問，不會(huì)被外部使用，則使用?？臻g，否則就要使用堆空間。

我們?cè)? go build 編譯代碼時(shí)，可使用 -gcflags '-m' 參數(shù)來查看逃逸分析日志。

以上面的兩個(gè)函數(shù)為例，編譯的日志輸出是：

日志中的 i escapes to heap 表示該變量數(shù)據(jù)逃逸到了堆上。

需要使用堆空間，所以逃逸，這沒什么可爭議的。但編譯器有時(shí)會(huì)將 不需要 使用堆空間的變量，也逃逸掉。這里是容易出現(xiàn)性能問題的大坑。網(wǎng)上有很多相關(guān)文章，列舉了一些導(dǎo)致逃逸情況，其實(shí)總結(jié)起來就一句話：

多級(jí)間接賦值容易導(dǎo)致逃逸 。

這里的多級(jí)間接指的是，對(duì)某個(gè)引用類對(duì)象中的引用類成員進(jìn)行賦值。Go 語言中的引用類數(shù)據(jù)類型有 func , interface , slice , map , chan , *Type(指針) 。

記住公式 Data.Field = Value ，如果 Data , Field 都是引用類的數(shù)據(jù)類型，則會(huì)導(dǎo)致 Value 逃逸。這里的等號(hào) = 不單單只賦值，也表示參數(shù)傳遞。

根據(jù)公式，我們假設(shè)一個(gè)變量 data 是以下幾種類型，相應(yīng)的可以得出結(jié)論：

下面給出一些實(shí)際的例子：

如果變量值是一個(gè)函數(shù)，函數(shù)的參數(shù)又是引用類型，則傳遞給它的參數(shù)都會(huì)逃逸。

上例中 te 的類型是 func(*int) ，屬于引用類型，參數(shù) *int 也是引用類型，則調(diào)用 te(j) 形成了為 te 的參數(shù)(成員) *int 賦值的現(xiàn)象，即 te.i = j 會(huì)導(dǎo)致逃逸。代碼中其他幾種調(diào)用都沒有形成 多級(jí)間接賦值 情況。

同理，如果函數(shù)的參數(shù)類型是 slice , map 或 interface{} 都會(huì)導(dǎo)致參數(shù)逃逸。

匿名函數(shù)的調(diào)用也是一樣的，它本質(zhì)上也是一個(gè)函數(shù)變量。有興趣的可以自己測試一下。

只要使用了 Interface 類型(不是 interafce{} )，那么賦值給它的變量一定會(huì)逃逸。因?yàn)? interfaceVariable.Method() 先是間接的定位到它的實(shí)際值，再調(diào)用實(shí)際值的同名方法，執(zhí)行時(shí)實(shí)際值作為參數(shù)傳遞給方法。相當(dāng)于 interfaceVariable.Method.this = realValue

向 channel 中發(fā)送數(shù)據(jù)，本質(zhì)上就是為 channel 內(nèi)部的成員賦值，就像給一個(gè) slice 中的某一項(xiàng)賦值一樣。所以 chan *Type , chan map[Type]Type , chan []Type , chan interface{} 類型都會(huì)導(dǎo)致發(fā)送到 channel 中的數(shù)據(jù)逃逸。

這本來也是情理之中的，發(fā)送給 channel 的數(shù)據(jù)是要與其他函數(shù)分享的，為了保證發(fā)送過去的指針依然可用，只能使用堆分配。

可變參數(shù)如 func(arg ...string) 實(shí)際與 func(arg []string) 是一樣的，會(huì)增加一層訪問路徑。這也是 fmt.Sprintf 總是會(huì)使參數(shù)逃逸的原因。

例子非常多，這里不能一一列舉，我們只需要記住分析方法就好，即，2 級(jí)或更多級(jí)的訪問賦值會(huì) 容易 導(dǎo)致數(shù)據(jù)逃逸。這里加上 容易 二字是因?yàn)殡S著語言的發(fā)展，相信這些問題會(huì)被慢慢解決，但現(xiàn)階段，這個(gè)可以作為我們分析逃逸現(xiàn)象的依據(jù)。

下面代碼中包含 2 種很常規(guī)的寫法，但他們卻有著很大的性能差距，建議自己想下為什么。

Benchmark 和 pprof 給出的結(jié)果:

熟悉堆棧概念可以讓我們更容易看透 Go 程序的性能問題，并進(jìn)行優(yōu)化。

多級(jí)間接賦值會(huì)導(dǎo)致 Go 編譯器出現(xiàn)不必要的逃逸，在一些情況下可能我們只需要修改一下數(shù)據(jù)結(jié)構(gòu)就會(huì)使性能有大幅提升。這也是很多人不推薦在 Go 中使用指針的原因，因?yàn)樗鼤?huì)增加一級(jí)訪問路徑，而 map , slice , interface{} 等類型是不可避免要用到的，為了減少不必要的逃逸，只能拿指針開刀了。

大多數(shù)情況下，性能優(yōu)化都會(huì)為程序帶來一定的復(fù)雜度。建議實(shí)際項(xiàng)目中還是怎么方便怎么寫，功能完成后通過性能分析找到瓶頸所在，再對(duì)局部進(jìn)行優(yōu)化。

本文名稱：go語言堆棧,go內(nèi)存模型 堆棧
文章來源：http://www.jiaotiyi.com/article/hesdpc.html