在Go语言中，并发编程主要通过goroutine和channel来实现。
goroutine
goroutine 是 Go 语言中并发的核心。它是一种轻量级的线程，
package main
import (
"fmt"
"time"
)
func hello() {
fmt.Println("Hello world goroutine")
}
func main() {
go hello() // 启动一个goroutine
fmt.Println("main function done")
time.Sleep(1 * time.Second) // 等待goroutine执行完成
}channel
channel 是 goroutine 之间通信的一种方式。
package main
import (
"fmt"
"time"
)
func sum(a []int, c chan int) {
total := 0
for _, v := range a {
total += v
}
c <- total // 把sum结果发送到channel c
}
func main() {
a := []int{7, 2, 8, -9, 4, 0}
c := make(chan int) // 创建一个channel
go sum(a[:len(a)/2], c) // 计算a的前半部分的和
go sum(a[len(a)/2:], c) // 计算a的后半部分的和
x, y := <-c, <-c // 从channel接收计算结果
fmt.Println(x, y, x + y)
time.Sleep(1 * time.Second)
}select
select 语句用于处理多个通道的发送和接收操作。
package main
import (
"fmt"
"time"
)
func fibonacci(c, quit chan int) {
x, y := 0, 1
for {
select {
case c <- x:
x, y = y, x+y
case <-quit:
fmt.Println("quit")
return
}
}
}
func main() {
c := make(chan int)
quit := make(chan int)
go func() {
time.Sleep(1 * time.Second)
quit <- 0
}()
fibonacci(c, quit)
}并发和并行
并发 (concurrency) 是指同时处理多个任务，但在任意时刻只有一个任务在执行。
并行 (parallelism) 是指同时处理多个任务，且多个任务在同时执行。
package main
import (
"fmt"
"runtime"
"sync"
"time"
)
var wg sync.WaitGroup
func worker(id int, wg *sync.WaitGroup) {
defer wg.Done() // 在函数退出时执行，相当于计数器减一
fmt.Printf("Worker %d starting\n", id)
time.Sleep(2 * time.Second)
fmt.Printf("Worker %d done\n", id)
}
func main() {
runtime.GOMAXPROCS(1) // 设置为1核心，模拟并发
for i := 1; i <= 3; i++ {
wg.Add(1) // 将等待组计数器加一
go worker(i, &wg) // 创建新的goroutine执行worker函数
}
wg.Wait() // 等待所有goroutine完成
}以上代码展示了如何使用Go语言的并发特性来实现并发操作。通过创建goroutine，我们可以同时处理多个任务，而不需要额外的线