go 并发满足方案

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
)

var num = 0
var max = 10000

var wg sync.WaitGroup
/*1、互斥锁满足并发需求：锁的速度非常快，理论上是高速缓存，
*内存总线读写但也应控制锁的范围，不能因为锁的内部过多消耗时间，
*而让其他协程挂起等待，从而降低了并发的效率*/
var mx sync.Mutex
//2、管道满足并发需求
var chf = make(chan string, 1)
//3、使用CAS（Compare-and-Swap） atomic原子递增 【仅适用于int32\64一个变量特定场景】满足并发需求
var nub int32 = 0
//4、等待组[穿行任务伪并发]
var wt sync.WaitGroup

var res1, res2, res3, res4 = num, num, nub, num

func main() {
	wg.Add(2)
	//线程不安全
	for i := 0; i < 2; i++ {
		go add0()
	}
	wg.Wait()
	fmt.Printf("num=%d\n", num)
	//线程安全 方案一
	wg.Add(2)
	for i := 0; i < 2; i++ {
		go add1()
	}
	wg.Wait()
	fmt.Printf("res1=%d\n", res1)
	//线程安全 方案二
	wg.Add(2)
	for i := 0; i < 2; i++ {
		go add2()
	}
	wg.Wait()
	close(chf)
	fmt.Printf("res2=%d\n", res2)
	//线程安全 方案三
	wg.Add(2)
	for i := 0; i < 2; i++ {
		go add3()
	}
	wg.Wait()
	fmt.Printf("res3=%d\n", res3)
	//线程安全 方案四
	wg.Add(2)
	for i := 0; i < 2; i++ {
		wt.Add(1)
		go add4()
		wt.Wait()
	}
	wg.Wait()
	fmt.Printf("res4=%d\n", res4)

}

func add0() {
	for i := 0; i < max; i++ {
		num++
	}
	wg.Done()
}

func add1() {
	for i := 0; i < max; i++ {
		mx.Lock()
		res1++
		mx.Unlock()
	}
	wg.Done()
}

func add2() {
	for i := 0; i < max; i++ {
		chf <- "wt"
		res2++
		<-chf
	}
	wg.Done()
}

func add3() {
	for i := 0; i < max; i++ {
		atomic.AddInt32(&res3, 1)
	}
	wg.Done()
}

func add4() {
	for i := 0; i < max; i++ {
		res4++
	}
	wt.Done()
	wg.Done()
}