go語言天生支援高併發，同時訪問幾千幾萬網頁不是問題。例如在寫網路爬蟲時，我們從根頁面找出其他的頁面，然後其他的頁面又找出其他的頁面，如此反覆。雖然go可以支援同時訪問那麼多頁面，但是作業系統卻不支援同時開啟那麼多頁面，因為每次訪問頁面都是一次socket通訊。每次socket通訊就會佔用檔案描述符fd，作業系統同時支援開啟的fd是有限制的。所以有必要做併發控制。

下面模擬爬蟲的實驗。有一個函式每次隨機產生0-30個int型陣列。對陣列遍歷時又根據那個函式產生隨機陣列。我們先看看不做併發控制的程式碼：

package main 

import (
    "fmt"
    "time"
    "math/rand"
    "sync/atomic"
)

var Sum int32 = 0      //當前開啟fd的總量

func produceInt() []int {
    defer func()  {
        atomic.AddInt32(&Sum, -1)
    }()
    
    atomic.AddInt32(&Sum, 1)
    rnd := rand.Intn(30)            //這次產生的int的數量
    var list []int
    for i := 0; i < rnd; i++  {
        list = append(list, rand.Intn(100))
    }
    time.Sleep(time.Millisecond * 100)
    return list
}

func main()  {
    workList := make(chan []int)

    go func()  {
        workList <- []int{1}
    }()

    go func()  {
        for {
            fmt.Println("\nsum is ", Sum)      //列印當前fd的數量
            time.Sleep(time.Second)
        }
    }()

    for list := range workList  {     //list仍然是個[]int
        for range list  {
            go func()  {
                workList <- produceInt()
            }()
        }
    }
} 
 

運行當前的程式碼，發現fd是一直不停的在增加的。我們開始想辦法控制併發。
最簡單的方法就是利用chan來實現：

package main 

import (
    "fmt"
    "time"
    "math/rand"
    "sync/atomic"
)

var Sum int32 = 0      //當前開啟fd的總量

var tokens = make(chan struct{}, 30)

func produceInt() []int {
    defer func()  {
        atomic.AddInt32(&Sum, -1)
    }()
    
    tokens <- struct{}{}            //用chan同步來控制
    atomic.AddInt32(&Sum, 1)    
    rnd := rand.Intn(30)            //這次產生的int的數量
    var list []int
    for i := 0; i < rnd; i++  {
        list = append(list, rand.Intn(100))
    }
    time.Sleep(time.Millisecond * 100)
    <- tokens
    return list
}

func main()  {
    workList := make(chan []int)

    go func()  {
        workList <- []int{1}
    }()

    go func()  {
        for {
            fmt.Println("\nsum is ", Sum)      //列印當前fd的數量
            time.Sleep(time.Second)
        }
    }()

    for list := range workList  {     //list仍然是個[]int
        for range list  {
            go func()  {
                workList <- produceInt()
            }()
        }
    }
} 
 

另外一種寫法就是，利用chan，每次只取陣列元素中的一個。然後開啟N個這樣的協程，程式碼如下：

package main 

import (
    "fmt"
    "time"
    "math/rand"
    "sync/atomic"
    "runtime"
)

var Sum int32 = 0      //當前開啟fd的總量

func produceInt() []int {
    defer func()  {
        atomic.AddInt32(&Sum, -1)
    }()
    
    atomic.AddInt32(&Sum, 1)
    rnd := rand.Intn(30)            //這次產生的int的數量
    var list []int
    for i := 0; i < rnd; i++  {
        list = append(list, rand.Intn(100))
    }
    time.Sleep(time.Millisecond * 100)
    return list
}

func main()  {
    workList := make(chan []int)
    unseen := make(chan int)

    go func()  {
        for {
            fmt.Printf("sum is %d", Sum)      //列印當前fd的數量
            fmt.Printf("num of co is %d\n", runtime.NumGoroutine())      //當前協程的數量
            time.Sleep(time.Second)
        }
    }()

    go func()  {
        workList <- []int{1}
    }()

    for i := 0; i < 20; i++  {
        go func()  {
            for range unseen  {
                k := produceInt()
                go func()  {
                    workList <- k
                }()
            }
        }()
    }

    for list := range workList  {
        for _, l := range list  {
            unseen <- l
        }
    }
} 
 

 注意，雖然併發得到了控制，但是協程的數量是一直在增加的，執行第三個程式碼就可以看。