一、并发 VS 并行

1: 多线程程序在一个核的CPU上运行

 

2: 多线程程序在多个核的CPU上运行 

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

线程：用户态，轻量级线程，栈MB级别。

协程：内核态，线程内跑多个协程，栈KB级别。

1.1 Goroutine

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)
}

快速打印：hello goroutine : 0-4

 1.2 CSP (Communicating Sequential Processes)

【提倡通过通信共享内存而不是通过共享内存实现通信 】

1.3 Channel

语法：make(chan 元素类型，[缓冲大小])

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

A 子协程发送 0～9 数字

B 子协程计算输入数字的平方

主协程输出最后的平方数

 

 

 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: 0-4

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

func ManyGoWait()  {
	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()
}