golang sync

##Goroutine 内存占用

下面是一个创建 goroutine 什么也不干，对内存的占用打印。说明创建 goroutine 的成本非常低。

num:1  mem: 0.062MB average:64.000kb 
num:10  mem: 0.000MB average:0.000kb 
num:100  mem: 0.000MB average:0.000kb 
num:1000  mem: 0.250MB average:0.256kb 
num:10000  mem: 1.373MB average:0.141kb 
num:100000  mem: 265.852MB average:2.722kb 
num:1000000  mem: 2462.125MB average:2.521kb 

以下是创建代码：

package main

import (
	"fmt"
	"runtime"
	"sync"
)

// goroutine ： go 中的每个并发执行单元叫 go routine

// 返回从系统中获取的字节数
func memConsumed() uint64 {
	runtime.GC()
	var s runtime.MemStats
	runtime.ReadMemStats(&s)
	return s.Sys //系统字节数
}

// 获取创建指定数量协程
func memChannel(num uint64) {
	var c <-chan interface{}

	var wg sync.WaitGroup
	noop := func() {
		wg.Done()
		<-c
	}
	wg.Add(int(num))
	before := memConsumed()
	for i := num; i > 0; i-- {
		go noop()
	}
	wg.Wait()
	after := memConsumed()
	fmt.Printf("num:%d  mem: %.3fMB average:%.3fkb \n", num, float64(after-before)/1024/1024, float64(after-before)/1024/float64(num))

}

func main() {
	memChannel(1)
	memChannel(1e1)
	memChannel(1e2)
	memChannel(1e3)
	memChannel(1e4)
	memChannel(1e5)
	memChannel(1e6) // 百万
}

WaitGroup

用于等待线程结束，Add 为计数器 +n，Done 线程结束方法。 当调用到 n个 Done 后 ，如果计数器小于 0 ，Wait 阻塞结束。

var wg sync.WaitGroup
var urls = []string{
    "http://www.golang.org/",
    "http://www.google.com/",
    "http://www.somestupidname.com/",
}
for _, url := range urls {
    // Increment the WaitGroup counter.
    wg.Add(1)
    // Launch a goroutine to fetch the URL.
    go func(url string) {
        // Decrement the counter when the goroutine completes.
        defer wg.Done()
        // Fetch the URL.
        http.Get(url)
    }(url)
}
// Wait for all HTTP fetches to complete.
wg.Wait()

Mutex

Mutex 是一个互斥锁。 具有两个方法 Lock 和 Unlock。

Lock 如果加锁，则阻塞到解锁 。

Unlock 如果未加锁会导致运行错误。

RWMutex

读写互斥锁，可以多个读一个写。

Lock /Unlock 同 Mutex

Rlock/RUnlock 锁定为读取，禁止写，允许读。

Once

Do 只能执行一次.

func main() {
	var once sync.Once
	onceBody := func() {
		fmt.Println("Only once")
	}

	done := make(chan bool)

	for i := 0; i < 5; i++ {
		go func() {
			fmt.Println("go run \n")
			once.Do(onceBody) // 只会执行一次
			done <- true
		}()
	}

	for i := 0; i < 5; i++ {
		fmt.Printf("done channel :%v \n", <-done)
	}
}

$ go run once.go
go run 

Only once
done channel :true 
go run 

done channel :true 
go run 

go run 

done channel :true 
go run 

done channel :true 
done channel :true 

Cond

条件锁，当满足某些条件才起作用的锁。

package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {

	var lc = new(sync.Mutex)
	var cond = sync.NewCond(lc)

	for i := 0; i < 3; i++ {
		go func(x int) {
			cond.L.Lock()
			defer cond.L.Unlock()
			cond.Wait()
			fmt.Println(x)
		}(i)
	}

	time.Sleep(2 * time.Second)
	fmt.Println("1--\n")
	cond.Signal()
	time.Sleep(2 * time.Second)
	fmt.Println("2--\n")
	cond.Broadcast()
	time.Sleep(2 * time.Second)

}

$ go run cone.go
1-- # signal

0
2-- # broadcast 

1
2

Pool

sync.Pool有两个公开的方法。一个是Get，另一个是Put。前者的功能是从池中获取一个interface{}类型的值，而后者的作用则是把一个interface{}类型的值放置于池中。

// 一个[]byte的对象池，每个对象为一个[]byte
var bytePool = sync.Pool{
  New: func() interface{} {
    b := make([]byte, 1024)
    return &b
  },
}

func main() {
  a := time.Now().Unix()
  // 不使用对象池
  for i := 0; i < 1000000000; i++{
    obj := make([]byte,1024)
    _ = obj
  }
  b := time.Now().Unix()
  // 使用对象池
  for i := 0; i < 1000000000; i++{
    obj := bytePool.Get().(*[]byte)
    _ = obj
    bytePool.Put(obj)
  }
  c := time.Now().Unix()
  fmt.Println("without pool ", b - a, "s")
  fmt.Println("with    pool ", c - b, "s")
}

// without pool  34 s
// with    pool  24 s