func main(){
    lis,err := net.Listen("tcp","localhost:8080")
    if err != nil {
        log.Fatal(err)
    }
    for {
        conn,err := lis.Accept()
        if err != nil {
            log.Println(err)
        }
        go func(){
            defer conn.Close()
            for {
                _,err := io.WriteString(conn, time.Now().Format("15:04:05\n"))
                if err != nil {
                    return 
                }
                time.Sleep(1*time.Second)
            }
        }(conn net.Conn)
        /*
        这里不要使用内部函数来捕获变量，申明一个参数，将需要的变量传递进来。
        */
    }
}

func main(){
    naturals := make(chan int)
    squares := make(chan int)

    //计数器
    go func(){
        for x:=0 ; x<100 ; x++ {
            naturals <- x
        }
        close(naturals) //通知接收方停止
    }()
    
    //平方产生器
    go func(){
        for x := range naturals {
            squares <- x*x
        }
        close(squares) //同上
    }()

    //打印器
    for x := range squares {
        fmt.println(x)
    }
}

select {
    case <-ch1:

    case x := <-ch2:

    case ch3 <- y:

    //可选
    default:
    //当default出现时，select永不阻塞，相当于轮询
    //没有default时，若所有case都是阻塞状态，这select会阻塞，
    //有任一case得到响应，select则进入相应的case执行代码
    //若同时有多个case满足条件，select随机选择一个进入
}

var verbose = flag.Bool("v", false, "Show verbose progress message")
var done = make(chan struct{}) //标识是否停止

func main(){
    flag.Parse()
    roots := flag.Args()
    if len(roots) == 0 {
        roots = []string{"."}
    }
    go func(){
        os.Stdin.Read(make([]byte,1)) //任意按键停止程序
        close(done)
    }()

    fileSize := make(chan int64) //接受文件大小
    var n sync.WaitGroup
    for _, root := range roots {
        n.Add(1)
        go walkDir(root, &n, fileSize)
    }
    go func(){
        n.Wait()
        close(fileSize)
    }()

    var tick <-chan time.Time
    if *verbose {
        tick = time.Tick(500*time.Millisecond) //500毫秒显示一次
    }
    
    var nfiles, nbytes int64
loop:
    for {
        select{
            case <-done:
                for range fileSize{} //吃空所有goroutine
                return
            case size,ok := <-fileSize:
                if !ok { 
                    break loop  //跳出for循环
                }
                nfiles ++
                nbytes += size
            case <-tick.C:  //定时任务
                printDiskUsage(nfiles,nbytes)
        }
    }
    printDiskUsage(nfiles, nbytes)
    fmt.Println(nbytes)
}

func printDiskUsage(nfiles,nbytes int64){
    fmt.Printf("du: %d files, %s\n",nfiles,formatUnit(nbytes))
}

func formatUnit(nbytes int64) string {
    units := []string{"bytes","Kb","Mb","Gb","Pb"}
    index := 0
    var unit = units[index]
    var b = float64(nbytes)
    for b>1e3 && index<len(units) {
        index ++
        unit = units[index]
        b /= 1e3
    }
    return fmt.Sprintf(".2f %s",b,unit)
}

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

func walkDir(dir string, n *sync.WaitGroup, fileSize <-chan int64){
    defer n.Done()
    if isCanceled() {
        return
    }
    for _,entry := range dirents(dir) {
        if entry.IsDir() {
            n.Add(1)
            subDir := filePath.Join(dir,entry.Name())
            go walkDir(subDir,n,fileSize)
        } else {
            fileSize <- entry.Size()
        }
    }
}

var sema = make(chan struct{}, 20) //最多20个goroutine

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.Fprintf(os.Stderr,"du: %v\n", err)
        return nil
    }
    return entries
}