go 并发编程

1goroutine

1.1 统计当前goroutine数量

//控制并发数量
func GoroutineAnts() {
	//1.统计当前goroutine数量
	go func() {
		for {
			fmt.Println("goroutinenum：", runtime.NumGoroutine())
			time.Sleep(250 * time.Millisecond)
		}
	}()
	//2.初始化协程池 goroutine pool
	size := 1024
	pool, err := ants.NewPool(size)
	if err != nil {
		log.Fatalln(err)
	}
	//保证pool被关闭
	defer pool.Release()
	//3.利用pool，调度需要并发的大量goroutine
	for {
		//向pool中提交一个执行的goroutine
		err := pool.Submit(func() {
			V := make([]int, 1024)
			_ = V
			time.Sleep(time.Second * 100)
		})
		if err != nil {
			log.Fatalln(err)
		}
	}
}

1.2 控制并发数量

//控制并发数量
func GoroutineAnts() {
	//1.统计当前goroutine数量
	go func() {
		for {
			fmt.Println("goroutinenum：", runtime.NumGoroutine())
			time.Sleep(250 * time.Millisecond)
		}
	}()
	//2.初始化协程池 goroutine pool
	size := 1024
	pool, err := ants.NewPool(size)
	if err != nil {
		log.Fatalln(err)
	}
	//保证pool被关闭
	defer pool.Release()
	//3.利用pool，调度需要并发的大量goroutine
	for {
		//向pool中提交一个执行的goroutine
		err := pool.Submit(func() {
			V := make([]int, 1024)
			_ = V
			time.Sleep(time.Second * 100)
		})
		if err != nil {
			log.Fatalln(err)
		}
	}
}

1.3 多对多协程调度模式

1.4 GMP模型结构

所有G由P管理，一旦P与M绑定，就将G交由M执行，注意：P只能管理G，不能执行G

1.5 抢占调度和协作调度

//主动让出执行权
func GoroutineSched() {
	wg := sync.WaitGroup{}
	max := 100
	wg.Add(2)
	//设置为 1个P 在调度 G
	runtime.GOMAXPROCS(1) //单线程模式
	//输出奇数
	go func() {
		defer wg.Done()
		for i := 1; i <= max; i += 2 {
			fmt.Println(" ", i)
			//time.Sleep(time.Millisecond * 3)
			//主动让出
			runtime.Gosched()
		}
	}()
	//输出偶数
	go func() {
		defer wg.Done()
		for i := 2; i <= max; i += 2 {
			fmt.Println(" ", i)
			//time.Sleep(3 * time.Millisecond) //延长时间，使得处理机进行调度  单处理机运行一般10ms
			//主动让出
			runtime.Gosched()
		}
	}()
	wg.Wait()
}

1.6小节

• GMP
• G存在于P的本地队列或全局队列中
• M要与P绑定，P中的G才会执行
• M执行G中的系统调用时，会解绑M和P。P会找到新的M执行

2 综合应用

• channel

1.需要先关闭，然后再循环遍历取值

//空接口管道断言
dog1:=<-allChan
a:=dog1.(dog) //需要类型断言
a:=(<-allChan).(dog) //与上面等价

2.1

var intChan chan int
func ReadAndWrite() {
	intChan = make(chan int, 50)
	exitChan := make(chan bool, 1)
	go WriteData(intChan)
	go ReadData(intChan, exitChan)
	if <-exitChan {
		fmt.Println("end！")
	}
}
//封装两个方法
func WriteData(intChan chan int) {
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < 50; i++ {
		var tempInt int
		tempInt = rand.Intn(4) + 10
		fmt.Printf("写入数据为%v，第%v次写入\n", tempInt, i+1)
		intChan <- tempInt
	}
	close(intChan)
}
func ReadData(intChan chan int, exitChan chan bool) {
	var count int
	for {
		val, ok := <-intChan
		count++
		if !ok {
			break
		}
		fmt.Printf("读取到%v，是第%v次读取\n", val, count)
	}
	exitChan <- true //读取完毕
	close(exitChan)
}

2.2统计素数需求的传统实现与协程和管道的实现

• 通常方法检查素数

// 检查是否为素数 通常用法
func IsPrime(n int) {
	for i := 1; i <= n; i++ {
		var flag bool = true
		for j := 2; j < i; j++ {
			if i%j == 0 {
				flag = false
				continue
			}
		}
		if flag {
			fmt.Println(i, "为素数")
		}
	}
}

• 管道协程检查素数

// 检查是否为素数 管道协程
func initChan(n int) {
	for i := 1; i <= n; i++ {
		intChan <- i
	}
	close(intChan)
}
func isPrimeChannel(intChan chan int, primeChan chan int, exitChan chan bool) {
	var flag bool
	for {
		intchan, ok := <-intChan
		flag = true
		if !ok {
			break
		}
		for j := 2; j < intchan; j++ {
			if intchan%j == 0 {
				flag = false
				continue
			}
		}
		if flag {
			primeChan <- intchan
		}
	}
	exitChan <- true
}
func IsPrimeChannel() {
	var primeChan chan int = make(chan int, 100)
	var exitChan chan bool = make(chan bool, 8)
	go initChan(100)
	for i := 1; i <= 8; i++ {
		go isPrimeChannel(intChan, primeChan, exitChan)
	}
	go func() {
		for i := 0; i < 8; i++ {
			<-exitChan
		}
		close(primeChan)
		close(exitChan) //取完才能关闭，因为开启了八个协程，所以该管道会有八个值
	}()
	for {
		res, ok := <-primeChan
		if !ok {
			break
		}
		fmt.Println("素数有", res)
	}
}

2.3 只读只写

2.4 如果不close(管道)，怎么避免锁错误 使用 break label

break label 跳出循环不再执行for循环里的代码，即不再第二次执行for循环代码。

// 检查是否为素数 管道协程
func initChan(n int) {
	for i := 1; i <= n; i++ {
		intChan <- i
	}
	//close(intChan)
}
func isPrimeChannel(intChan chan int, primeChan chan int, exitChan chan bool) {
	var flag bool
label:
	for {
		select {
		case intchan := <-intChan:
			flag = true
			for j := 2; j < intchan; j++ {
				if intchan%j == 0 {
					flag = false
					continue
				}
			}
			if flag {
				primeChan <- intchan
			}
		default:
			break label
		}
	}
	exitChan <- true
}
func IsPrimeChannel() {
	var primeChan chan int = make(chan int, 100)
	var exitChan chan bool = make(chan bool, 8)
	go initChan(100)
	for i := 1; i <= 8; i++ {
		go isPrimeChannel(intChan, primeChan, exitChan)
	}
	go func() {
		for i := 0; i < 8; i++ {
			<-exitChan
		}
		//close(primeChan)
		//close(exitChan) //取完才能关闭，因为开启了八个协程，所以该管道会有八个值
	}()
label:
	for {
		select {
		case res := <-primeChan:
			fmt.Println("素数有", res)
		default:
			break label
		}

	}
}

2.5 defer 匿名函数捕获panic

//defer recover panic
func PanicMain() {
	go onlyOut(2)
	fmt.Println("exit main")
	go onlyIn()
	time.Sleep(time.Second * 2)
}
func onlyOut(num int) {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("onlyOut报错", err)
		}
	}()
	var testMap map[int]int //这地方报错
	testMap[0] = 1
}
func onlyIn() {
	for i := 0; i < 10; i++ {
		fmt.Println(i)
	}
}

2.6 生产者 消费者

//生产者消费者
func ProCouMain() {
	num := 10
	storageChan := make(chan Product, num)
	shopChan := make(chan Product, num)
	exitChan := make(chan bool, 1)
	for i := 0; i < num; i++ {
		go Produce(storageChan, num)
	}
	go Logistics(storageChan, shopChan)
	go Consumer(shopChan, num, exitChan)
	if <-exitChan {
		return
	}
}
//定义商品
type Product struct {
	Name string
}
//生产
func Produce(storage chan<- Product, count int) {
	for {
		producer := Product{Name: "商品：" + strconv.Itoa(count)}
		storage <- producer
		count--
		fmt.Println("生产了：", producer)
		time.Sleep(time.Second)
		if count < 1 {
			return
		}
	}
}
//运输
func Logistics(storageChan <-chan Product, shopCHan chan<- Product) {
	for {
		product := <-storageChan
		shopCHan <- product
		fmt.Println("运输了", product)
	}
}
//消费者消费
func Consumer(shopChan <-chan Product, count int, exitChan chan<- bool) {
	for {
		product := <-shopChan
		fmt.Println("消费者消费了", product)
		count--
		if count < 1 {
			exitChan <- true
			return
		}
	}
}

2.7 协程管道定时任务的应用

//协程管道定时任务
func TimingMain() {
	//方式一：
	fmt.Println("当前时间", time.Now())
	timer := time.NewTimer(time.Second * 3)
	t1 := <-timer.C //timer.c是一个只读的管道
	fmt.Println("现在时间", t1)
	//方式二:
	fmt.Println("当前时间", time.Now())
	t2 := <-time.After(time.Second * 3) //源码可见，实际返回的是 return NewTimer(d).C
	fmt.Println("现在时间", t2)
}

2.7 定时器的终止与重置

//协程管道定时任务
func TimingMain() {
	//方式一：
	fmt.Println("当前时间", time.Now())
	timer := time.NewTimer(time.Second * 3)
	if flag {
		timer.Stop()
	} else {
		t1 := <-timer.C //timer.c是一个只读的管道
		fmt.Println("现在时间", t1)
	}
	//方式二:
	//fmt.Println("当前时间", time.Now())
	//t2 := <-time.After(time.Second * 3) //源码可见，实际返回的是 return NewTimer(d).C
	//fmt.Println("现在时间", t2)
}
func IsStopTimer() bool {
	rand.Seed(time.Now().UnixNano())
	tempInt := rand.Intn(2) + 16
	if tempInt >= 18 {
		fmt.Println("已经找到大于18的,结束timer")
		return true
	} else {
		return false
	}
}

2.8 每隔固定时间触发任务

//循环时钟
func CircMain() {
	var count int = 0
	var exitChan chan bool
	newTicker := time.NewTicker(time.Second)
	go func() {
		for {
			t := <-newTicker.C
			fmt.Println(t.Format("2006-01-02 03:04:05PM"))
			count++
			if count > 1 {
				newTicker.Stop()
				exitChan <- true
			}
		}
	}()
	<-exitChan
	fmt.Println("结束！")
}

2.8 改造任务队列

• timer ticker

//循环时钟
func CircMain() {
	var wg sync.WaitGroup
	wg.Add(2)
	var count int = 0
	var countb int = 0
	newTicker := time.NewTicker(time.Second)
	go func() {
		defer wg.Done()
		defer newTicker.Stop()
		for {
			t := <-newTicker.C
			fmt.Println(t.Format("ticker" + "2006-01-02 03:04:05PM"))
			count++
			if count > 2 {
				return
			}
		}
	}()
	newTimer := time.NewTimer(time.Second)
	go func() {
		defer wg.Done()
		defer newTimer.Stop()
		for {
			t := <-newTimer.C
			fmt.Println(t.Format("timer:" + "2006-01-02 03:04:05PM"))
			newTimer.Reset(time.Second)
			countb++
			if countb > 3 {
				return
			}
		}
	}()
	wg.Wait()
	fmt.Println("结束！")
}

3 context上下文

3.1 默认context使用

3.2 主动传递取消信号

//context主动取消
func ContextCancel() {
	//1.创建cancelContext
	ctx, cancel := context.WithCancel(context.Background())
	//2.启动goroutine 携带cancelCtx
	for i := 0; i < 4; i++ {
		//启动goroutine 携带ctx参数
		go func(c context.Context, n int) {
			//监听context的取消完成channel，来确定是否执行了主动的cancel操作
			for {
				select {
				//等待接收c.Done()这个channel
				case <-c.Done():
					fmt.Println("1 context cancel!") //这里不输出原因是 37行 cancel()执行后 主goroutine已经结束，因此后续goroutine自动结束，所以还没来得及执行就结束了。
					return                           //不是<-c.Done()导致协程结束 ，是因为return导致结束。 <-c.Done()只是一个开关
				default:
				}
				fmt.Println(strings.Repeat("  ", n), n)
				time.Sleep(time.Millisecond * 300)
			}
		}(ctx, i)
	}
	//3.主动取消 cacel()
	//3秒后取消
	select {
	//case <-time.NewTimer(3 * time.Second).C:
	case <-time.After(2 * time.Second):
		cancel() // ctx.Done() <- struct{}
	}
	select {
	case <-ctx.Done():
		fmt.Println("2 context cancel!")
	}
}

3.3 定时取消

//定时取消信号
func ContextCancelTime() {
	fmt.Println(time.Now())
	//1.创建 带有时间的 cancelContext  一段时间后取消
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	//ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(time.Second*2)) //以上两个等价 这个是具体时间点
	//或具体到年月日时分秒纳秒，
	//curr := time.Now()
	//ctx, cancel := context.WithDeadline(context.Background(), time.Date(curr.Year(), curr.Month(), curr.Day(), 20, 30, 0, 0, time.Local))
	//2.启动goroutine 携带cancelCtx
	for i := 0; i < 4; i++ {
		//启动goroutine 携带ctx参数
		go func(c context.Context, n int) {
			//监听context的取消完成channel，来确定是否执行了主动的cancel操作
			for {
				select {
				//等待接收c.Done()这个channel
				case <-c.Done():
					fmt.Println("1 context cancel!") //这里不输出原因是 37行 cancel()执行后 主goroutine已经结束，因此后续goroutine自动结束，所以还没来得及执行就结束了。
					return                           //不是<-c.Done()导致协程结束 ，是因为return导致结束。 <-c.Done()只是一个开关
				default:
				}
				fmt.Println(strings.Repeat("  ", n), n)
				time.Sleep(time.Millisecond * 300)
			}
		}(ctx, i)
	}
	//3.主动取消 cancel() 到时取消
	select {
	//4s后主动取消
	case <-time.After(4 * time.Second):
		cancel() // ctx.Done() <- struct{}
		fmt.Println("主动", time.Now())
		fmt.Println("call cancel() Cancel")
	case <-ctx.Done(): //2s后到时取消
		fmt.Println("被动", time.Now())
		fmt.Println("main  cancel!")
	}
}

3.4 cancel操作的向下取消

//cancel取消向下传递
func ContextCancelDeep() {
	//1.创建层级关系的cancelCtx  1-(2-(4),3)
	//ctxOne, _ := context.WithCancel(context.Background())
	//ctxTwo, cancel := context.WithCancel(ctxOne)
	//ctxThree, _ := context.WithCancel(ctxOne)
	//ctxFour, _ := context.WithCancel(ctxTwo)
	//1.定时器方式保证取消 一方面也解决了枷锁固定问题
	ctxOne, _ := context.WithTimeout(context.Background(), time.Second*2)
	ctxTwo, cancel := context.WithTimeout(ctxOne, time.Second*2)
	ctxThree, _ := context.WithTimeout(ctxOne, time.Second*2)
	ctxFour, _ := context.WithTimeout(ctxTwo, time.Second*2)
	wg := sync.WaitGroup{}

	//2.使用goroutine来接收ctx.Done()
	go func(c context.Context) {
		wg.Add(1)
		defer wg.Done()
		select {
		case <-c.Done(): //ctxOne
			fmt.Println("one cancel")
		}
	}(ctxOne)
	go func(c context.Context) {
		wg.Add(1)
		defer wg.Done()
		select {
		case <-c.Done(): //ctxOne
			fmt.Println("two cancel")
		}
	}(ctxTwo)
	go func(c context.Context) {
		wg.Add(1)
		defer wg.Done()
		select {
		case <-c.Done(): //ctxOne
			fmt.Println("three cancel")
		}
	}(ctxThree)
	go func(c context.Context) {
		wg.Add(1)
		defer wg.Done()
		select {
		case <-c.Done(): //ctxOne
			fmt.Println("four cancel")
		}
	}(ctxFour)
	//主动取消
	cancel()
	wg.Wait()
}

3.5 取消操作的流程

3.6 context传值

//context传值
func ContextValue() {
	wg := sync.WaitGroup{}
	wg.Add(1)
	//1.创建带有value的Context
	//传递 有哪个用哪个 没有的话就用上层的(如果key一致),key不一致的话,按从低到高找  1--2--3
	//key的值不建议直接使用string或其他内置类型 例如 两个包的 key "one" ,但值不一样
	ctxOne := context.WithValue(context.Background(), MyContextString("one"), "go of one")
	ctxTwo := context.WithValue(ctxOne, "title", "go of two")
	ctxThree := context.WithValue(ctxTwo, "title", "go of three")
	//2.将ctx传到goroutine中使用
	go func(c context.Context) {
		defer wg.Done()
		//获取key对应的value
		if v := c.Value(MyContextString("one")); v != nil {
			fmt.Println("title 对应的值为", v)
			return
		}
		fmt.Println("NOT FOUND VALUE ACCORDING TO title")
	}(ctxThree)
	wg.Wait()
}

3.7 小节

4 同步与锁

4.1互斥锁的使用

4.2 读写互斥锁rwmutex

func SyncRLock() {
	//RLOCK可能先于LOCK
	wg := sync.WaitGroup{}
	//模拟多个goroutine
	var rwlck sync.RWMutex
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			//输出一段内容
			//rwlck.Lock()
			rwlck.RLock()
			fmt.Println(time.Now())
			time.Sleep(1 * time.Second)
			//rwlck.Unlock()
			rwlck.RUnlock()
		}()
	}
	wg.Add(1)
	go func() {
		defer wg.Done()
		defer wg.Done()
		//输出一段内容
		rwlck.Lock()
		fmt.Println(time.Now(), "LOCK")
		time.Sleep(1 * time.Second)
		rwlck.Unlock()
	}()
	wg.Wait()
}

4.3 sync.map同步map的使用

//syncmap
func SyncSyncMapMethod() {
	wg := sync.WaitGroup{}
	//直接初始化即可使用，不需要指定key和value的类型
	var m sync.Map
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(n int) {
			defer wg.Done()
			//存储
			m.Store(n, fmt.Sprintf("value:(%d)", n))
		}(i)
	}
	//并发goroutine完成load操作
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(n int) {
			defer wg.Done()
			//读取
			fmt.Println(m.Load(n))
		}(i)
	}
	wg.Wait()
	//遍历
	m.Range(func(key, value interface{}) bool {
		fmt.Println(key, value)
		//返回true，继续遍历，直到map结尾
		//返回false 提前终止遍历
		return true
	})
	m.Delete(4)
}

4.4原子操作

// 原子操作
func SyncAtomicAdd() {
	//并发的过程 没有加锁
	//atomic 原子的int32 counter:=0
	var counter atomic.Int32
	wg := sync.WaitGroup{}
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for i := 0; i < 100; i++ {
				//原子累加 == counter++
				counter.Add(1)
			}
		}()
	}
	wg.Wait()
	fmt.Println("counter", counter.Load())
}

func SyncAtomicValue() {
	//一个goroutine动态加载配置
	//配置为自定义类型 map[string]string
	//模拟加载配置，例如从配置文件加载，返回解析的配置信息
	var loadConfig = func() map[string]string {
		return map[string]string{
			//some config
			"title":   "马士兵go并发",
			"varConf": fmt.Sprintf("%d", rand.Int31()),
		}
	}
	//config的操作应该是并发安全的，我们选择使用原子操作来实现
	//自定义的原子操作类型，atomic.Value
	var config atomic.Value
	//每n秒加载一次配置文件(监视配置文件的修改)
	go func() {
		for {
			//原子加载配置
			config.Store(loadConfig())
			fmt.Println("lasted config was loaded", time.Now().Format("15:04:05.99999999"))
			time.Sleep(time.Second)
		}
	}()
	//在多个goroutine中使用最新配置
	//不能在加载的过程中使用配置
	for {
		go func() {
			//原子加载配置
			c := config.Load()
			fmt.Println(c, time.Now().Format("15:04:06.99999999"))
		}()
		time.Sleep(400 * time.Millisecond)
	}
	select {}
}

4.5 sync.pool并发安全池

• 这个类设计的目的是用来保存和复用临时对象，以减少内存分配，降低cg压力。

// sync.pool
//并发资源管理
func SyncPool() {

	//管理资源 资源为可复用的临时对象时，使用池子
	//原子计数器
	var counter int32 = 0
	//定义元素的Newer,创建器
	elementNewer := func() any {
		//原子的计数器累加
		atomic.AddInt32(&counter, 1)
		//池中元素推荐(强烈)是指针类型
		return new(bytes.Buffer)
	}
	//Pool的初始化
	pool := sync.Pool{
		New: elementNewer, //一旦池子里没有的话，调用pool.New
	}
	//并发的申请和交回元素
	wg := sync.WaitGroup{}
	workNum := 1024
	wg.Add(workNum)
	for i := 0; i < workNum; i++ {
		go func() {
			defer wg.Done()
			//申请元素，通常需要断言为特定类型
			buffer := pool.Get().(*bytes.Buffer)
			//交回元素
			defer pool.Put(buffer)
			//使用元素
			_ = buffer.String()
		}()
	}
	wg.Wait()
	//测试创建元素次数
	fmt.Println("elements number：", counter)
}

4.6 data race现象

• 检测数据竞争情况 解决方案 锁或原子操作
• 

package main

import (
	"fmt"
	"sync"
)

func main() {
	wg := sync.WaitGroup{}
	num := 1000
	var counter int = 0
	wg.Add(num)
	for i := 0; i < num; i++ {
		go func() {
			defer wg.Done()
			//累加
			for k := 0; k < 100; k++ {
				counter++
			}
		}()
	}
	wg.Wait()
	fmt.Println("counter number is ", counter)
}

4.7 sync.Once 执行一次

func SyncOnce() {
	//初始化config变量
	config := make(map[string]string)
	//1.初始化 sync.Once
	once := sync.Once{}
	//加载配置函数
	loadConfig := func() {
		//2. 利用 once.Do()来执行
		once.Do(func() {
			//保证只执行一次
			config = map[string]string{
				"varInt": fmt.Sprintf("%d", rand.Int31()),
			}
			fmt.Println("config loaded")
		})
	}
	//模拟多个goroutine，多次调用加载配置
	//测试加载配置操作，执行了几次
	workers := 10
	wg := sync.WaitGroup{}
	wg.Add(workers)
	for i := 0; i < workers; i++ {
		go func() {
			defer wg.Done()
			//并发的多次加载配置
			loadConfig()
			//使用配置
			_ = config
		}()
	}
	wg.Wait()
}

4.8 sync .Cond 条件等待通知的使用

// 一个goroutine接收数据，多个goroutine处理数据
func SyncCond() {
	wg := sync.WaitGroup{}
	//全局(使用cond的gouroutine来说的)数据
	var data []int
	dataLen := 1024 * 1024
	//1.创建sync.Cond
	cond := sync.NewCond(&sync.Mutex{})
	//接受数据goroutine，一个
	wg.Add(1)
	go func() {
		defer wg.Done()
		cond.L.Lock() //用于输出 “cond broadcast”
		defer cond.L.Unlock()
		for i := 0; i < dataLen; i++ {
			data = append(data, i*i) //模拟数据传输
		}
		//2.在数据接收完毕后，在通知处理的goroutine进行数据处理
		//广播,可以选的需要锁定
		time.Sleep(time.Second * 2)
		cond.Broadcast() //先 wait 再 broadcast
		fmt.Println("cond broadcast")
	}()
	const workers = 8
	wg.Add(workers)
	//处理数据的goroutine,一组
	for i := 0; i < workers; i++ {
		go func() {
			defer wg.Done()
			//3.在数据未接收完之前(就是等待的条件)，等待
			//wait前要加锁
			cond.L.Lock()
			//defer cond.L.Unlock()
			for len(data) < dataLen { //表明没有传输完毕，等待中 使用 for 是因为其他地方可能使用了 cond.Broadcast()，提前释放了wait
				cond.Wait() //函数里先解锁了，后加锁了
			}
			//处理数据
			fmt.Println("处理数据，数据长度：", len(data))
			//wait后要解锁，业务逻辑处理完毕
			cond.L.Unlock()
		}()
	}
	wg.Wait()
}

4.9 同步与索小节

5 案例

5.1 并发目录大小统计之一 业务分析

5.2 并发目录大小统计之二 整体流程

5.3 并发目录大小统计之三 递归信息

// WalkDir 外部调用的遍历目录统计信息的方法
func WalkDir(dirs ...string) string { //多个目录，一个目录下有多个文件
	//一、保证至少有一个目录需要统计遍历
	//默认为当前目录
	if len(dirs) == 0 {
		dirs = []string{"."}
	}
	//二、初始化变量，channel用于完成Size的传递，WaitGroup用于等待调度
	filesizeCh := make(chan int64, 1)
	wg := &sync.WaitGroup{} //在多个协程传递用指针类型
	//三、启动多个Goroutine统计信息，取决于len(dirs)
	for _, dir := range dirs {
		wg.Add(1) //+1
		//并发的遍历统计每个目录的信息
		go walkDir(dir, filesizeCh, wg)
	}
	//四、启动累计运算的Goroutine
	//1.用户关闭 filesizeCh
	go func(wg *sync.WaitGroup) {
		//等待统计工作的完成
		wg.Wait()
		//关闭 filesizeCh
		close(filesizeCh)
	}(wg)
	//2.range的方式从 filesizeCh 中获取文件大小
	//3.将统计结果，用channel传递出来
	fileNumCh := make(chan int64, 1)
	sizeTotalCh := make(chan int64, 1)
	go Total(filesizeCh, fileNumCh, sizeTotalCh)
	//五、整理返回值
	//size的单位 byte
	//需要的单位 mb
	result := fmt.Sprintf("%d files %.2f MB\n", <-fileNumCh,
		float64(<-sizeTotalCh)/1e6) //1024*1024
	return result
}

// 遍历并统计某个特定目录的信息
// 核心实现函数，完成递归，统计
func walkDir(dir string, filesizeCh chan<- int64, wg *sync.WaitGroup) {
	//一、wg计数器减少
	defer wg.Done()
	//二、读取 dir 下的全部文件信息
	for _, fileinfo := range fileInfos(dir) {
		//三、根据 dir 下的文件信息
		if fileinfo.IsDir() {
			//1.如果是目录， 获取递归信息
			//子目录地址
			subDir := filepath.Join(dir, fileinfo.Name())
			//递归调用，也是并发的，也需要wg统计
			wg.Add(1)
			go walkDir(subDir, filesizeCh, wg)
		} else {
			//2.如果不是，就是文件，统计文件大小，放入channel
			filesizeCh <- fileinfo.Size() //Byte
		}
	}
}

//获取某个目录下全部信息列表
func fileInfos(dir string) []fs.FileInfo {
	//一、读取目录的全部文件
	entries, err := os.ReadDir(dir)
	if err != nil {
		log.Println("WalkDir error ", err)
		return []fs.FileInfo{} //nil
	}
	//二、获取文件的文件信息
	//DirEntry to FileInfo
	infos := make([]fs.FileInfo, 0, len(entries))
	for _, entry := range entries {
		//如果获取文件信息无错误，存储到Infos中
		if info, err := entry.Info(); err == nil {
			infos = append(infos, info)
		}
	}
	//三、返回
	return infos
}

func Total(filesizeCh <-chan int64, fileNumCh, sizeTotalCh chan<- int64) {
	//统计文件数，和文件整体大小
	var fileNum, sizeTotal int64
	//遍历全部 filesizeCh 元素，统计文件数量和大小，直到 filesizeCh 通道关闭
	for filesize := range filesizeCh { //使用 for 是防止通道阻塞
		//累计文件数，和统计文件整体大小
		fileNum++
		sizeTotal += filesize
	}
	//将统计结果写入channel
	fileNumCh <- fileNum
	sizeTotalCh <- sizeTotal
}

快速排序的并发编程思想实现