Golang中的并发限制与超时控制

并发

package main
import (
    "fmt"
    "time"
)
func run(task_id, sleeptime int, ch chan string) {
    time.Sleep(time.Duration(sleeptime) * time.Second)
    ch <- fmt.Sprintf("task id %d , sleep %d second", task_id, sleeptime)
    return
}
func main() {
    input := []int{3, 2, 1}
    ch := make(chan string)
    startTime := time.Now()
    fmt.Println("Multirun start")
    for i, sleeptime := range input {
        go run(i, sleeptime, ch)
    }
    for range input {
        fmt.Println(<-ch)
    }
    endTime := time.Now()
    fmt.Printf("Multissh finished. Process time %s. Number of tasks is %d", endTime.Sub(startTime), len(input))
}

   函数 run() 接受输入的参数，sleep 若干秒。然后通过 go 关键字并发执行，通过 channel 返回结果。

   channel 顾名思义，他就是 goroutine 之间通信的“管道"。管道中的数据流通，实际上是 goroutine 之间的一种内存共享。我们通过他可以在 goroutine 之间交互数据。

   ch <- xxx // 向 channel 写入数据

   <- ch // 从 channel 中读取数据

   channel 分为无缓冲(unbuffered)和缓冲(buffered)两种。例如刚才我们通过如下方式创建了一个无缓冲的 channel。

   ch := make(chan string)

   channel 的缓冲，我们一会再说，先看看刚才看看执行的结果。

   

   三个 goroutine `分别 sleep 了 3，2，1秒。但总耗时只有 3 秒。所以并发生效了，go 的并发就是这么简单。

按序返回

   刚才的示例中，我执行任务的顺序是 0，1，2。但是从 channel 中返回的顺序却是 2，1，0。这很好理解，因为 task 2 执行的最快嘛，所以先返回了进入了 channel，task 1 次之，task 0 最慢。

   如果我们希望按照任务执行的顺序依次返回数据呢？可以通过一个 channel 数组（好吧，应该叫切片）来做，比如这样

package main
import (
    "fmt"
    "time"
)
func run(task_id, sleeptime int, ch chan string) {
    time.Sleep(time.Duration(sleeptime) * time.Second)
    ch <- fmt.Sprintf("task id %d , sleep %d second", task_id, sleeptime)
    return
}
func main() {
    i