go語言100個(gè)常用方法,go語言簡單
如何用go語言每分鐘處理100萬個(gè)請(qǐng)求
在Malwarebytes 我們經(jīng)歷了顯著的增長，自從我一年前加入了硅谷的公司，一個(gè)主要的職責(zé)成了設(shè)計(jì)架構(gòu)和開發(fā)一些系統(tǒng)來支持一個(gè)快速增長的信息安全公司和所有需要的設(shè)施來支持一個(gè)每天百萬用戶使用的產(chǎn)品。我在反病毒和反惡意軟件行業(yè)的不同公司工作了12年，從而我知道由于我們每天處理大量的數(shù)據(jù)，這些系統(tǒng)是多么復(fù)雜。
成都創(chuàng)新互聯(lián)公司網(wǎng)站建設(shè)公司是一家服務(wù)多年做網(wǎng)站建設(shè)策劃設(shè)計(jì)制作的公司,為廣大用戶提供了成都網(wǎng)站設(shè)計(jì)、網(wǎng)站建設(shè)、外貿(mào)網(wǎng)站建設(shè)，成都網(wǎng)站設(shè)計(jì)，廣告投放平臺(tái)，成都做網(wǎng)站選成都創(chuàng)新互聯(lián)公司，貼合企業(yè)需求，高性價(jià)比，滿足客戶不同層次的需求一站式服務(wù)歡迎致電。
有趣的是，在過去的大約9年間，我參與的所有的web后端的開發(fā)通常是通過Ruby on Rails技術(shù)實(shí)現(xiàn)的。不要錯(cuò)怪我。我喜歡Ruby on Rails，并且我相信它是個(gè)令人驚訝的環(huán)境。但是一段時(shí)間后，你會(huì)開始以ruby的方式開始思考和設(shè)計(jì)系統(tǒng)，你會(huì)忘記，如果你可以利用多線程、并行、快速執(zhí)行和小內(nèi)存開銷，軟件架構(gòu)本來應(yīng)該是多么高效和簡單。很多年期間，我是一個(gè)c/c++、Delphi和c#開發(fā)者，我剛開始意識(shí)到使用正確的工具可以把復(fù)雜的事情變得簡單些。
作為首席架構(gòu)師，我不會(huì)很關(guān)心在互聯(lián)網(wǎng)上的語言和框架戰(zhàn)爭。我相信效率、生產(chǎn)力。代碼可維護(hù)性主要依賴于你如何把解決方案設(shè)計(jì)得很簡單。
問題
當(dāng)工作在我們的匿名遙測(cè)和分析系統(tǒng)中，我們的目標(biāo)是可以處理來自于百萬級(jí)別的終端的大量的POST請(qǐng)求。web處理服務(wù)可以接收包含了很多payload的集合的JSON數(shù)據(jù)，這些數(shù)據(jù)需要寫入Amazon S3中。接下來，map-reduce系統(tǒng)可以操作這些數(shù)據(jù)。
按照習(xí)慣，我們會(huì)調(diào)研服務(wù)層級(jí)架構(gòu)，涉及的軟件如下：
Sidekiq
Resque
DelayedJob
Elasticbeanstalk Worker Tier
RabbitMQ
and so on…
搭建了2個(gè)不同的集群，一個(gè)提供web前端，另外一個(gè)提供后端處理，這樣我們可以橫向擴(kuò)展后端服務(wù)的數(shù)量。
但是，從剛開始，在 討論階段我們的團(tuán)隊(duì)就知道我們應(yīng)該使用Go，因?yàn)槲覀兛吹竭@會(huì)潛在性地成為一個(gè)非常龐大（ large traffic）的系統(tǒng)。我已經(jīng)使用了Go語言大約2年時(shí)間，我們開發(fā)了幾個(gè)系統(tǒng)，但是很少會(huì)達(dá)到這樣的負(fù)載（amount of load）。
我們開始創(chuàng)建一些結(jié)構(gòu)，定義從POST調(diào)用得到的web請(qǐng)求負(fù)載，還有一個(gè)上傳到S3 budket的函數(shù)。
type PayloadCollection struct {
WindowsVersion string `json:"version"`
Token string `json:"token"`
Payloads []Payload `json:"data"`
}
type Payload struct {
// [redacted]
}
func (p *Payload) UploadToS3() error {
// the storageFolder method ensures that there are no name collision in
// case we get same timestamp in the key name
storage_path := fmt.Sprintf("%v/%v", p.storageFolder, time.Now().UnixNano())
bucket := S3Bucket
b := new(bytes.Buffer)
encodeErr := json.NewEncoder(b).Encode(payload)
if encodeErr != nil {
return encodeErr
}
// Everything we post to the S3 bucket should be marked 'private'
var acl = s3.Private
var contentType = "application/octet-stream"
return bucket.PutReader(storage_path, b, int64(b.Len()), contentType, acl, s3.Options{})
}
本地Go routines方法
剛開始，我們采用了一個(gè)非常本地化的POST處理實(shí)現(xiàn)，僅僅嘗試把發(fā)到簡單go routine的job并行化：
func payloadHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
// Read the body into a string for json decoding
var content = PayloadCollection{}
err := json.NewDecoder(io.LimitReader(r.Body, MaxLength)).Decode(content)
if err != nil {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusBadRequest)
return
}
// Go through each payload and queue items individually to be posted to S3
for _, payload := range content.Payloads {
go payload.UploadToS3() // ----- DON'T DO THIS
}
w.WriteHeader(http.StatusOK)
}
對(duì)于中小負(fù)載，這會(huì)對(duì)大多數(shù)的人適用，但是大規(guī)模下，這個(gè)方案會(huì)很快被證明不是很好用。我們期望的請(qǐng)求數(shù)，不在我們剛開始計(jì)劃的數(shù)量級(jí)，當(dāng)我們把第一個(gè)版本部署到生產(chǎn)環(huán)境上。我們完全低估了流量。
上面的方案在很多地方很不好。沒有辦法控制我們產(chǎn)生的go routine的數(shù)量。由于我們收到了每分鐘1百萬的POST請(qǐng)求，這段代碼很快就崩潰了。
再次嘗試
我們需要找一個(gè)不同的方式。自開始我們就討論過， 我們需要保持請(qǐng)求處理程序的生命周期很短，并且進(jìn)程在后臺(tái)產(chǎn)生。當(dāng)然，這是你在Ruby on Rails的世界里必須要做的事情，否則你會(huì)阻塞在所有可用的工作 web處理器上，不管你是使用puma、unicore還是passenger（我們不要討論JRuby這個(gè)話題）。然后我們需要利用常用的處理方案來做這些，比如Resque、 Sidekiq、 SQS等。這個(gè)列表會(huì)繼續(xù)保留，因?yàn)橛泻芏嗟姆桨缚梢詫?shí)現(xiàn)這些。
所以，第二次迭代，我們創(chuàng)建了一個(gè)緩沖channel，我們可以把job排隊(duì)，然后把它們上傳到S3。因?yàn)槲覀兛梢钥刂莆覀冴?duì)列中的item最大值，我們有大量的內(nèi)存來排列job，我們認(rèn)為只要把job在channel里面緩沖就可以了。
var Queue chan Payload
func init() {
Queue = make(chan Payload, MAX_QUEUE)
}
func payloadHandler(w http.ResponseWriter, r *http.Request) {
...
// Go through each payload and queue items individually to be posted to S3
for _, payload := range content.Payloads {
Queue - payload
}
...
}
接下來，我們?cè)購年?duì)列中取job，然后處理它們。我們使用類似于下面的代碼：
func StartProcessor() {
for {
select {
case job := -Queue:
job.payload.UploadToS3() // -- STILL NOT GOOD
}
}
}
說實(shí)話，我不知道我們?cè)谙胧裁?。這肯定是一個(gè)滿是Red-Bulls的夜晚。這個(gè)方法不會(huì)帶來什么改善，我們用了一個(gè) 有缺陷的緩沖隊(duì)列并發(fā)，僅僅是把問題推遲了。我們的同步處理器同時(shí)僅僅會(huì)上傳一個(gè)數(shù)據(jù)到S3，因?yàn)閬淼降恼?qǐng)求遠(yuǎn)遠(yuǎn)大于單核處理器上傳到S3的能力，我們的帶緩沖channel很快達(dá)到了它的極限，然后阻塞了請(qǐng)求處理邏輯的queue更多item的能力。
我們僅僅避免了問題，同時(shí)開始了我們的系統(tǒng)掛掉的倒計(jì)時(shí)。當(dāng)部署了這個(gè)有缺陷的版本后，我們的延時(shí)保持在每分鐘以常量增長。
最好的解決方案
我們討論過在使用用Go channel時(shí)利用一種常用的模式，來創(chuàng)建一個(gè)二級(jí)channel系統(tǒng)，一個(gè)來queue job，另外一個(gè)來控制使用多少個(gè)worker來并發(fā)操作JobQueue。
想法是，以一個(gè)恒定速率并行上傳到S3，既不會(huì)導(dǎo)致機(jī)器崩潰也不好產(chǎn)生S3的連接錯(cuò)誤。這樣我們選擇了創(chuàng)建一個(gè)Job/Worker模式。對(duì)于那些熟悉Java、C#等語言的開發(fā)者，可以把這種模式想象成利用channel以golang的方式來實(shí)現(xiàn)了一個(gè)worker線程池，作為一種替代。
var (
MaxWorker = os.Getenv("MAX_WORKERS")
MaxQueue = os.Getenv("MAX_QUEUE")
)
// Job represents the job to be run
type Job struct {
Payload Payload
}
// A buffered channel that we can send work requests on.
var JobQueue chan Job
// Worker represents the worker that executes the job
type Worker struct {
WorkerPool chan chan Job
JobChannel chan Job
quit chan bool
}
func NewWorker(workerPool chan chan Job) Worker {
return Worker{
WorkerPool: workerPool,
JobChannel: make(chan Job),
quit: make(chan bool)}
}
// Start method starts the run loop for the worker, listening for a quit channel in
// case we need to stop it
func (w Worker) Start() {
go func() {
for {
// register the current worker into the worker queue.
w.WorkerPool - w.JobChannel
select {
case job := -w.JobChannel:
// we have received a work request.
if err := job.Payload.UploadToS3(); err != nil {
log.Errorf("Error uploading to S3: %s", err.Error())
}
case -w.quit:
// we have received a signal to stop
return
}
}
}()
}
// Stop signals the worker to stop listening for work requests.
func (w Worker) Stop() {
go func() {
w.quit - true
}()
}
我們已經(jīng)修改了我們的web請(qǐng)求handler，用payload創(chuàng)建一個(gè)Job實(shí)例，然后發(fā)到JobQueue channel，以便于worker來獲取。
func payloadHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
// Read the body into a string for json decoding
var content = PayloadCollection{}
err := json.NewDecoder(io.LimitReader(r.Body, MaxLength)).Decode(content)
if err != nil {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(http.StatusBadRequest)
return
}
// Go through each payload and queue items individually to be posted to S3
for _, payload := range content.Payloads {
// let's create a job with the payload
work := Job{Payload: payload}
// Push the work onto the queue.
JobQueue - work
}
w.WriteHeader(http.StatusOK)
}
在web server初始化時(shí)，我們創(chuàng)建一個(gè)Dispatcher，然后調(diào)用Run()函數(shù)創(chuàng)建一個(gè)worker池子，然后開始監(jiān)聽JobQueue中的job。
dispatcher := NewDispatcher(MaxWorker)
dispatcher.Run()
下面是dispatcher的實(shí)現(xiàn)代碼：
type Dispatcher struct {
// A pool of workers channels that are registered with the dispatcher
WorkerPool chan chan Job
}
func NewDispatcher(maxWorkers int) *Dispatcher {
pool := make(chan chan Job, maxWorkers)
return Dispatcher{WorkerPool: pool}
}
func (d *Dispatcher) Run() {
// starting n number of workers
for i := 0; i d.maxWorkers; i++ {
worker := NewWorker(d.pool)
worker.Start()
}
go d.dispatch()
}
func (d *Dispatcher) dispatch() {
for {
select {
case job := -JobQueue:
// a job request has been received
go func(job Job) {
// try to obtain a worker job channel that is available.
// this will block until a worker is idle
jobChannel := -d.WorkerPool
// dispatch the job to the worker job channel
jobChannel - job
}(job)
}
}
}
注意到，我們提供了初始化并加入到池子的worker的最大數(shù)量。因?yàn)檫@個(gè)工程我們利用了Amazon Elasticbeanstalk帶有的docker化的Go環(huán)境，所以我們常常會(huì)遵守12-factor方法論來配置我們的生成環(huán)境中的系統(tǒng)，我們從環(huán)境變了讀取這些值。這種方式，我們控制worker的數(shù)量和JobQueue的大小，所以我們可以很快的改變這些值，而不需要重新部署集群。
var (
MaxWorker = os.Getenv("MAX_WORKERS")
MaxQueue = os.Getenv("MAX_QUEUE")
)
直接結(jié)果
我們部署了之后，立馬看到了延時(shí)降到微乎其微的數(shù)值，并未我們處理請(qǐng)求的能力提升很大。
Elastic Load Balancers完全啟動(dòng)后，我們看到ElasticBeanstalk 應(yīng)用服務(wù)于每分鐘1百萬請(qǐng)求。通常情況下在上午時(shí)間有幾個(gè)小時(shí)，流量峰值超過每分鐘一百萬次。
我們一旦部署了新的代碼，服務(wù)器的數(shù)量從100臺(tái)大幅 下降到大約20臺(tái)。
我們合理配置了我們的集群和自動(dòng)均衡配置之后，我們可以把服務(wù)器的數(shù)量降至4x EC2 c4.Large實(shí)例，并且Elastic Auto-Scaling設(shè)置為如果CPU達(dá)到5分鐘的90%利用率，我們就會(huì)產(chǎn)生新的實(shí)例。
總結(jié)
在我的書中，簡單總是獲勝。我們可以使用多隊(duì)列、后臺(tái)worker、復(fù)雜的部署設(shè)計(jì)一個(gè)復(fù)雜的系統(tǒng)，但是我們決定利用Elasticbeanstalk 的auto-scaling的能力和Go語言開箱即用的特性簡化并發(fā)。
我們僅僅用了4臺(tái)機(jī)器，這并不是什么新鮮事了?？赡芩鼈冞€不如我的MacBook能力強(qiáng)大，但是卻處理了每分鐘1百萬的寫入到S3的請(qǐng)求。
處理問題有正確的工具。當(dāng)你的 Ruby on Rails 系統(tǒng)需要更強(qiáng)大的web handler時(shí)，可以考慮下ruby生態(tài)系統(tǒng)之外的技術(shù)，或許可以得到更簡單但更強(qiáng)大的替代方案。
GO語言學(xué)習(xí)系列八——GO函數(shù)(func)的聲明與使用
GO是編譯性語言，所以函數(shù)的順序是無關(guān)緊要的，為了方便閱讀，建議入口函數(shù) main 寫在最前面，其余函數(shù)按照功能需要進(jìn)行排列
GO的函數(shù) 不支持嵌套，重載和默認(rèn)參數(shù)
GO的函數(shù) 支持 無需聲明變量，可變長度，多返回值，匿名，閉包等
GO的函數(shù)用 func 來聲明，且左大括號(hào) { 不能另起一行
一個(gè)簡單的示例：
輸出為：
參數(shù)：可以傳0個(gè)或多個(gè)值來供自己用
返回：通過用 return 來進(jìn)行返回
輸出為：
上面就是一個(gè)典型的多參數(shù)傳遞與多返回值
對(duì)例子的說明：
按值傳遞：是對(duì)某個(gè)變量進(jìn)行復(fù)制，不能更改原變量的值
引用傳遞：相當(dāng)于按指針傳遞，可以同時(shí)改變?cè)瓉淼闹担⑶蚁牡膬?nèi)存會(huì)更少，只有4或8個(gè)字節(jié)的消耗
在上例中，返回值 (d int, e int, f int) { 是進(jìn)行了命名，如果不想命名可以寫成 (int,int,int){ ,返回的結(jié)果都是一樣的，但要注意:
當(dāng)返回了多個(gè)值，我們某些變量不想要，或?qū)嶋H用不到，我們可以使用 _ 來補(bǔ)位，例如上例的返回我們可以寫成 d,_,f := test(a,b,c) ，我們不想要中間的返回值，可以以這種形式來舍棄掉
在參數(shù)后面以 變量 ... type 這種形式的，我們就要以判斷出這是一個(gè)可變長度的參數(shù)
輸出為：
在上例中， strs ...string 中， strs 的實(shí)際值是b,c,d,e,這就是一個(gè)最簡單的傳遞可變長度的參數(shù)的例子，更多一些演變的形式，都非常類似
在GO中 defer 關(guān)鍵字非常重要，相當(dāng)于面相對(duì)像中的析構(gòu)函數(shù)，也就是在某個(gè)函數(shù)執(zhí)行完成后，GO會(huì)自動(dòng)這個(gè)；
如果在多層循環(huán)中函數(shù)里，都定義了 defer ,那么它的執(zhí)行順序是先進(jìn)后出；
當(dāng)某個(gè)函數(shù)出現(xiàn)嚴(yán)重錯(cuò)誤時(shí)， defer 也會(huì)被調(diào)用
輸出為
這是一個(gè)最簡單的測(cè)試了，當(dāng)然還有更復(fù)雜的調(diào)用，比如調(diào)試程序時(shí)，判斷是哪個(gè)函數(shù)出了問題，完全可以根據(jù) defer 打印出來的內(nèi)容來進(jìn)行判斷，非?？焖?，這種留給你們?nèi)?shí)現(xiàn)
一個(gè)函數(shù)在函數(shù)體內(nèi)自己調(diào)用自己我們稱之為遞歸函數(shù)，在做遞歸調(diào)用時(shí)，經(jīng)常會(huì)將內(nèi)存給占滿，這是非常要注意的，常用的比如，快速排序就是用的遞歸調(diào)用
本篇重點(diǎn)介紹了GO函數(shù)(func)的聲明與使用，下一篇將介紹GO的結(jié)構(gòu) struct
怎么樣使用Go語言中函數(shù)的參數(shù)傳遞與調(diào)用
按值傳遞函數(shù)參數(shù)，是拷貝參數(shù)的實(shí)際值到函數(shù)的形式參數(shù)的方法調(diào)用。在這種情況下，參數(shù)在函數(shù)內(nèi)變化對(duì)參數(shù)不會(huì)有影響。
默認(rèn)情況下，Go編程語言使用調(diào)用通過值的方法來傳遞參數(shù)。在一般情況下，這意味著，在函數(shù)內(nèi)碼不能改變用來調(diào)用所述函數(shù)的參數(shù)。考慮函數(shù)swap()的定義如下。
代碼如下:
/* function definition to swap the values */
func swap(int x, int y) int {
var temp int
temp = x /* save the value of x */
x = y /* put y into x */
y = temp /* put temp into y */
return temp;
}
現(xiàn)在，讓我們通過使實(shí)際值作為在以下示例調(diào)用函數(shù)swap()：
代碼如下:
package main
import "fmt"
func main() {
/* local variable definition */
var a int = 100
var b int = 200
fmt.Printf("Before swap, value of a : %d\n", a )
fmt.Printf("Before swap, value of b : %d\n", b )
/* calling a function to swap the values */
swap(a, b)
fmt.Printf("After swap, value of a : %d\n", a )
fmt.Printf("After swap, value of b : %d\n", b )
}
func swap(x, y int) int {
var temp int
temp = x /* save the value of x */
x = y /* put y into x */
y = temp /* put temp into y */
return temp;
}
讓我們把上面的代碼放在一個(gè)C文件，編譯并執(zhí)行它，它會(huì)產(chǎn)生以下結(jié)果：
Before swap, value of a :100
Before swap, value of b :200
After swap, value of a :100
After swap, value of b :200
這表明，參數(shù)值沒有被改變，雖然它們已經(jīng)在函數(shù)內(nèi)部改變。
通過傳遞函數(shù)參數(shù)，即是拷貝參數(shù)的地址到形式參數(shù)的參考方法調(diào)用。在函數(shù)內(nèi)部，地址是訪問調(diào)用中使用的實(shí)際參數(shù)。這意味著，對(duì)參數(shù)的更改會(huì)影響傳遞的參數(shù)。
要通過引用傳遞的值，參數(shù)的指針被傳遞給函數(shù)就像任何其他的值。所以，相應(yīng)的，需要聲明函數(shù)的參數(shù)為指針類型如下面的函數(shù)swap()，它的交換兩個(gè)整型變量的值指向它的參數(shù)。
代碼如下:
/* function definition to swap the values */
func swap(x *int, y *int) {
var temp int
temp = *x /* save the value at address x */
*x = *y /* put y into x */
*y = temp /* put temp into y */
}
現(xiàn)在，讓我們調(diào)用函數(shù)swap()通過引用作為在下面的示例中傳遞數(shù)值：
代碼如下:
package main
import "fmt"
func main() {
/* local variable definition */
var a int = 100
var b int= 200
fmt.Printf("Before swap, value of a : %d\n", a )
fmt.Printf("Before swap, value of b : %d\n", b )
/* calling a function to swap the values.
* a indicates pointer to a ie. address of variable a and
* b indicates pointer to b ie. address of variable b.
*/
swap(a, b)
fmt.Printf("After swap, value of a : %d\n", a )
fmt.Printf("After swap, value of b : %d\n", b )
}
func swap(x *int, y *int) {
var temp int
temp = *x /* save the value at address x */
*x = *y /* put y into x */
*y = temp /* put temp into y */
}
讓我們把上面的代碼放在一個(gè)C文件，編譯并執(zhí)行它，它會(huì)產(chǎn)生以下結(jié)果：
Before swap, value of a :100
Before swap, value of b :200
After swap, value of a :200
After swap, value of b :100
這表明變化的功能以及不同于通過值調(diào)用的外部體現(xiàn)的改變不能反映函數(shù)之外。
Go語言基礎(chǔ)語法（一）
本文介紹一些Go語言的基礎(chǔ)語法。
先來看一個(gè)簡單的go語言代碼：
go語言的注釋方法：
代碼執(zhí)行結(jié)果：
下面來進(jìn)一步介紹go的基礎(chǔ)語法。
go語言中格式化輸出可以使用 fmt 和 log 這兩個(gè)標(biāo)準(zhǔn)庫，
常用方法：
示例代碼：
執(zhí)行結(jié)果：
更多格式化方法可以訪問中的fmt包。
log包實(shí)現(xiàn)了簡單的日志服務(wù)，也提供了一些格式化輸出的方法。
執(zhí)行結(jié)果：
下面來介紹一下go的數(shù)據(jù)類型
下表列出了go語言的數(shù)據(jù)類型：
int、float、bool、string、數(shù)組和struct屬于值類型，這些類型的變量直接指向存在內(nèi)存中的值；slice、map、chan、pointer等是引用類型，存儲(chǔ)的是一個(gè)地址，這個(gè)地址存儲(chǔ)最終的值。
常量是在程序編譯時(shí)就確定下來的值，程序運(yùn)行時(shí)無法改變。
執(zhí)行結(jié)果：
執(zhí)行結(jié)果：
Go 語言的運(yùn)算符主要包括算術(shù)運(yùn)算符、關(guān)系運(yùn)算符、邏輯運(yùn)算符、位運(yùn)算符、賦值運(yùn)算符以及指針相關(guān)運(yùn)算符。
算術(shù)運(yùn)算符：
關(guān)系運(yùn)算符：
邏輯運(yùn)算符：
位運(yùn)算符：
賦值運(yùn)算符：
指針相關(guān)運(yùn)算符：
下面介紹一下go語言中的if語句和switch語句。另外還有一種控制語句叫select語句，通常與通道聯(lián)用，這里不做介紹。
if語法格式如下：
if ... else ：
else if：
示例代碼：
語法格式：
另外，添加 fallthrough 會(huì)強(qiáng)制執(zhí)行后面的 case 語句，不管下一條case語句是否為true。
示例代碼：
執(zhí)行結(jié)果：
下面介紹幾種循環(huán)語句：
執(zhí)行結(jié)果：
執(zhí)行結(jié)果：
也可以通過標(biāo)記退出循環(huán)：
--THE END--
本文標(biāo)題：go語言100個(gè)常用方法,go語言簡單
轉(zhuǎn)載來源：http://m.jiaotiyi.com/article/dsigepc.html