声明

转载请注明本文地址,感谢 :)

了解进程、线程、协程

本文不详细解释这三个名词的意思,下面有一篇文章,不懂的同学可以参考看看。

Goroutine的使用

  • Goroutine 奉行通过通信来共享内存,而不是共享内存来通信
  • 使用goroutine很简单,只需要用到一个关键字go,我们用一段代码来示例一下如何使用go关键字
1
2
3
4
5
6
7
8
9
10
11
12
13
package main
import (
"fmt"
)
func main() {
go Goroutine()
}
func Goroutine() {
fmt.Println("Goroutine")
}

没有输出?

  • 执行了上面的代码后,你会发现,什么都没有输出,那么是什么问题呢?
  • 因为我们当前的程序,只是一个单线程的程序,main函数只要执行完毕后,就不会再管其他线程在做什么事情了,程序自动退出。 然后我们想到了一个办法,加一个sleep函数,让main函数等待Goroutine函数执行完毕后再退出。

  • 更改后的代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main
import (
"fmt"
"time"
)
func main() {
go Goroutine()
time.Sleep(3 * time.Second)
}
func Goroutine() {
fmt.Println("Goroutine")
}
  • 不出所料,程序成功打印出了“Goroutine”字符串。

引入Channel

  • 通过上面的实验,我们成功地用Goroutine,并打印出了一句话。现在问题来了,这个并不是我们想要的。为什么?如果我的Goroutine函数里的代码需要执行10s、20s甚至更多的时候,怎么办?难道还是继续Sleep更多的秒数吗?
  • 我们需要的是,当Goroutine函数执行完毕的时候,自动通知main函数。所以这里我们就引出了channel

创建方式

  • channel使用make创建

    • chann := make(chan bool)
  • 往channel中传入数据

    • chann <- true
  • 输出channel中的数据

    • <- chann
  • 接着我们改进上面使用Sleep方式的代码,换成使用channel的版本

  • 代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main
import (
"fmt"
)
func main() {
chann := make(chan bool)
go func() {
fmt.Println("Goroutine")
chann <- true
}()
<- chann
}
  • 如果运行以上的代码片段后,你成功输出了Goroutine,那么说明我们的写法是没错的。现在我们来理解一下这段代码的意思,我们看看匿名函数外面的<-chann,这实际上是起到了阻塞的作用,当匿名函数里面的业务没有执行完并讲true传入channel中的时候,这个程序是不会退出的,匿名函数外面会一直在等待。当匿名函数里面执行到了chann <- true,也就是将true传入了channel的时候,就不会继续阻塞,这时候程序就会结束。这就是channel的作用。

使用for range迭代输出Channel

  • 需要注意的是,当你在对channel 迭代的时候,必须在某个位置明确的关闭这个channel,不然程序就会死锁。我们用一个代码段来示例一下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main
import (
"fmt"
)
func main() {
chann := make(chan bool)
go func() {
fmt.Println("Goroutine")
chann <- true
close(chann) //关闭channel
}()
for v := range chann {
fmt.Println(v)
}
}

Channel 的定义类型

  • Channel 类型的定义格式:
    • ChannelType = ("chan" | "chan" "<-" | "<-" "chan")
  • Channel包含了三种类型的定义,可选的<-代表的是Channel的方向。没有指定方向的话,Channel就是双向的,既可以接受数据,也可以发送数据。
    • chan T //可以接收也可以发送
    • chan <- bool //可以发送bool类型的数据
    • <- chan bool //可以接收int类型的数据

无缓冲Channel与缓冲Channel

无缓冲Channel

  • 定义方式 chann := make(chan int)
  • 所谓无缓冲Channel就是在通道中只能传入1个值,若是传入的值一直没有被取走,那么就会一直阻塞着,直到被取走。可以说是同步阻塞的
  • 需要注意的是,无缓冲Channel一定是先取后传。当代码中出现了取的操作时,发现Channel里面并没有值,那么就会发生阻塞,当Channel里有值了,才会停止阻塞。

缓冲Channel

  • 定义方式 chann := make(chan int,100)
  • 有缓冲Channel,比如缓冲值是100,那么除非传入的值已经达到了100了,否则这个Channel中,还是可以不断地传值进去。当Channel满了,就会发生阻塞,等值被取走后,才可以继续传值。

如何判断一组任务是否完成

使用缓冲Channel

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package main
import (
"fmt"
"runtime"
)
func main() {
runtime.GOMAXPROCS(runtime.NumCPU()) // 设置线程数为当前计算机的CPU数
chann := make(chan bool, 10)
for i := 0; i < 10; i++ {
go Go(chann, i)
}
for i := 0; i < 10; i++ {
<-chann
}
}
func Go(chann chan bool, index int) {
a := 1
for i := 0; i < 100000000; i++ {
a += 1
}
fmt.Println(index, a)
chann <- true
}

使用sync包

  • 通过设置一个任务组,大小为10。每完成一个任务就记录一次wg.Done(),当10个任务都完成的时候,程序自动退出。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package main
import (
"fmt"
"runtime"
"sync"
)
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
wg :=sync.WaitGroup{}
wg.Add(10)
for i := 0; i < 10; i++ {
go Go(&wg, i)
}
wg.Wait()
}
func Go(wg *sync.WaitGroup, index int) {
a := 1
for i := 0; i < 100000000; i++ {
a += 1
}
fmt.Println(index, a)
wg.Done()
}

Select

select 用于多个channel监听并收发消息,当任何一个case满足条件则会执行,若没有可执行的case,就会执行default,如果没有default,程序就会阻塞。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package main
import (
"fmt"
"time"
)
func main() {
chann := make(chan int)
go enqueue(chann)
for {
select {
case v, ok := <-chann:
if ok {
fmt.Println(v)
} else {
fmt.Println("close")
return
}
default:
fmt.Println("waiting")
}
}
}
func enqueue(chann chan int) {
time.Sleep(3 * time.Second)
chann <- 1
close(chann)
}

参考