1. 语言进阶

1.1 并发 VS 并行

多线程程序在一个核的cpu上运行

多线程程序在多个核的cpu上运行

Go 可以充分发挥多核优势，高效运行

1.2 Coroutine

协程： 用户态，轻量级线程，栈 KB 级别。 线程： 内核态，线程跑多个协程，栈 MB 级别

快速打印 hello goroutinue 0-4

package main

import (
	"fmt"
	"time"
)

func hello(i int) {
	println("hello goroutine : " + fmt.Sprint(i))
}

func HelloGoRoutine() {
	for i := 0; i < 5; i++ {
		go func(j int) {
			hello(j)
		}(i)
	}
	time.Sleep(time.Second)
}

func main() {
	HelloGoRoutine()
}

go 语言可以使用 go 关键字来快速实现协程

可以看到输出并不是有序的，说明协程是并行的

1.2 CSP（Communicating Sequential Processes）

go 语言提倡通过 通过共享内存 而不是通过共享内存而实现通信

1.3 Channel

make(chan 元素类型, [缓冲大小])

无缓冲通道 make(chan int)
有缓冲通道 make(chan int, 2)

A 协程发送 0~9 个数字
B 协程计算输入数字的平方
主协程输出最后的平方数

func CalSquare() {
	src := make(chan int)
	dest := make(chan int, 3)
	go func() {
		defer close(src)
		for i := 0; i < 10; i++ {
			src <- i
		}
	}()
	go func() {
		defer close(dest)
		for i := range src {
			dest <- i * i
		}
	}()
	for i := range dest {
		println(i)
	}
}

1.4 并发安全 Lock

对变量执行 2000 次 +1 操作，5 个协程并发执行

var (
	x    int64
	lock sync.Mutex
)

func addWithLock() {
	for i := 0; i < 2000; i++ {
		lock.Lock()
		x += 1
		lock.Unlock()
	}
}

func addWithoutLock() {
	for i := 0; i < 2000; i++ {
		x += 1
	}
}

func Add() {
	x = 0
	for i := 0; i < 5; i++ {
		go addWithoutLock()
	}
	time.Sleep(time.Second)
	println("WithoutLock:", x)
	x = 0
	for i := 0; i < 5; i++ {
		go addWithLock()
	}
	time.Sleep(time.Second)
	println("WithLock:", x)
}

1.5 WaitGroup

计数器： 开启协程+1，执行结束-1，主协程阻塞直到计数器为0

修改之前的打印 hello goroutine 程序

func HelloGoRoutine() {
	var wg sync.WaitGroup
	wg.Add(5)
	for i := 0; i < 5; i++ {
		go func(j int) {
			defer wg.Done()
			hello(j)
		}(i)
	}
	wg.Wait()
	//time.Sleep(time.Second)
}