[go]go并发

同步协程

通过睡眠方法

// 通过睡眠方式等待

time.Sleep(time.Second)
<-time.NewTimer(time.Second).C
<-time.After(time.Second)

// 睡眠100毫秒

select {
case <- time.NewTimer(100 * time.Millisecond).C:    // 将在100毫秒可读，返回
}

for {
    time.Sleep(10*time.Second)
}

通过WaitGroup同步

// WaitGroup同步: 无需结果

var wg sync.WaitGroup
wg.Add(2)
wg.Done()
wg.Wait() //阻塞等待

通过有缓冲通道同步

// 缓冲为1 的同步

ch := make(chan int, 1)
go func() {
    println(1)
    ch <- 1
}()
<-ch
println(2)

// 缓冲为10,同步
ch := make(chan int, 10)
for i := 0; i < 10; i++ {
    go func() {
        println(1)
        ch <- i
    }()
}
for i := 0; i < cap(ch); i++ {
    <-ch
}

//有缓冲通道: 返回无序结果

func main() {
    ch := make(chan int, 10)
    //开了10个协程让去干活
    for i := 0; i < 10; i++ {
        go func(i int) {
            ch <- i
        }(i)
    }
    //获取10个协程的结果
    res := []int{}
    for i := 0; i < 10; i++ {
        res = append(res, <-ch)
    }
    //打印10个协程的结果(无序)
    fmt.Println(res)
}

参考

// 从100个url获取结果数据, 后集中返回结果(无序)

type User struct {
    name string
    age  int
}

func getUserInfo(resCh chan User, url string) {
    resCh <- User{
        name: url,
        age:  22,
    }
    println(url)
    time.Sleep(time.Second)
}

func main() {
    //获取100个用户的信息

    var users []User //存放结果数据

    urls := []string{
        "http://www.1.com",
        "http://www.2.com",
        "http://www.3.com",
        "http://www.4.com",
        "http://www.5.com",
    }

    resCh := make(chan User, len(urls))
    defer close(resCh)
    for i := 0; i < len(urls); i++ {
        go getUserInfo(resCh, urls[i])
    }

    for i := 0; i < len(urls); i++ {
        users = append(users, <-resCh)
    }

    //打印结果数据
    fmt.Println(users)
}

channel

//判断chan关闭

func main() {
    ch := make(chan int, 10)
    go func() {
        for i := 0; i < 10; i++ {
            ch <- i
        }
        close(ch)
    }()

    //for i := 0; i < 10; i++ {
    //  println(<-ch)
    //}

    //for {
    //  i, ok := <-ch
    //  if !ok {
    //      break
    //  }
    //  println(i)
    //}

    for v := range ch {
        println(v)
    }
}

//有缓冲通道: 控制任务并发数

func main() {
    ch := make(chan int, 3)
    for i := 0; i < 10; i++ {
        go func() {
            ch <- 1
            println("doing")
            time.Sleep(time.Second / 3)
            <-ch
        }()
    }
    time.Sleep(time.Second)
}

// 管道里有数据即输出: 实现优选返回速度快的

func main() {
    ch := make(chan int, 32)
    go func() {
        time.Sleep(time.Second)
        println("google")
        ch <- 1
    }()
    go func() {
        time.Sleep(time.Second/2)
        println("baidu")
        ch <- 1
    }()
    go func() {
        time.Sleep(time.Second/3)
        println("bing")
        ch <- 1
    }()

    println(<-ch)
}

select

//select: 实现任务超时

func main() {
    ch := make(chan int)
    select {
    case <-ch:
    case <-time.After(time.Second):
        println("timeout")
    }
}

//select分支随机执行: 实现生成随机数
func main() {
    ch := make(chan int)
    go func() {
        for{
            select {
            case ch<-0:
            case ch<-1:
            }
            time.Sleep(time.Second/3)
        }
    }()

    for v := range ch {
        println(v)
    }
}

// select的default分支: 实现goroutine的退出
func main() {
    ch := make(chan int)
    go func() {
        for {
            select {
            case <-ch://接收退出信号
            default: //正常执行
                println("hello")
            }
            time.Sleep(time.Second / 3)
        }
    }()
    time.Sleep(time.Second * 3)
    ch <- 1
}

// close chan发广播: 结束多个goroutine
func main() {
    ch := make(chan int)
    for i := 0; i < 10; i++ {
        go func(i int) {
            for {
                select {
                case <-ch: //接收退出信号
                default: //正常执行
                    println("hello", i)
                }
                time.Sleep(time.Second / 3)
            }
        }(i)
    }

    time.Sleep(time.Second * 3)
    close(ch)
}