摘要： 一、前言 go語言類似Java JUC包也提供了一些列用于多線程之間進行同步的措施，比如低級的同步措施有 鎖、CAS、原子變量操作類。相比Java來說go提供了獨特的基于通道的同步措施。本節(jié)我們先來看看go中CAS操作 二、CAS操作 go中的Cas操作與java中類似，都是借用了CPU提供的原子性指令來實現(xiàn)。
專注于為中小企業(yè)提供網(wǎng)站制作、網(wǎng)站建設(shè)服務(wù),電腦端+手機端+微信端的三站合一,更高效的管理,為中小企業(yè)平城免費做網(wǎng)站提供優(yōu)質(zhì)的服務(wù)。我們立足成都，凝聚了一批互聯(lián)網(wǎng)行業(yè)人才，有力地推動了上千余家企業(yè)的穩(wěn)健成長，幫助中小企業(yè)通過網(wǎng)站建設(shè)實現(xiàn)規(guī)模擴充和轉(zhuǎn)變。
go語言類似Java JUC包也提供了一些列用于多線程之間進行同步的措施，比如低級的同步措施有 鎖、CAS、原子變量操作類。相比Java來說go提供了獨特的基于通道的同步措施。本節(jié)我們先來看看go中CAS操作
go中的Cas操作與java中類似，都是借用了CPU提供的原子性指令來實現(xiàn)。CAS操作修改共享變量時候不需要對共享變量加鎖，而是通過類似樂觀鎖的方式進行檢查，本質(zhì)還是不斷的占用CPU 資源換取加鎖帶來的開銷（比如上下文切換開銷）。下面一個例子使用CAS來實現(xiàn)計數(shù)器
go中CAS操作具有原子性，在解決多線程操作共享變量安全上可以有效的減少使用鎖所帶來的開銷，但是這是使用cpu資源做交換的。
我簡單列舉了并發(fā)編程的大綱，需要詳細(xì)的私信“555”~~
Go 由于不支持泛型而臭名昭著，但最近，泛型已接近成為現(xiàn)實。Go 團隊實施了一個看起來比較穩(wěn)定的設(shè)計草案，并且正以源到源翻譯器原型的形式獲得關(guān)注。本文講述的是泛型的最新設(shè)計，以及如何自己嘗試泛型。
例子
FIFO Stack
假設(shè)你要創(chuàng)建一個先進先出堆棧。沒有泛型，你可能會這樣實現(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)
}
但是，這里存在一個問題：每當(dāng)你 Peek 項時，都必須使用類型斷言將其從 interface{} 轉(zhuǎn)換為你需要的類型。如果你的堆棧是 *MyObject 的堆棧，則意味著很多 s.Peek().(*MyObject)這樣的代碼。這不僅讓人眼花繚亂，而且還可能引發(fā)錯誤。比如忘記 * 怎么辦？或者如果您輸入錯誤的類型怎么辦？s.Push(MyObject{})` 可以順利編譯，而且你可能不會發(fā)現(xiàn)到自己的錯誤，直到它影響到你的整個服務(wù)為止。
通常，使用 interface{} 是相對危險的。使用更多受限制的類型總是更安全，因為可以在編譯時而不是運行時發(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)
}
這會向 Stack 添加一個類型參數(shù)，從而完全不需要 interface{}?，F(xiàn)在，當(dāng)你使用 Peek() 時，返回的值已經(jīng)是原始類型，并且沒有機會返回錯誤的值類型。這種方式更安全，更容易使用。（譯注：就是看起來更丑陋，^-^）
此外，泛型代碼通常更易于編譯器優(yōu)化，從而獲得更好的性能（以二進制大小為代價）。如果我們對上面的非泛型代碼和泛型代碼進行基準(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)存，同時泛型的速度是非泛型的兩倍。
合約（Contracts）
上面的堆棧示例適用于任何類型。但是，在許多情況下，你需要編寫僅適用于具有某些特征的類型的代碼。例如，你可能希望堆棧要求類型實現(xiàn) String() 函數(shù)
如果有其他語言基礎(chǔ)的話，直接類比學(xué)習(xí)就好了。如果沒有話那就先得熟悉編程思維，在掌握語言具體用法.
用 Go 編程的感覺很棒。庫程序里有我想要的一切，總體實現(xiàn)較為完善。學(xué)習(xí)體驗也十分順暢，不得不說，Go 是一種經(jīng)過精心設(shè)計的實用性語言。舉個例子：一旦你知悉了 Go 的語法，就能將其他語言中慣用法延續(xù)到 Go 中。只要你學(xué)會一些 Go，就可以相對輕易地推測 Go 語言的其他特性。憑借一些來自其他語言的知識，我能夠閱讀并理解 Go 代碼，而不需要過多的搜索
Go 語言較之 C 語言一個很大的優(yōu)勢就是自帶 GC 功能，可 GC 并不是沒有代價的。寫 C 語言的時候，在一個函數(shù)內(nèi)聲明的變量，在函數(shù)退出后會自動釋放掉，因為這些變量分配在棧上。如果你期望變量的數(shù)據(jù)可以在函數(shù)退出后仍然能被訪問，就需要調(diào)用 malloc 方法在堆上申請內(nèi)存，如果程序不再需要這塊內(nèi)存了，再調(diào)用 free 方法釋放掉。Go 語言不需要你主動調(diào)用 malloc 來分配堆空間，編譯器會自動分析，找出需要 malloc 的變量，使用堆內(nèi)存。編譯器的這個分析過程就叫做逃逸分析。
所以你在一個函數(shù)中通過 dict := make(map[string]int) 創(chuàng)建一個 map 變量，其背后的數(shù)據(jù)是放在棧空間上還是堆空間上，是不一定的。這要看編譯器分析的結(jié)果。
可逃逸分析并不是百分百準(zhǔn)確的，它有缺陷。有的時候你會發(fā)現(xiàn)有些變量其實在?？臻g上分配完全沒問題的，但編譯后程序還是把這些數(shù)據(jù)放在了堆上。如果你了解 Go 語言編譯器逃逸分析的機制，在寫代碼的時候就可以有意識地繞開這些缺陷，使你的程序更高效。
Go 語言雖然在內(nèi)存管理方面降低了編程門檻，即使你不了解堆棧也能正常開發(fā)，但如果你要在性能上較真的話，還是要掌握這些基礎(chǔ)知識。
這里不對堆內(nèi)存和棧內(nèi)存的區(qū)別做太多闡述。簡單來說就是， 棧分配廉價，堆分配昂貴。 棧空間會隨著一個函數(shù)的結(jié)束自動釋放，堆空間需要時間 GC 模塊不斷地跟蹤掃描回收。如果對這兩個概念有些迷糊，建議閱讀下面 2 個文章：
這里舉一個小例子，來對比下堆棧的差別：
stack 函數(shù)中的變量 i 在函數(shù)退出會自動釋放；而 heap 函數(shù)返回的是對變量 i 的引用，也就是說 heap() 退出后，表示變量 i 還要能被訪問，它會自動被分配到堆空間上。
他們編譯出來的代碼如下：
邏輯的復(fù)雜度不言而喻，從上面的匯編中可看到， heap() 函數(shù)調(diào)用了 runtime.newobject() 方法，它會調(diào)用 mallocgc 方法從 mcache 上申請內(nèi)存，申請的內(nèi)部邏輯前面文章已經(jīng)講述過。堆內(nèi)存分配不僅分配上邏輯比棧空間分配復(fù)雜，它最致命的是會帶來很大的管理成本，Go 語言要消耗很多的計算資源對其進行標(biāo)記回收（也就是 GC 成本）。
Go 編輯器會自動幫我們找出需要進行動態(tài)分配的變量，它是在編譯時追蹤一個變量的生命周期，如果能確認(rèn)一個數(shù)據(jù)只在函數(shù)空間內(nèi)訪問，不會被外部使用，則使用?？臻g，否則就要使用堆空間。
我們在 go build 編譯代碼時，可使用 -gcflags '-m' 參數(shù)來查看逃逸分析日志。
以上面的兩個函數(shù)為例，編譯的日志輸出是：
日志中的 i escapes to heap 表示該變量數(shù)據(jù)逃逸到了堆上。
需要使用堆空間，所以逃逸，這沒什么可爭議的。但編譯器有時會將 不需要 使用堆空間的變量，也逃逸掉。這里是容易出現(xiàn)性能問題的大坑。網(wǎng)上有很多相關(guān)文章，列舉了一些導(dǎo)致逃逸情況，其實總結(jié)起來就一句話：
多級間接賦值容易導(dǎo)致逃逸 。
這里的多級間接指的是，對某個引用類對象中的引用類成員進行賦值。Go 語言中的引用類數(shù)據(jù)類型有 func , interface , slice , map , chan , *Type(指針) 。
記住公式 Data.Field = Value ，如果 Data , Field 都是引用類的數(shù)據(jù)類型，則會導(dǎo)致 Value 逃逸。這里的等號 = 不單單只賦值，也表示參數(shù)傳遞。
根據(jù)公式，我們假設(shè)一個變量 data 是以下幾種類型，相應(yīng)的可以得出結(jié)論：
下面給出一些實際的例子：
如果變量值是一個函數(shù)，函數(shù)的參數(shù)又是引用類型，則傳遞給它的參數(shù)都會逃逸。
上例中 te 的類型是 func(*int) ，屬于引用類型，參數(shù) *int 也是引用類型，則調(diào)用 te(j) 形成了為 te 的參數(shù)(成員) *int 賦值的現(xiàn)象，即 te.i = j 會導(dǎo)致逃逸。代碼中其他幾種調(diào)用都沒有形成 多級間接賦值 情況。
同理，如果函數(shù)的參數(shù)類型是 slice , map 或 interface{} 都會導(dǎo)致參數(shù)逃逸。
匿名函數(shù)的調(diào)用也是一樣的，它本質(zhì)上也是一個函數(shù)變量。有興趣的可以自己測試一下。
只要使用了 Interface 類型(不是 interafce{} )，那么賦值給它的變量一定會逃逸。因為 interfaceVariable.Method() 先是間接的定位到它的實際值，再調(diào)用實際值的同名方法，執(zhí)行時實際值作為參數(shù)傳遞給方法。相當(dāng)于 interfaceVariable.Method.this = realValue
向 channel 中發(fā)送數(shù)據(jù)，本質(zhì)上就是為 channel 內(nèi)部的成員賦值，就像給一個 slice 中的某一項賦值一樣。所以 chan *Type , chan map[Type]Type , chan []Type , chan interface{} 類型都會導(dǎo)致發(fā)送到 channel 中的數(shù)據(jù)逃逸。
這本來也是情理之中的，發(fā)送給 channel 的數(shù)據(jù)是要與其他函數(shù)分享的，為了保證發(fā)送過去的指針依然可用，只能使用堆分配。
可變參數(shù)如 func(arg ...string) 實際與 func(arg []string) 是一樣的，會增加一層訪問路徑。這也是 fmt.Sprintf 總是會使參數(shù)逃逸的原因。
例子非常多，這里不能一一列舉，我們只需要記住分析方法就好，即，2 級或更多級的訪問賦值會 容易 導(dǎo)致數(shù)據(jù)逃逸。這里加上 容易 二字是因為隨著語言的發(fā)展，相信這些問題會被慢慢解決，但現(xiàn)階段，這個可以作為我們分析逃逸現(xiàn)象的依據(jù)。
下面代碼中包含 2 種很常規(guī)的寫法，但他們卻有著很大的性能差距，建議自己想下為什么。
Benchmark 和 pprof 給出的結(jié)果:
熟悉堆棧概念可以讓我們更容易看透 Go 程序的性能問題，并進行優(yōu)化。
多級間接賦值會導(dǎo)致 Go 編譯器出現(xiàn)不必要的逃逸，在一些情況下可能我們只需要修改一下數(shù)據(jù)結(jié)構(gòu)就會使性能有大幅提升。這也是很多人不推薦在 Go 中使用指針的原因，因為它會增加一級訪問路徑，而 map , slice , interface{} 等類型是不可避免要用到的，為了減少不必要的逃逸，只能拿指針開刀了。
大多數(shù)情況下，性能優(yōu)化都會為程序帶來一定的復(fù)雜度。建議實際項目中還是怎么方便怎么寫，功能完成后通過性能分析找到瓶頸所在，再對局部進行優(yōu)化。
前端框架越來越豐富，前后端分離已經(jīng)是大多數(shù)軟件團隊采取的模式了。vue使用的場景也越來越多。
go本來使用template模板來進行前端的表現(xiàn)，現(xiàn)在可以用vue來分擔(dān)很大一部分工作了。
通常直接使用go語言寫后端，然后使用靜態(tài)模板加載渲染前端，前端獲取后端提供的數(shù)據(jù)是使用{{ }}符號，2個套在一起的花括號。這個也是vue使用的數(shù)據(jù)表現(xiàn)方式。
如果go+vue來協(xié)同工作的話，需要對vue進行一點設(shè)置。比如把{{ }}的方式改為[[ ]]的方式。
首先我們要知道，vue的使用，需要在頁面中加載vue.js或vue.min.js
純靜態(tài)網(wǎng)頁使用vue是這樣的（給個html例子）
然后我們實現(xiàn)一個go的簡單web服務(wù)和模板頁面
這個go服務(wù)器通過端口 1989 展示服務(wù)器頁面，提供了一個靜態(tài)文件路徑 htmlpage，我們把vue.js和index.html文件都放置在htmlpage路徑里。
go服務(wù)器還用模板給前臺頁面提供了一個News結(jié)構(gòu)的數(shù)據(jù)，數(shù)據(jù)包括：Title,Content,Author的值。
在index.html頁面中，加載vue.js的時候需要帶上靜態(tài)路徑 htmlpage
在 new 一個 vue 變量的時候，必須有一句來設(shè)置包裹數(shù)據(jù)的符號，我們這里設(shè)置這個符號為[[ ]]
同時，所有需要由 vue 渲染的數(shù)據(jù)，都寫成類似這樣的樣子
在 go + vue 方式下的完整模板文件 index.html
此頁面中{{ }}包裹的數(shù)據(jù)是由go從后端提供的數(shù)據(jù)（ 例如：{{.Title}}），而[[ ]]包裹的數(shù)據(jù)，是vue渲染的數(shù)據(jù)。
只是把 Vue里的數(shù)據(jù)，改為由go后端提供即可。
好吧，作者已經(jīng)在向月亮示愛了。呵呵 _
運行一下程序，看修改模板后的效果。
切換到新語言始終是一大步，尤其是當(dāng)您的團隊成員只有一個時有該語言的先前經(jīng)驗?，F(xiàn)在，Stream 的主要編程語言從 Python 切換到了 Go。這篇文章將解釋stream決定放棄 Python 并轉(zhuǎn)向 Go 的一些原因。
Go 非?？臁Ｐ阅茴愃朴?Java 或 C++。對于用例，Go 通常比 Python 快 40 倍。
對于許多應(yīng)用程序來說，編程語言只是應(yīng)用程序和數(shù)據(jù)庫之間的粘合劑。語言本身的性能通常并不重要。然而，Stream 是一個API 提供商，為 700 家公司和超過 5 億最終用戶提供提要和聊天平臺。多年來，我們一直在優(yōu)化 Cassandra、PostgreSQL、Redis 等，但最終，您會達(dá)到所使用語言的極限。Python 是一門很棒的語言，但對于序列化/反序列化、排名和聚合等用例，它的性能相當(dāng)緩慢。我們經(jīng)常遇到性能問題，Cassandra 需要 1 毫秒來檢索數(shù)據(jù)，而 Python 會花費接下來的 10 毫秒將其轉(zhuǎn)換為對象。
看看我如何開始 Go 教程中的一小段 Go 代碼。（這是一個很棒的教程，也是學(xué)習(xí) Go 的一個很好的起點。）
如果您是 Go 新手，那么在閱讀那個小代碼片段時不會有太多讓您感到驚訝的事情。它展示了多個賦值、數(shù)據(jù)結(jié)構(gòu)、指針、格式和一個內(nèi)置的 HTTP 庫。當(dāng)我第一次開始編程時，我一直喜歡使用 Python 更高級的功能。Python 允許您在編寫代碼時獲得相當(dāng)?shù)膭?chuàng)意。例如，您可以：
這些功能玩起來很有趣，但是，正如大多數(shù)程序員會同意的那樣，在閱讀別人的作品時，它們通常會使代碼更難理解。Go 迫使你堅持基礎(chǔ)。這使得閱讀任何人的代碼并立即了解發(fā)生了什么變得非常容易。 注意：當(dāng)然，它實際上有多“容易”取決于您的用例。如果你想創(chuàng)建一個基本的 CRUD API，我仍然推薦 Django + DRF或 Rails。
作為一門語言，Go 試圖讓事情變得簡單。它沒有引入許多新概念。重點是創(chuàng)建一種非?？焖偾乙子谑褂玫暮唵握Z言。它唯一具有創(chuàng)新性的領(lǐng)域是 goroutine 和通道。（100% 正確CSP的概念始于 1977 年，所以這項創(chuàng)新更多是對舊思想的一種新方法。）Goroutines 是 Go 的輕量級線程方法，通道是 goroutines 之間通信的首選方式。Goroutines 的創(chuàng)建非常便宜，并且只需要幾 KB 的額外內(nèi)存。因為 Goroutine 非常輕量，所以有可能同時運行數(shù)百甚至數(shù)千個。您可以使用通道在 goroutine 之間進行通信。Go 運行時處理所有復(fù)雜性。goroutines 和基于通道的并發(fā)方法使得使用所有可用的 CPU 內(nèi)核和處理并發(fā) IO 變得非常容易——所有這些都不會使開發(fā)復(fù)雜化。與 Python/Java 相比，在 goroutine 上運行函數(shù)需要最少的樣板代碼。您只需在函數(shù)調(diào)用前加上關(guān)鍵字“go”：
Go 的并發(fā)方法很容易使用。與 Node 相比，這是一種有趣的方法，開發(fā)人員必須密切關(guān)注異步代碼的處理方式。Go 中并發(fā)的另一個重要方面是競爭檢測器。這樣可以很容易地確定異步代碼中是否存在任何競爭條件。
我們目前用 Go 編寫的最大的微服務(wù)編譯需要 4 秒。與以編譯速度慢而聞名的 Java 和 C++ 等語言相比，Go 的快速編譯時間是一項重大的生產(chǎn)力勝利。我喜歡在程序編譯的時候摸魚，但在我還記得代碼應(yīng)該做什么的同時完成事情會更好。
首先，讓我們從顯而易見的開始：與 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++ 流行。幸運的是，Go 是一種非常簡單易學(xué)的語言。它提供了您需要的基本功能，僅此而已。它引入的新概念是“延遲”聲明和內(nèi)置的并發(fā)管理與“goroutines”和通道。（對于純粹主義者來說：Go 并不是第一種實現(xiàn)這些概念的語言，只是第一種使它們流行起來的語言。）任何加入團隊的 Python、Elixir、C++、Scala 或 Java 開發(fā)人員都可以在一個月內(nèi)在 Go 上發(fā)揮作用，因為它的簡單性。與許多其他語言相比，我們發(fā)現(xiàn)組建 Go 開發(fā)人員團隊更容易。如果您在博爾德和阿姆斯特丹等競爭激烈的生態(tài)系統(tǒng)中招聘人員，這是一項重要的優(yōu)勢。
對于我們這樣規(guī)模的團隊（約 20 人）來說，生態(tài)系統(tǒng)很重要。如果您必須重新發(fā)明每一個小功能，您根本無法為您的客戶創(chuàng)造價值。Go 對我們使用的工具有很好的支持。實體庫已經(jīng)可用于 Redis、RabbitMQ、PostgreSQL、模板解析、任務(wù)調(diào)度、表達(dá)式解析和 RocksDB。與 Rust 或 Elixir 等其他較新的語言相比，Go 的生態(tài)系統(tǒng)是一個重大勝利。它當(dāng)然不如 Java、Python 或 Node 之類的語言好，但它很可靠，而且對于許多基本需求，你會發(fā)現(xiàn)已經(jīng)有高質(zhì)量的包可用。
Gofmt 是一個很棒的命令行實用程序，內(nèi)置在 Go 編譯器中，用于格式化代碼。就功能而言，它與 Python 的 autopep8 非常相似。我們大多數(shù)人并不真正喜歡爭論制表符與空格。格式的一致性很重要，但實際的格式標(biāo)準(zhǔn)并不那么重要。Gofmt 通過使用一種正式的方式來格式化您的代碼來避免所有這些討論。
Go 對協(xié)議緩沖區(qū)和 gRPC 具有一流的支持。這兩個工具非常適合構(gòu)建需要通過 RPC 通信的微服務(wù)。您只需要編寫一個清單，在其中定義可以進行的 RPC 調(diào)用以及它們采用的參數(shù)。然后從這個清單中自動生成服務(wù)器和客戶端代碼。生成的代碼既快速又具有非常小的網(wǎng)絡(luò)占用空間并且易于使用。從同一個清單中，您甚至可以為許多不同的語言生成客戶端代碼，例如 C++、Java、Python 和 Ruby。因此，內(nèi)部流量不再有模棱兩可的 REST 端點，您每次都必須編寫幾乎相同的客戶端和服務(wù)器代碼。.
Go 沒有像 Rails 用于 Ruby、Django 用于 Python 或 Laravel 用于 PHP 那樣的單一主導(dǎo)框架。這是 Go 社區(qū)內(nèi)激烈爭論的話題，因為許多人主張你不應(yīng)該一開始就使用框架。我完全同意這對于某些用例是正確的。但是，如果有人想構(gòu)建一個簡單的 CRUD API，他們將更容易使用 Django/DJRF、Rails Laravel 或Phoenix。對于 Stream 的用例，我們更喜歡不使用框架。然而，對于許多希望提供簡單 CRUD API 的新項目來說，缺乏主導(dǎo)框架將是一個嚴(yán)重的劣勢。
Go 通過簡單地從函數(shù)返回錯誤并期望調(diào)用代碼來處理錯誤（或?qū)⑵浞祷氐秸{(diào)用堆棧）來處理錯誤。雖然這種方法有效，但很容易失去問題的范圍，以確保您可以向用戶提供有意義的錯誤。錯誤包通過允許您向錯誤添加上下文和堆棧跟蹤來解決此問題。另一個問題是很容易忘記處理錯誤。像 errcheck 和 megacheck 這樣的靜態(tài)分析工具可以方便地避免犯這些錯誤。雖然這些變通辦法效果很好，但感覺不太對勁。您希望該語言支持正確的錯誤處理。
Go 的包管理絕不是完美的。默認(rèn)情況下，它無法指定特定版本的依賴項，也無法創(chuàng)建可重現(xiàn)的構(gòu)建。Python、Node 和 Ruby 都有更好的包管理系統(tǒng)。但是，使用正確的工具，Go 的包管理工作得很好。您可以使用Dep來管理您的依賴項，以允許指定和固定版本。除此之外，我們還貢獻了一個名為的開源工具VirtualGo，它可以更輕松地處理用 Go 編寫的多個項目。
我們進行的一個有趣的實驗是在 Python 中使用我們的排名提要功能并在 Go 中重寫它。看看這個排名方法的例子：
Python 和 Go 代碼都需要執(zhí)行以下操作來支持這種排名方法：
開發(fā) Python 版本的排名代碼大約花了 3 天時間。這包括編寫代碼、單元測試和文檔。接下來，我們花了大約 2 周的時間優(yōu)化代碼。其中一項優(yōu)化是將分?jǐn)?shù)表達(dá)式 (simple_gauss(time)*popularity) 轉(zhuǎn)換為抽象語法樹. 我們還實現(xiàn)了緩存邏輯，可以在未來的特定時間預(yù)先計算分?jǐn)?shù)。相比之下，開發(fā)此代碼的 Go 版本大約需要 4 天時間。性能不需要任何進一步的優(yōu)化。因此，雖然 Python 的最初開發(fā)速度更快，但基于 Go 的版本最終需要我們團隊的工作量大大減少。另外一個好處是，Go 代碼的執(zhí)行速度比我們高度優(yōu)化的 Python 代碼快大約 40 倍?，F(xiàn)在，這只是我們通過切換到 Go 體驗到的性能提升的一個示例。
與 Python 相比，我們系統(tǒng)的其他一些組件在 Go 中構(gòu)建所需的時間要多得多。作為一個總體趨勢，我們看到 開發(fā) Go 代碼需要更多的努力。但是，我們花更少的時間 優(yōu)化 代碼以提高性能。
我們評估的另一種語言是Elixir.。Elixir 建立在 Erlang 虛擬機之上。這是一種迷人的語言，我們之所以考慮它，是因為我們的一名團隊成員在 Erlang 方面擁有豐富的經(jīng)驗。對于我們的用例，我們注意到 Go 的原始性能要好得多。Go 和 Elixir 都可以很好地服務(wù)數(shù)千個并發(fā)請求。但是，如果您查看單個請求的性能，Go 對于我們的用例來說要快得多。我們選擇 Go 而不是 Elixir 的另一個原因是生態(tài)系統(tǒng)。對于我們需要的組件，Go 有更成熟的庫，而在許多情況下，Elixir 庫還沒有準(zhǔn)備好用于生產(chǎn)環(huán)境。培訓(xùn)/尋找開發(fā)人員使用 Elixir 也更加困難。這些原因使天平向 Go 傾斜。Elixir 的 Phoenix 框架看起來很棒，絕對值得一看。
Go 是一種非常高性能的語言，對并發(fā)有很好的支持。它幾乎與 C++ 和 Java 等語言一樣快。雖然與 Python 或 Ruby 相比，使用 Go 構(gòu)建東西確實需要更多時間，但您將節(jié)省大量用于優(yōu)化代碼的時間。我們在Stream有一個小型開發(fā)團隊，為超過 5 億最終用戶提供動力和聊天。Go 結(jié)合了 強大的生態(tài)系統(tǒng) 、新開發(fā)人員的 輕松入門、快速的性能 、對并發(fā)的 可靠支持和高效的編程環(huán)境 ，使其成為一個不錯的選擇。Stream 仍然在我們的儀表板、站點和機器學(xué)習(xí)中利用 Python 來提供個性化的訂閱源. 我們不會很快與 Python 說再見，但今后所有性能密集型代碼都將使用 Go 編寫。我們新的聊天 API也完全用 Go 編寫。
重慶分公司
重慶分公司
