Goroutine
在Go语言中，可以通过go func()来创建一个Goroutine，但是该Goroutine并不会立刻执行
goroutine-without-wait.go
package main
import (
"fmt"
)
func main() {
go func() {
fmt.Printf("world!\n")
}() //创建一个Goroutine
fmt.Printf("Hello ")
}
输出结果为
Hello
main()函数执行完毕后，会立刻退出，并不会等待后台Goroutine的执行，为了使Goroutine能够顺利执行，可以在main()函数中调用time.Sleep()，使得Goroutine能够获取CPU时间片并执行
wait-for-goroutine.go
package main
import (
"fmt"
"time"
)
func main() {
go func() {
fmt.Printf("world!\n")
}()
fmt.Printf("Hello ")
time.Sleep(1 * time.Second) //暂停1s，等待Goroutine执行完毕
}
输出结果为
Hello world!
在main()函数中通过调用time.Sleep()将当前程序进入等待状态，这样Goroutine就可以顺利执行，这样的弊端就是可能等待的时间过长或过短，可以使用Channel等待Goroutine的执行
wait-goroutine-by-channel.go
package main
import (
"fmt"
)
func main() {
var c = make(chan struct{})
go func() {
fmt.Printf("Hello ")
c <- struct{}{} //发送一个消息到Channel 或者 <-c
}()
<-c //从Channel接受消息 或者 c <- struct{}{}
fmt.Printf("world!\n")
}
在main()函数中，接收Channel的操作会一直阻塞，直到从Channel中接收到消息才会继续向下执行
如果在main()函数中发送一条消息Channel，那么在其它的Groutine从Channel中接收到该消息之前，程序也会阻塞
GO语言中还提供了一种方式等待Goroutine的执行
wait-goroutine-by-waitGroup.go
package main
import (
"fmt"
"sync"
)
func main() {
var n sync.WaitGroup
n.Add(1) //加1
go func() {
fmt.Printf("Hello ")
n.Done()
//相当于减1，一种常见的用法是在func()内部语句开头使用 defer n.Done()
}()
n.Wait()//值为0才会向下执行
fmt.Printf("world!\n")
}
在使用sync.WaitGroup时需要注意n.Add(1)与n.Done()的执行次数需一致，这样可以避免死锁，在循环中一种常用的用法
wait-goroutine-by-waitGroup-forLoop.go
package main
import (
"fmt"
"sync"
)
func main() {
var n sync.WaitGroup
for i := 0; i < 10; i++ {
n.Add(1)
go func(i int) {
defer n.Done()
fmt.Printf("Task [%d] Work!\n", i)
}(i)
}
n.Wait()
fmt.Printf("All task has done!\n")
}
使用Buffer Channel也可以完成此类操作，仍需注意Channel缓冲区的数量要与创建Goroutine的数量一致
wait-goroutine-by-bufferChannel-forLoop.go
package main
import (
"fmt"
)
func main() {
var c = make(chan struct{}, 10)
for i := 0; i < 10; i++ {
go func(i int) {
fmt.Printf("Task [%d] word!\n", i)
c <- struct{}{}
}(i)
} //创建10个Goroutine
//等待所有的Goroutine执行完毕
for j := 0; j < 10; j++ {
<-c
} //可以更改J的值看看会发生什么
fmt.Printf("All task has done!\n")
}
Buffer Channel在缓冲区满时，发送操作会阻塞，在缓冲区为空时，接收操作会阻塞
并行循环
在处理一些矩阵问题时，可以采用矩阵分块的思想利用Goroutine加速实现任务
《Go程序设计语言》第八章有一个关于并行循环的习题，大致是画一幅1024 x 1024像素的图形，能否利用Goroutine对其进行加速？
在刚开始看到题目时，我以为是在调用img.set()时创建Goroutine对其进行加速，于是就有了下面这样的代码
var n sync.WaitGroup
img := image.NewRGBA(image.Rect(0, 0, width, height))
for py := 0; py < height; py++ {
y := float64(py)/height*(ymax-ymin) + ymin
for px := 0; px < width; px++ {
x := float64(px)/width*(xmax-xmin) + xmin
z := complex(x, y)
n.Add(1)
go func(px, py int, z color.Color) {
defer n.Done()
img.Set(px, py, z) //将颜色写入对应的位置
}(px, py, mandelbrot(z))
}
}
n.Wait() //等待所有Goroutine执行完毕
结果在实际运行时发现比不使用Goroutine还慢，在这段代码中总共创建了1024 x 1024个Goroutine，系统需要花费很长时间用于Goroutine的调度
在看完别人的解答后发现思路是将一个1024 x 1024的矩阵分为y个 (1024 / y) x 1024的矩阵，每个Goroutine负责执行一部分
for i := 0; i < 4; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
//每个Goroutine根据i的值负责一部分区域的颜色填充
for py := i * 256; py < (i+1)*256; py++ {
y := float64(py)/height*(ymax-ymin) + ymin
for px := 0; px < width; px++ {
x := float64(px)/width*(xmax-xmin) + xmin
z := complex(x, y)
img.Set(px, py, mandelbrot(z)) //颜色填充
}
}
}(i)
}
wg.Wait()
超时处理
假设有一个Master节点负责维护任务的状态，其它Worker节点负责执行任务，很多时候对于每个任务都会设置超时处理，如果某个任务没有在规定时间内完成，将任务重新分配给Worker执行
每当Master节点分配一个任务时，可以创建一个Goroutine负责监控该任务的执行状态
下面给出一段Master的伪码
master-with-timeout.go
const (
UNASSIGN = 0 //未分配
INPROCESS = 1 //正在执行
COMPLETED = 2 //执行完毕
)
func assignWorkRPC() {
for index := 0; index < len(task); index++ {
//如果该任务没有被分配，分配该任务
if task[index] == UNASSIGN {
task[index] = INPROCESS //任务状态未正在执行
go func(index int) {
//休眠一段时间后检查任务状态
time.Sleep(10 * time.Second)
if task[index] != COMPLETED { //任务未在规定时间内完成
task[index] = UNASSIGN //任务状态转换为未分配
}
}(index)
}
}
}
func workCompleteRpc() {
task[args.TaskId] = COMPLETED //如果Worker执行完任务改变任务状态
}
在处理超时问题时，使用Goroutine与time.sleep()是一种很常见的方法，首先让Goroutine休眠一段时间，接着检查任务的状态，如果任务在规定时间内完成就不做任何改动，如果任务没有在规定时间内完成，需要改变任务的状态