《GO语言圣经》学习笔记(八)Goroutines和Channels

知识点

goroutinue

基本用法

golang非常深度的简化了goroutinue的使用方法,异常简单,门槛降低很多

// goroutinue 使用非常简单
go f()

Goroutines和线程的区别

  • goroutinue使用动态栈,2k开始,最大1g
  • Go的运行时包含了其自己的调度器,这个调度器使用了一些技术手段,比如m:n调度,因为其会在n个操作系统线程上多工(调度)m个goroutine
  • Go的调度器使用了一个叫做GOMAXPROCS的变量来决定会有多少个操作系统的线程同时执行Go的代码
  • goroutine没有可以被程序员获取到的身份(id)的概念
注意点

channel

基本用法
  • 发送和接收两个操作都使用<-运算符。在发送语句中,<-运算符分割channel和要发送的值。

  • 在接收语句中,<-运算符写在channel对象之前。一个不使用接收结果的接收操作也是合法的。

  • 试图重复关闭一个channel将导致panic异常,试图关闭一个nil值的channel也将导致panic异常

  • channel分带缓存和不带缓存

ch = make(chan int)    // 不带缓存 channel
ch = make(chan int, 0) // 不带缓存 channel
ch = make(chan int, 3) // 容量为3的缓存 channel
cap 为缓存,len为缓存已使用长度
  • 无缓存channels 的发送和接受会以阻塞的方式让两个goroutinue进行同步,因此,无缓存channels又称同步channels。

  • 接收者接收到数据发生在唤醒发送者goroutinue之前,此称happens before:数据需要先接收到channels中,才能被channels发送出去,即先写才能读。

  • 单向channels 限制形式如下,限制在编译期检测

func counter(out chan<- int) {
     XXX
}
  • 基于select 的多路复用
func main() {
    // ...create abort channel...

    fmt.Println("Commencing countdown.  Press return to abort.")
    // main 结束后,tick并不会停止,goroutinue泄露
    tick := time.Tick(1 * time.Second)
    for countdown := 10; countdown > 0; countdown-- {
        fmt.Println(countdown)
        // select会等待某一个case有事件到达,然后执行对应代码块,加上default的代码(如果有的话)
        select {
        case <-tick:
            // Do nothing.
        case <-abort:
            fmt.Println("Launch aborted!")
            return
        }
    }
    // 应该显示关闭 tick: tick.Stop()
    launch()
}
注意点
  • 基于已关闭的channel的发送操作会导致 panic

示例

利用goroutinue 加速统计目录下文件数目和大小的示例程序,有几点可以学习借鉴下

  • 终止程序的实现
  • 打印中间状态的实现
  • sync 包的使用
  • 信号量的实现
package main

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

var verbose = flag.Bool("v", false, "show verbose progress messages")

func main() {
    // Determine the initial directories.
    flag.Parse()
    roots := flag.Args()
    if len(roots) == 0 {
        roots = []string{"/Users/bjhl/go"}
    }

    // Cancel traversal when input is detected.
    go func() {
        os.Stdin.Read(make([]byte, 1)) // read a single byte
        close(done)
    }()

    // Traverse each root of the file tree in parallel.
    fileSizes := make(chan int64)
    var n sync.WaitGroup
    for _, root := range roots {
        n.Add(1)
        go walkDir(root, &n, fileSizes)
    }
    go func() {
        n.Wait()
        close(fileSizes)
    }()

    // Print the results periodically.
    var tick <-chan time.Time
    if *verbose {
        tick = time.Tick(500 * time.Millisecond)
    }
    var fileNums, byteNums int64
loop:
    for {
        select {
        case <-done:
            // Drain fileSizes to allow existing goroutines to finish.
            for range fileSizes {
                // Do nothing.
            }
            return
        case size, ok := <-fileSizes:
            if !ok {
                break loop // fileSizes was closed
            }
            fileNums++
            byteNums += size
        case <-tick:
            printDiskUsage(fileNums, byteNums)
        }
    }
    printDiskUsage(fileNums, byteNums) // final totals
}

func printDiskUsage(fileNums, byteNums int64) {
    fmt.Printf("%d files  %.1f GB\n", fileNums, float64(byteNums)/1e9)
}

// walkDir recursively walks the file tree rooted at dir
// and sends the size of each found file on fileSizes.
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()
        }
    }
}

// sema is a counting semaphore for limiting concurrency in dirents.
var sema = make(chan struct{}, 20)

// dirents returns the entries of directory dir.
func dirents(dir string) []os.FileInfo {
    select {
    case sema <- struct{}{}: // acquire token
    case <-done:
        return nil // cancelled
    }
    defer func() { <-sema }() // release token

    entries, err := ioutil.ReadDir(dir)
    if err != nil {
        fmt.Fprintf(os.Stderr, "du: %v\n", err)
        return nil
    }
    return entries
}

var done = make(chan struct{})

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

引用


欢迎大家关注我的公众号


半亩房顶

推荐阅读更多精彩内容