知识点
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
}
}
引用
欢迎大家关注我的公众号
半亩房顶
