golang gin 框架 異步同步 goroutine 并發(fā)操作
goroutine機制可以方便地實現(xiàn)異步處理
package main
import (
"log"
"time"
"github.com/gin-gonic/gin"
)
func main() {
// 1.創(chuàng)建路由
// 默認使用了2個中間件Logger(), Recovery()
r := gin.Default()
// 1.異步
r.GET("/long_async", func(c *gin.Context) {
// 需要搞一個副本
copyContext := c.Copy()
// 異步處理
go func() {
time.Sleep(3 * time.Second)
log.Println("異步執(zhí)行：" + copyContext.Request.URL.Path)
}()
})
// 2.同步
r.GET("/long_sync", func(c *gin.Context) {
time.Sleep(3 * time.Second)
log.Println("同步執(zhí)行：" + c.Request.URL.Path)
})
r.Run(":8000")
}
補充：Golang的channel使用以及并發(fā)同步技巧
在學習《The Go Programming Language》第八章并發(fā)單元的時候還是遭遇了不少問題，和值得總結(jié)思考和記錄的地方。
做一個類似于unix du命令的工具。但是閹割了一些功能，這里應該只實現(xiàn)-c(統(tǒng)計total大小) 和-h(以human比較容易辨識的顯示出來)的功能。
首先我們需要構(gòu)造一個 能夠返回FileInfo信息數(shù)組的函數(shù)，我們把它取名為dirEntries:
func dirEntries(dir string) []os.FileInfo {
entries, err := ioutil.ReadDir(dir)
if err != nil {
fmt.Fprintf(os.Stderr, "du: %v\n", err)
return nil
}
return entries
}
傳入一個路徑字符串，然后使用ioutil.ReadDir解析這個路徑下面的所有文件以及文件夾生成一個FileInfo的profile。
Fileinfo interface下面包含了：
type FileInfo interface {
Name() string // base name of the file
Size() int64 // length in bytes for regular files; system-dependent for others
Mode() FileMode // file mode bits
ModTime() time.Time // modification time
IsDir() bool // abbreviation for Mode().IsDir()
Sys() interface{} // underlying data source (can return nil)
}
多種方法，可以直接調(diào)用，其作用就是后面注釋寫的一樣。
有了能夠獲取文件夾下面文件和文件夾的函數(shù)之后，我們需要一個調(diào)用方用來walk指定的目錄：
// 入?yún)⑹且粋€文件目錄，一個INT64的只接收的單向channel
func walkDir(dir string, fileSizes chan<- int64) {
for _, entry := range dirEntries(dir) {
if entry.IsDir() {
subdir := filepath.Join(dir, entry.Name())
walkDir(subdir, fileSizes)
} else {
fileSizes <- entry.Size()
}
}
}
這里我們定義一個目錄，然后需求傳入一個單向接收channel用于在多goroutine中計算總共的文件大小。
使用range方法來遍歷我們上面寫的dirEntries的返回文件或文件夾，如果是文件夾則繼續(xù)迭代。
如果不是則將文件大小存入放入fileSizes channel中。
搞定上面兩個函數(shù)，我們來寫主函數(shù)部分：
func main() {
root := ""
flag.StringVar(&root, "-p", ".", "input dir.")
flag.Parse()
fileSizes := make(chan int64)
// 起一個goroutine去walk目錄
go func() {
walkDir(root, fileSizes)
// Walk完畢之后要關(guān)閉該channel下面使用range讀取數(shù)據(jù)的時候才會有盡頭
close(fileSizes)
}()
var nfiles, nbytes int64
for size := range fileSizes {
nfiles++
nbytes += size
}
fmt.Printf("%d files %.1f GB\n", nfiles, float64(nbytes)/1e9)
}
這里注意一點，因為起goroutine的walk函數(shù)，和下面同時在range遍歷是在同步進行，如果下面range速度太快讀到管道里面沒有值了會阻塞住等待有數(shù)據(jù)繼續(xù)進來之后讀取，而不是會跳出。只有當close(fileSizes)這句執(zhí)行到，顯示關(guān)閉掉channel之后，才會跳出range循環(huán)并且這時已經(jīng)讀取完了所有的數(shù)據(jù)。這里有點像，close channel的時候給range發(fā)送了一個停止信號一樣，感覺這個利用起來會比較有用？ 后續(xù)可能會再研究一下。
讓我們繼續(xù)來優(yōu)化我們的程序，添加一個-v參數(shù)，打印出掃描文件的進度，當我們要掃描整個盤的時候，可能會花費大量的時間，我們需要知道進度如何了。
其實這個需求只需要很小的改動，讓我們來重新改寫一下main函數(shù)，用select多路復用來完成這個事情。
func main() {
root := ""
verbose := false
tick := make(<-chan time.Time)
var nfiles, nbytes int64
flag.StringVar(&root, "p", ".", "input dir.")
flag.BoolVar(&verbose, "v", false, "add verbose if you want")
flag.Parse()
if verbose {
tick = time.Tick(500 * time.Millisecond)
}
fileSizes := make(chan int64)
// 起一個goroutine去walk目錄
go func() {
walkDir(root, fileSizes)
// Walk完畢之后要關(guān)閉該channel下面使用range讀取數(shù)據(jù)的時候才會有盡頭
close(fileSizes)
}()
loop:
for {
select {
case size, ok := <-fileSizes:
if !ok {
break loop
}
nfiles++
nbytes += size
case <-tick:
fmt.Printf("%d files %.1f GB\n", nfiles, float64(nbytes)/1e9)
}
}
fmt.Printf("%d files %.1f GB\n", nfiles, float64(nbytes)/1e9)
}
上面其實都差不多，這里我直接從loop那里開始說吧，遇到這個loop的時候我其實還蠻疑惑的，因為我在go語言保留關(guān)鍵字里面并沒有看到他的身影，但是這里他的確是個關(guān)鍵字，和里面的break連用 里面break后面跟上的loop 可以直接跳出到最外層loop包裹的循環(huán)，而不是break默認的只跳出一層循環(huán)。明白了這個道理之后，這個就不難理解了，當我們還在遍歷文件的時候，select 會持續(xù)讀取文件大小賦值給size，并且返回true給ok。如果我們開啟了verbose，每隔500毫秒tick會收到來自time.Tick的消息。我們都知道select會在都準備好的情況下隨機pick一個執(zhí)行，所以這里也或快或慢的被打印進度(前提是同時收到信號，但是實際上這個發(fā)生速度可能在nm級別，憑感受很難感覺到誰先)。當最后都執(zhí)行完畢后filesSizes channel會被上面的攜程函數(shù)close()，當close之后，在讀取完剩余數(shù)據(jù)后，fileSizes會返回給ok nil。就可以跳出循環(huán)。
看到這里可能會覺得有點繞，所以要盡可能的多理解一下，當然我們可以讓這個du程序更快?？梢宰⒁獾轿覀儾]有在walkdir里面開啟goroutines進行并發(fā)處理。下面我將嘗試開啟goroutine處理它們，并且用channel給他們加個鎖控制一下goroutine的數(shù)量，在此之前我們先來看看現(xiàn)在完成了的代碼：
package main
import (
"fmt"
"io/ioutil"
"os"
"path/filepath"
"flag"
"time"
)
// 入?yún)⑹且粋€文件目錄，一個INT64的只接收的單向channel
func walkDir(dir string, fileSizes chan<- int64) {
for _, entry := range dirEntries(dir) {
if entry.IsDir() {
subdir := filepath.Join(dir, entry.Name())
walkDir(subdir, fileSizes)
} else {
fileSizes <- entry.Size()
}
}
}
func dirEntries(dir string) []os.FileInfo {
entries, err := ioutil.ReadDir(dir)
if err != nil {
fmt.Fprintf(os.Stderr, "du: %v\n", err)
return nil
}
return entries
}
func main() {
t1 := time.Now()
root := ""
verbose := false
tick := make(<-chan time.Time)
var nfiles, nbytes int64
flag.StringVar(&root, "p", ".", "input dir.")
flag.BoolVar(&verbose, "v", false, "add verbose if you want")
flag.Parse()
if verbose {
tick = time.Tick(500 * time.Millisecond)
}
fileSizes := make(chan int64)
// 起一個goroutine去walk目錄
go func() {
walkDir(root, fileSizes)
// Walk完畢之后要關(guān)閉該channel下面使用range讀取數(shù)據(jù)的時候才會有盡頭
close(fileSizes)
}()
loop:
for {
select {
case size, ok := <-fileSizes:
if !ok {
break loop
}
nfiles++
nbytes += size
case <-tick:
fmt.Printf("%d files %.1f GB\n", nfiles, float64(nbytes)/1e9)
}
}
fmt.Printf("%d files %.1f GB\n", nfiles, float64(nbytes)/1e9)
fmt.Println(time.Since(t1))
}
觀察上面代碼可以看出我們并不能直接在這個代碼的基礎上直接給walkDir加上goroutine，這樣會導致channel直接被關(guān)閉，然后啥也沒跑就結(jié)束了。
我們需要讓主goroutine等待其他goroutine都完成之后再結(jié)束，所以主goroutine需要在這里阻塞住，等到得到可以結(jié)束的信號之后再結(jié)束。
我們可以使用sync.WaitGroup 來對仍舊活躍的walkDir調(diào)用進行計數(shù)。等到數(shù)量為0的時候就算我們可以結(jié)束了。
sync.WaitGroup提供了三個方法：
Add：添加或減少goroutine的數(shù)量。
Done：相當于Add(-1)。
Wait：阻塞住等待WaitGroup數(shù)量變成0.
明白這個道理之后我們改寫了一下代碼，讓它使用sync.WaitGroup來支持同步，最后當所有g(shù)oroutine都結(jié)束之后，關(guān)閉channel完成任務。
package main
import (
"fmt"
"io/ioutil"
"os"
"path/filepath"
"flag"
"time"
"sync"
)
// 入?yún)⑹且粋€文件目錄，一個INT64的只接收的單向channel
func walkDir(dir string, fileSizes chan<- int64, n *sync.WaitGroup) {
defer n.Done()
for _, entry := range dirEntries(dir) {
if entry.IsDir() {
n.Add(1)
subdir := filepath.Join(dir, entry.Name())
go walkDir(subdir, fileSizes, n)
} else {
fileSizes <- entry.Size()
}
}
}
func dirEntries(dir string) []os.FileInfo {
entries, err := ioutil.ReadDir(dir)
if err != nil {
fmt.Fprintf(os.Stderr, "du: %v\n", err)
return nil
}
return entries
}
func main() {
t1 := time.Now()
root := ""
verbose := false
tick := make(<-chan time.Time)
fileSizes := make(chan int64)
var n sync.WaitGroup
var nfiles, nbytes int64
flag.StringVar(&root, "p", ".", "input dir.")
flag.BoolVar(&verbose, "v", false, "add verbose if you want")
flag.Parse()
if verbose {
tick = time.Tick(500 * time.Millisecond)
}
n.Add(1)
go walkDir(root, fileSizes, &n)
go func() {
n.Wait()
close(fileSizes)
}()
loop:
for {
select {
case size, ok := <-fileSizes:
if !ok {
break loop
}
nfiles++
nbytes += size
case <-tick:
fmt.Printf("%d files %.1f GB\n", nfiles, float64(nbytes)/1e9)
}
}
fmt.Printf("%d files %.1f GB\n", nfiles, float64(nbytes)/1e9)
fmt.Println(time.Since(t1))
}
隨便跑跑。。感覺快得飛起，然而跑不了幾秒就會報錯，這個程序最大的問題就是我們完全沒有辦法之后它會自己打開多少個goroutine，感覺會爆炸。所以我們要限制這種夸張的寫法，使用channel來做一個并發(fā)協(xié)程池，把同時開啟的goroutine的數(shù)量控制一下。
最后上一下完整代碼，注意defer關(guān)鍵字，只接收函數(shù)，所以我會在釋放鎖的時候使用匿名函數(shù)：
package main
import (
"fmt"
"io/ioutil"
"os"
"path/filepath"
"flag"
"time"
"sync"
)
var token = make(chan int, 100)
// 入?yún)⑹且粋€文件目錄，一個INT64的只接收的單向channel
func walkDir(dir string, fileSizes chan<- int64, n *sync.WaitGroup) {
defer n.Done()
for _, entry := range dirEntries(dir) {
if entry.IsDir() {
n.Add(1)
subdir := filepath.Join(dir, entry.Name())
go walkDir(subdir, fileSizes, n)
} else {
fileSizes <- entry.Size()
}
}
}
func dirEntries(dir string) []os.FileInfo {
token <- 1
defer func() {<-token}()
entries, err := ioutil.ReadDir(dir)
if err != nil {
fmt.Fprintf(os.Stderr, "du: %v\n", err)
return nil
}
return entries
}
func main() {
var nfiles, nbytes int64
var n sync.WaitGroup
root := ""
verbose := false
t1 := time.Now()
fileSizes := make(chan int64)
tick := make(<-chan time.Time)
flag.StringVar(&root, "p", ".", "input dir.")
flag.BoolVar(&verbose, "v", false, "add verbose if you want")
flag.Parse()
if verbose {
tick = time.Tick(500 * time.Millisecond)
}
n.Add(1)
go walkDir(root, fileSizes, &n)
go func() {
n.Wait()
close(fileSizes)
}()
loop:
for {
select {
case size, ok := <-fileSizes:
if !ok {
break loop
}
nfiles++
nbytes += size
case <-tick:
fmt.Printf("%d files %.1f GB\n", nfiles, float64(nbytes)/1e9)
}
}
fmt.Printf("%d files %.1f GB\n", nfiles, float64(nbytes)/1e9)
fmt.Println(time.Since(t1))
}
Reference:
https://github.com/gopl-zh/gopl-zh.github.com The Go Programming Language
以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。
相關(guān)文章
golang RWMutex讀寫鎖實現(xiàn)讀共享寫獨占的功能示例
在 Go 里除了互斥鎖外,還有讀寫鎖 RWMutex,它主要用來實現(xiàn)讀共享,寫獨占的功能,今天我們也順便分析下讀寫鎖,加深對 Go 鎖的理解2023-09-09
Golang的循環(huán)語句和循環(huán)控制語句詳解
循環(huán)語句為了簡化程序中有規(guī)律的重復性操作，需要用到循環(huán)語句，和其他大多數(shù)編程語言一樣，GO的循環(huán)語句有for循環(huán)，不同的是沒有while循環(huán)，而循環(huán)控制語句可以改變循環(huán)語句的執(zhí)行過程，下面給大家介紹下go循環(huán)語句和循環(huán)控制語句的相關(guān)知識，一起看看吧2021-11-11
Go語言的并發(fā)機制是其強大和流行的一個關(guān)鍵特性之一,本文主要介紹了Go實現(xiàn)并發(fā)的示例代碼,具有一定的參考價值,感興趣的可以了解一下2023-11-11
這篇文章主要為大家介紹了Golang交叉編譯之跨平臺編譯使用詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-10-10
今天給大家推薦的工具是deepcopy，一個可以對指針、接口、切片、結(jié)構(gòu)體、Map都能進行深拷貝的工具，感興趣的小伙伴快跟隨小編一起學習學習2022-09-09
這篇文章主要為大家介紹了gRPC超時攔截器實現(xiàn)示例，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-06-06
Go語言創(chuàng)建、初始化數(shù)組的常見方式匯總
這篇文章主要介紹了Go語言創(chuàng)建、初始化數(shù)組的常見方式,實例匯總了Go語言操作數(shù)組的常見技巧,具有一定參考借鑒價值,需要的朋友可以參考下2015-02-02
在編程中，判斷兩個對象是否相等是一項常見的任務,同時判斷對象是否相等在很多情況下都非常重要，所以在接下來的內(nèi)容中，我們將詳細介紹在?Go?語言中如何判斷對象是否相等的方法和技巧，需要的可以參考一下2023-06-06
這篇文章主要和大家分享一下Go語言中的文件讀取操作，文中的示例代碼講解詳細，對我們學習Go語言有一定的幫助，需要的小伙伴可以參考一下2022-12-12
Go語言數(shù)據(jù)結(jié)構(gòu)之單鏈表的實例詳解
鏈表由一系列結(jié)點（鏈表中每一個元素稱為結(jié)點）組成，結(jié)點可以在運行時動態(tài)生成。本文將通過五個例題帶大家深入了解Go語言中單鏈表的用法，感興趣的可以了解一下2022-08-08