设为首页 加入收藏

TOP

goroutine,channel(一)
2019-09-04 00:55:45 】 浏览:36
Tags:goroutine channel

Go语言中有个概念叫做goroutine, 这类似我们熟知的线程,但是更轻。
以下的程序,我们串行地去执行两次loop函数:

package main

import "fmt"

func main() {
    loop()
    loop()
}

func loop() {
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", i)
    }
}

毫无疑问,输出会是这样的:

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 

下面我们把一个loop放在一个goroutine里跑,我们可以使用关键字go来定义并启动一个goroutine,多次运行:

0 1 2 3 4 5 6 7 8 9 
//或有可能是下面这样
0 1 2 3 4 5 6 7 8 9 0 1 2 
//亦或是下面这样
0 1 2 3 4 5 6 7 8 9 0 

我们反复运行上面的代码会发现结果会类似于上面这样,但是就是无法完整输出两遍0~9,明明我们主线跑了一趟,也开了一个goroutine来跑一趟啊。

原来,在goroutine还没来得及跑loop的时候,主函数已经退出了,正所谓"皮(主线程)之不存,毛(子线程)将焉附"。

main函数退出地太快了,我们要想办法阻止它过早地退出,一个办法是让main等待一下:

package main

import (
    "fmt"
    "time"
)

func main() {
    go loop() //启动一个goroutine
    loop()
    time.Sleep(time.Second) //停顿一秒
}

func loop() {
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", i)
    }
}

这次确实输出了两趟,目的达到了。
可是采用等待的办法并不好,如果goroutine在结束的时候,告诉下主线说“Hey, 我要跑完了!”就好了, 即所谓阻塞主线的办法,回忆下我们Python里面等待所有线程执行完毕的写法:

for thread in threads:
    thread.join()

是的,我们也需要一个类似join的东西来阻塞住主线。那就是信道

信道

信道是什么?简单说,是goroutine之间互相通讯的东西。类似我们Unix上的管道(可以在进程间传递消息), 用来goroutine之间发消息和接收消息。其实,就是在做goroutine之间的内存共享。
使用make来建立一个信道:

var channel chan int = make(chan int)

那如何向信道存消息和取消息呢? 一个例子:

package main

import "fmt"

func main() {
    var messages = make(chan string)
    go func(message string) {
        messages <- message //存消息
    }("Ping!")

    fmt.Println(<-messages) //取消息
}

默认的,信道的存消息和取消息都是阻塞的 (叫做无缓冲的信道,不过缓冲这个概念稍后了解,先说阻塞的问题)。

也就是说, 无缓冲的信道在取消息和存消息的时候都会挂起当前的goroutine,除非另一端已经准备好。
比如以下的main函数和foo函数:

package main

var ch = make(chan int)

func foo() {
    ch <- 0 //向ch中加数据,如果没有其他goroutine来取走这个数据,那么挂起foo, 直到main函数把0这个数据拿走
}
func main() {
    go foo()
    <-ch //从ch取数据,如果ch中还没放数据,那就挂起main线,直到foo函数中放数据为止
}

那既然信道可以阻塞当前的goroutine, 那么回到上一部分「goroutine」所遇到的问题「如何让goroutine告诉主线我执行完毕了」 的问题来, 使用一个信道来告诉主线即可:

package main

import "fmt"

var ch = make(chan int)

func loop() {
    for i := 0; i < 10; i++ {
        fmt.Printf("%d ", i)
    }
    ch <- 0 //执行完毕了,发个消息
}

func main() {

    go loop()
    <- ch //main在此阻塞住,直到线程跑完, 取到消息.
}

如果不用信道来阻塞主线的话,主线就会过早跑完,loop线都没有机会执行

其实,无缓冲的信道永远不会存储数据,只负责数据的流通,为什么这么讲呢?

  • 从无缓冲信道取数据,必须要有数据流进来才可以,否则当前线阻塞
  • 数据流入无缓冲信道, 如果没有其他goroutine来拿走这个数据,那么当前线阻塞

所以,你可以测试下,无论如何,我们测试到的无缓冲信道的大小都是0 (len(channel))
如果信道正有数据在流动,我们还要加入数据,或者信道干涩,我们一直向无数据流入的空信道取数据呢? 就会引起死锁
死锁一个死锁的例子:

package main

func main() {
    ch := make(chan int)

    <-ch //阻塞main goroutine,信道ch被锁
}

执行这个程序你会看到Go报这样的错误:

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
    /Users/XXX/Go/src/main.go:6 +0x4d

Process finished with exit code 2

何谓死锁? 操作系统有讲过的,所有的线程或进程都在等待资源的释放。如上的程序中, 只有一个goroutine, 所以当你向里面加数据或者存数据的话,都会锁死信道, 并且阻塞当前 goroutine, 也就是所有的goroutine(其实就main线一个)都在等待信道的开放(没人拿走数据信道是不会开放的),也就是死锁咯。
我发现死锁是一个很有意思的话题,这里有几个死锁的例子:
1.只在单一的goroutine里操作无缓冲信道,一定死锁。比如你只在main函数里操作信道:

package main

import "fmt"

func main() {
    ch := make(chan int)

    ch <- 1 //1流入信道,堵塞当前线, 没人取走数据信道不会打开
    fmt.Println("This line code won`t run") //在此行执行之前Go就会报死锁
}

2.如下也是一个死锁的例子:

package main

import "fmt"

var ch1 = make(chan int)
var ch2 = make(chan int)

func say(s string) {
    fmt.Println(s)
    ch1 <- <- ch2 //ch1等待ch2流出的数据
}

func main() {
    go say("hello")
    <-ch1 //堵塞主线
}

其中主线等ch1中的数据流出,ch1等ch2的数据流
goroutine,channel(一) https://www.cppentry.com/bencandy.php?fid=78&id=249901

首页 上一页 1 2 3 下一页 尾页 1/3/3
】【打印繁体】【投稿】【收藏】 【推荐】【举报】【评论】 【关闭】 【返回顶部
上一篇Go 面试每天一篇(第 2 天) 下一篇(转)go新建文件权限与设置不符