并发：逻辑上具备同时处理多个任务的能力(单核，上下文切换)
并行：物理上同一时刻执行多个并发任务(多核，互不影响)
package main
import (
"fmt"
"time"
)
var c int
func counter() int {
c++
return c
}
func main() {
a := 100
go func(x, y int) {
time.Sleep(time.Second) //goroutine在main逻辑之后执行
fmt.Println("go:", x, y)
}(a, counter()) //立即计算并赋值
a += 100
fmt.Println("main", a, counter())
time.Sleep(time.Second * 3) //等goroutine结束
}
进程退出并不会等并发任务执行结束，可用channel阻塞，然后发出退出信号
package main
import (
"fmt"
"time"
)
func main() {
exit := make(chan struct{})
go func() {
time.Sleep(time.Second)
fmt.Println("goroutine done")
close(exit) //关闭通道，发出信号
}()
fmt.Println("main start...")
<-exit //通道关闭，立即解除阻塞
fmt.Println("main end...")
}
等待多个任务结束，使用sync.WaitGroup，通过设定计数器，让每个goroutine在退出前递减，直至归零时解除阻塞
package main
import (
"fmt"
"sync"
"time"
)
func main() {
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1) //累加计数
go func(id int) {
defer wg.Done() //递归计数
time.Sleep(time.Second)
fmt.Println("goroutine", id)
}(i)
}
fmt.Println("start")
wg.Wait() //阻塞，直至计数归零
fmt.Println("stop")
}
channel限制并发数
package main
import (
"fmt"
"sync"
"time"
)
var wg = sync.WaitGroup{}
func main() {
ch := make(chan int, 2)
for i := 0; i < 100; i++ {
go run(ch, i)
}
wg.Wait()
}
func run(ch chan int, i int) {
wg.Add(1)
defer wg.Done()
ch <- i
fmt.Println(i)
time.Sleep(1*time.Second)
<-ch
}
GOMAXPROCS
与逻辑核数相等
package main
import (
"fmt"
"math"
"runtime"
"sync"
)
func count() {
x := 0
for i := 0; i < math.MaxUint32; i++ {
x += i
}
fmt.Println(x)
}
func test(n int) {
for i := 0; i < n; i++ {
count()
}
}
func test2(n int) {
var wg sync.WaitGroup
wg.Add(n)
for i := 0; i < n; i++ {
go func() {
count()
wg.Done()
}()
}
wg.Wait()
}
func main() {
n := runtime.GOMAXPROCS(0)
test2(n)
}
可在多处使用Wait阻塞，它们都能收到通知
package main
import (
"fmt"
"sync"
"time"
)
func main() {
var wg sync.WaitGroup
wg.Add(1)
go func() {
wg.Wait()
fmt.Println("wait exit")
}()
go func() {
time.Sleep(time.Second)
fmt.Println("done")
wg.Done()
}()
wg.Wait()
fmt.Println("main exit")
}
多个goroutine进行通信
方式一：全局变量(加锁)
package main
import (
"fmt"
"sync"
"time"
)
var (
m = make(map[int]int)
lock sync.Mutex
)
type task struct {
n int
}
func calc(t *task) {
sum := 1
for i := 1; i <= t.n; i++ {
sum *= i
}
lock.Lock()
m[t.n] = sum
lock.Unlock()
}
func main() {
for i := 1; i < 10; i++ {
t := &task{n: i}
go calc(t)
}
time.Sleep(time.Second * 2)
lock.Lock()
for k, v := range m {
fmt.Printf("%d! is %v
", k, v)
}
lock.Unlock()
}
用到goroutine时编译加-race竞争检测
方式二：channel
channel概念
- 类似pipe
- 先进先出
- 线程安全，多个goroutine同时访问，不需要加锁
- channel是有类型的，一个整数的channel只能存放整数
channel申明
- var 变量名 chan 类型
- var test chan int
- var test chan map[string]string
channel关闭
方法一：v,ok := <-chan
package main
import (
"fmt"
)
func main() {
ch := make(chan int, 10)
for i := 0; i < 10; i++ {
ch <- i
}
close(ch)
for {
b, ok := <-ch
if ok == false {
break
}
fmt.Println(b)
}
}
方式二：
for v ：= range chan
channel读写
package main
import (
"fmt"
"time"
)
func write(ch chan int) {
for i := 0; i < 100; i++ {
ch <- i
}
}
func read(ch chan int) {
var a int
for {
a = <-ch
fmt.Println("read", a)
}
}
func main() {
intChan := make(chan int, 10)
go write(intChan)
go read(intChan)
time.Sleep(time.Second)
}
判断10000内的素数
package main
import (
"fmt"
)
func calc(taskChan chan int, resChan chan int, exitChan chan bool) {
for v := range taskChan {
flag := true
for i := 2; i < v; i++ {
if v%i == 0 {
flag = false
break
}
}
if flag {
resChan <- v
}
}
exitChan <- true
}
func main() {
taskChan := make(chan int, 1000)
resChan := make(chan int, 1000)
exitChan := make(chan bool, 8)
go func() {
for i := 1; i < 10000; i++ {
taskChan <- i
}
close(taskChan)
}()
for i := 0; i < 8; i++ {
go calc(taskChan, resChan, exitChan)
}
go func() {
for i := 0; i < 8; i++ {
<-exitChan
}
close(resChan)
}()
for v := range resChan {
fmt.Println(v)
}
}
定时器
package main
import (
"fmt"
"time"
)
func main() {
t := time.NewTicker(time.Second)
for v := range t.C {
fmt.Println("hello", v)
}
t.Stop()
}
超时控制
package main
import (
"fmt"
"time"
)
func main() {
select {
case <-time.After(time.Second):
fmt.Println("timeout")
}
}