Goroutines和Channels

func makeThumbnails(filenames <-chan string) int64 {
	sizes := make(chan int64)
	var	wg sync.WaitGroup//number of working goroutines
	for	f := range filenames {
		wg.Add(1)//必需在worker goroutines开始之前调用，才能保证Add()是在closer goroutine调用Wait()之前被调用
		//worker goroutines
		go func(f string) {
			defer wg.Done()//使用defer来确保计数器即使是在程序出错的情况下依然能够正确地自减
			thumb, err := thumbnail.ImageFile(f)
			if err != nil {
				log.Println(err)
				return
			}
			info, _ := os.Stat(thumb)
			sizes <- info.Size()
		}(f)
	}
	//closer goroutine
	go func() {
		wg.Wait()
		close(sizes)
	}()
	var	total int64
	for	size := range sizes {
		total += size
	}
	return total
}

/**
*广度遍历目录文件，计算文件数量与大小
*每隔0.5秒输出已计算的文件数量与大小
*当标准输入有值时，中断程序运行
**/
package main

import (
	"flag"
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"sync"
	"time"
)

//广度遍历目录文件，计算文件数量与大小
func walkDir(dir string, n *sync.WaitGroup, fileSizes chan<- int64) {
	defer n.Done()
	if cancelled() {
		return
	}
	for _, entry := range dirents(dir) {
		if entry.IsDir() {
			n.Add(1)
			subdir := filepath.Join(dir, entry.Name())
			go walkDir(subdir, n, fileSizes)
		} else {
			fileSizes <- entry.Size()
		}
	}
}

/*
*目的：控制同一时刻打开的文件数量，防止程序占用太多资源
*实现：创建一个带缓存的channel，通过channel的缓存队列大小控制同一时刻打开的文件数量。
*读取文件之前向该channel发送一个信号量，读取完以后向该channel接收一个信号量，若是channel的缓存
*队列满了，则会阻塞，无法继续打开文件。
 */
var sema = make(chan struct{}, 2)

func dirents(dir string) []os.FileInfo {
	select {
	case sema <- struct{}{}:
	case <-done:
		return nil
	}
	defer func() { <-sema }()
	entries, err := ioutil.ReadDir(dir)
	if err != nil {
		fmt.Fprint(os.Stderr, "du1: %\n", err)
		return nil
	}
	return entries
}

/*
*目的：读取标准输入，只要有值则停止运行程序
*实现：创建一个空channel，每个goroutine读取文件之前都先从channel中接收值，如果阻塞，表示程序可以继续运行，
*当标准输入有值时，关闭该channel，所有未读取文件的goroutine从channel中接收到零值，中断程序运行。
 */
var done = make(chan struct{})

func cancelled() bool {
	select {
	case <-done:
		return true
	default:
		return false
	}
}

func main() {
	//读取标准输入，只要有输入则停止程序
	go func() {
		os.Stdin.Read(make([]byte, 1))
		close(done)
	}()

	flag.Parse()
	roots := flag.Args()
	if len(roots) == 0 {
		roots = []string{"."}
	}
	//用于发送文件大小的channel
	fileSizes := make(chan int64)

	/*
	*目的：当读取文件大小的所有goroutine都结束运行时，关闭用于发送文件大小的channel
	*实现：使用特殊计数器sync.WaitGroup，每次新增一个goroutine则自增1，每次结束一个goroutine
	*则自减1，当其自减为0时，表示所有goroutine都已结束运行，可以关闭channel了
	 */
	var n sync.WaitGroup
	for _, root := range roots {
		n.Add(1)
		go walkDir(root, &n, fileSizes)
	}
	go func() {
		n.Wait()
		close(fileSizes)
	}()

	/*
	*目的：每隔0.1秒输出文件数量与大小计算的结果
	*实现：使用time.Tick函数。time.Tick函数返回一个channel，程序会周期性地像一个节拍器一样向这个channel发送事件，
	*每一个事件的值是一个时间戳。当从该channel中接收到值的时候，就可以打印了。
	 */
	var tick <-chan time.Time
	tick = time.Tick(100 * time.Millisecond)

	var nfiles, nbytes int64
loop:
	for {
		select {
		case <-done:
			/*
			*程序结束，需要先吧fileSizes这个channel中的内容排空，以保证对walkDir的调用不会被向fileSizes发送信息阻塞住，
			*可以正确地完成,防止goroutine泄露。
			 */
			for range fileSizes {
			}
		case size, ok := <-fileSizes:
			if !ok { //fileSizes这个channel已关闭，退出循环loop
				break loop
			}
			nfiles++
			nbytes += size
		case <-tick:
			printDiskUsage(nfiles, nbytes)
		}
	}
}

//打印已经计算的文件数量与大小
func printDiskUsage(nfiles, nbytes int64) {
	fmt.Printf("%d files  %.1f GB\n", nfiles, float64(nbytes)/1e9)
}