Go语言协程Goroutine高级用法（一）
什么协程
在Go语言中，协程就是一种轻量的线程，是并发编程的单元，由Go来管理，所以在GO层面的协程会更加的轻量、高效、开销更小，并且更容易实现并发编程。
轻量级线程
- Go语言中协程（线程）与传统系统层面的线程相比，实在是太轻量了，能小到2kb
- 由于协程的轻量特性，可以更高效地利用系统资源。相较于传统的线程，协程的创建和销毁的开销更小，使得程序更具有扩展性和性能优势。
Go自身管理
- 在 Go 中，这些工作由运行时系统自动完成。这样我们就可以更专注于业务逻辑，而不必过多关心底层线程管理的细节。
并发的基本单元
- 协程是并发编程的基本单元，可以同时执行多个协程，而它们之间的调度和切换由运行时系统负责。
- 在程序中更容易实现高效的并发，处理多个任务而无需显式地创建和管理线程。
- 使用协程，我们可以轻松地实现并发任务，例如同时处理多个网络请求、执行后台任务等。由于协程的轻量特性，可以创建数千甚至数百万个协程而不会造成系统负担。
使用通道通信
- 协程之间可以通过通道进行通信，这是一种在协程之间安全地传递数据和同步操作的机制。通道是一种强大的工具，用于协程之间的协作和数据传递。
协程的基本操作
创建协程
- 语法： `go 函数(函数列表)`
package main
import (
"fmt"
"time")
func Hello() {
fmt.Println("hello world")
}
func main() {
go Hello()
fmt.Println("hello main")
time.Sleep(10 * time.Second)
}
协程与主线程是并发执行的。
协程间通行
- 主要通过
channel来实现的
package main
import (
"fmt"
)
func sendMessage(ch chan string, msg string) {
ch <- msg
}
func main() {
messagechan := make(chan string)
go sendMessage(messagechan, "Hello World")
msg := <-messagechan
fmt.Println(msg)
}
协程间的同步
- 使用sync包来实现的
- waitgroup 是用来计数信号量的
package main
import (
"fmt"
"sync")
func worker(id int, wg *sync.WaitGroup) {
defer wg.Done()
fmt.Printf("worker %d starting\n", id)
fmt.Printf("worker %d done\n", id)
}
func main() {
var wg sync.WaitGroup
for i := 1; i <= 10; i++ {
wg.Add(1)
go worker(i, &wg)
}
wg.Wait()
fmt.Printf("all workers done\n")
}
waitgroup确保主线程等待所有协程完成
协程的错误处理
- 使用
select语句和通道可以实现协程的错误处理
package main
import (
"fmt"
"time")
func dosomething(ch chan string) {
time.Sleep(2 * time.Second)
ch <- "hello world"
}
func main() {
ch := make(chan string)
go dosomething(ch)
select {
case msg := <-ch:
fmt.Println(msg)
case <-time.After(1 * time.Second):
fmt.Println("timeout")
}
}
select语句允许在多个通道操作中选择一个可用的操作，可以用来处理协程的超时等情况。
协程的高级操作
协程池
- 协程池是一组预先创建的协程，用于执行并发任务，可以避免频繁创建和销毁协程的开销。
- 使用缓冲通道来实现协程池
package main
import (
"fmt"
"sync")
func worker(id int, jobs <-chan int, results chan<- int) {
for j := range jobs {
fmt.Println("worker", id, "started job", j)
results <- j * 2
}
}
func main() {
const numJobs = 5
const numWorkers = 3
jobs := make(chan int, numJobs)
results := make(chan int, numJobs)
var wg sync.WaitGroup
for i := 1; i <= numWorkers; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
worker(i, jobs, results)
}(i)
}
for j := 1; j <= 5; j++ {
jobs <- j
}
close(jobs)
go func() {
wg.Wait()
close(results)
}()
for result := range results {
fmt.Println("result", result)
}
}
三个协程形成了协程池，从任务通道
jobs中获取任务，处理后将结果发送到结果通道results
超时控制
package main
import (
"fmt"
"time")
func dosomething(ch chan string) {
time.Sleep(2 * time.Second)
ch <- "hello world"
}
func main() {
ch := make(chan string)
go dosomething(ch)
select {
case msg := <-ch:
fmt.Println(msg)
case <-time.After(1 * time.Second):
fmt.Println("timeout")
}
}
time.After创建一个计时器，如果在指定时间内没有从通道ch中接收到结果，就会触发超时。
协程的取消
- 使用
context包提供的上下文（Context）来实现协程的取消。
package main
import (
"context"
"fmt" "time")
func doSomething(ctx context.Context, ch chan string) {
select {
case <-ctx.Done():
ch <- "task completed successfully"
case <-time.After(1 * time.Second):
ch <- "task timed out"
}
}
func main() {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
ch := make(chan string)
go doSomething(ctx, ch)
time.Sleep(2 * time.Second)
cancel()
result := <-ch
fmt.Println(result)
}
通过调用
cancel函数取消协程的执行。