Golang学习 - sync 包

------------------------------------------------------------

临时对象池

  Pool 用于存储临时对象,它将使用完毕的对象存入对象池中,在需要的时候取出来重复使用,目的是为了避免重复创建相同的对象造成 GC 负担过重。其中存放的临时对象随时可能被 GC 回收掉(如果该对象不再被其它变量引用)。

  从 Pool 中取出对象时,如果 Pool 中没有对象,将返回 nil,但是如果给 Pool.New 字段指定了一个函数的话,Pool 将使用该函数创建一个新对象返回。

  Pool 可以安全的在多个线程中并行使用,但 Pool 并不适用于所有空闲对象,Pool 应该用来管理并发的多线程共享的临时对象,而不应该管理短寿命对象中的临时对象,因为这种情况下内存不能很好的分配,这些短寿命对象应该自己实现空闲列表。

  Pool 在开始使用之后,不能再被复制。

------------------------------------------------------------

type Pool struct {
	// 创建临时对象的函数
	New func() interface{}
}

// 向临时对象池中存入对象
func (p *Pool) Put(x interface{})

// 从临时对象池中取出对象
func (p *Pool) Get() interface{}

------------------------------------------------------------

单次执行

  Once 的作用是多次调用但只执行一次,Once 只有一个方法,Once.Do(),向 Do 传入一个函数,这个函数在第一次执行 Once.Do() 的时候会被调用,以后再执行 Once.Do() 将没有任何动作,即使传入了其它的函数,也不会被执行,如果要执行其它函数,需要重新创建一个 Once 对象。

  Once 可以安全的在多个线程中并行使用。

------------------------------------------------------------

// 多次调用仅执行一次指定的函数 f
func (o *Once) Do(f func())

------------------------------------------------------------

// 示例:Once
func main() {
	var once sync.Once
	onceBody := func() {
		fmt.Println("Only once")
	}
	done := make(chan bool)
	for i := 0; i < 10; i++ {
		go func() {
			once.Do(onceBody) // 多次调用只执行一次
			done <- true
		}()
	}
	for i := 0; i < 10; i++ {
		<-done
	}
}

// 输出结果:
// Only once

------------------------------------------------------------

// Locker 接口包装了基本的 Lock 和 UnLock 方法,用于加锁和解锁。
type Locker interface {
    Lock()
    Unlock()
}

------------------------------------------------------------

互斥锁

  互斥锁用来保证在任一时刻,只能有一个线程访问某对象。Mutex 的初始值为解锁状态。Mutex 通常作为其它结构体的匿名字段使用,使该结构体具有 Lock 和 Unlock 方法。

  Mutex 可以安全的在多个线程中并行使用。

------------------------------------------------------------

// Lock 用于锁住 m,如果 m 已经被加锁,则 Lock 将被阻塞,直到 m 被解锁。
func (m *Mutex) Lock()

// Unlock 用于解锁 m,如果 m 未加锁,则该操作会引发 panic。
func (m *Mutex) Unlock()

------------------------------------------------------------

// 示例:互斥锁
type SafeInt struct {
	sync.Mutex
	Num int
}

func main() {
	count := SafeInt{}
	done := make(chan bool)
	for i := 0; i < 10; i++ {
		go func(i int) {
			count.Lock() // 加锁,防止其它线程修改 count
			count.Num += i
			fmt.Print(count.Num, " ")
			count.Unlock() // 修改完毕,解锁
			done <- true
		}(i)
	}
	for i := 0; i < 10; i++ {
		<-done
	}
}

// 输出结果(不固定):
// 2 11 14 18 23 29 36 44 45 45

------------------------------------------------------------

读写互斥锁

  RWMutex 比 Mutex 多了一个“读锁定”和“读解锁”,可以让多个线程同时读取某对象。RWMutex 的初始值为解锁状态。RWMutex 通常作为其它结构体的匿名字段使用。

  Mutex 可以安全的在多个线程中并行使用。

------------------------------------------------------------

// Lock 将 rw 设置为写锁定状态,禁止其他线程读取或写入。
func (rw *RWMutex) Lock()

// Unlock 解除 rw 的写锁定状态,如果 rw 未被写锁定,则该操作会引发 panic。
func (rw *RWMutex) Unlock()

// RLock 将 rw 设置为读锁定状态,禁止其他线程写入,但可以读取。
func (rw *RWMutex) RLock()

// Runlock 解除 rw 的读锁定状态,如果 rw 未被读锁顶,则该操作会引发 panic。
func (rw *RWMutex) RUnlock()

// RLocker 返回一个互斥锁,将 rw.RLock 和 rw.RUnlock 封装成了一个 Locker 接口。
func (rw *RWMutex) RLocker() Locker

------------------------------------------------------------

组等待

  WaitGroup 用于等待一组子线程的结束。主线程在创建每个子线程的时候先调用 Add 增加等待计数,每个子线程在结束时调用 Done 减少线程计数。之后,主线程通过 Wait 方法开始等待,直到计数器归零才继续执行。

------------------------------------------------------------

// 计数器增加 delta,delta 可以是负数。
func (wg *WaitGroup) Add(delta int)

// 计数器减少 1
func (wg *WaitGroup) Done()

// 等待直到计数器归零。如果计数器小于 0,则该操作会引发 panic。
func (wg *WaitGroup) Wait()

------------------------------------------------------------

// 示例:组等待
func main() {
	wg := sync.WaitGroup{}
	wg.Add(10)
	for i := 0; i < 10; i++ {
		go func(i int) {
			defer wg.Done()
			fmt.Print(i, " ")
		}(i)
	}
	wg.Wait()
}

// 输出结果(不固定):
// 9 3 4 5 6 7 8 0 1 2

------------------------------------------------------------

条件锁

  条件锁通过 Wait 让线程等待,通过 Signal 让一个等待的线程继续,通过 Broadcast 让所有等待的线程继续。

  在 Wait 之前应当手动为 c.L 上锁,Wait 结束后手动解锁。为避免虚假唤醒,需要将 Wait 放到一个条件判断循环中。官方要求的写法如下:

c.L.Lock()
for !condition() {
    c.Wait()
}
// 执行条件满足之后的动作...
c.L.Unlock()

  Cond 在开始使用之后,不能再被复制。

------------------------------------------------------------

type Cond struct {
    L Locker // 在“检查条件”或“更改条件”时 L 应该锁定。
} 

// 创建一个条件锁
func NewCond(l Locker) *Cond

// Broadcast 唤醒所有等待的 Wait,建议在“更改条件”时锁定 c.L,更改完毕再解锁。
func (c *Cond) Broadcast()

// Signal 唤醒一个等待的 Wait,建议在“更改条件”时锁定 c.L,更改完毕再解锁。
func (c *Cond) Signal()

// Wait 会解锁 c.L 并进入等待状态,在被唤醒时,会重新锁定 c.L
func (c *Cond) Wait()

------------------------------------------------------------

// 示例:条件锁
func main() {
	condition := false // 条件不满足
	var mu sync.Mutex
	cond := sync.NewCond(&mu)
	// 让协程去创造条件
	go func() {
		mu.Lock()
		condition = true // 更改条件
		cond.Signal()    // 发送通知:条件已经满足
		mu.Unlock()
	}()
	mu.Lock()
	// 检查条件是否满足,避免虚假通知,同时避免 Signal 提前于 Wait 执行。
	for !condition {
		// 等待条件满足的通知,如果收到虚假通知,则循环继续等待。
		cond.Wait() // 等待时 mu 处于解锁状态,唤醒时重新锁定。
	}
	fmt.Println("条件满足,开始后续动作...")
	mu.Unlock()
}

// 输出结果:
// 条件满足,开始后续动作...

------------------------------------------------------------
时间: 09-27

Golang学习 - sync 包的相关文章

golang的sync包例子

package main import ( "fmt" "sync" ) var wg sync.WaitGroup func asyncTestFunc() { for i := 0; i < 100; i++ { fmt.Println(i) } wg.Done() } func main() { wg.Add(1) go asyncTestFunc() wg.Wait() } golang的sync包例子

Golang学习 - builtin 包

Go builtin包提供了go预先声明的函数.变量等的文档.这些函数变量等的实现其实并不是在builtin包里,只是为了方便文档组织. 这些内置的变量.函数.类型无需引入包即可使用. 默认提供的有: 1.常量: true,false,iota 关于iota,请参考周一的文章"go iota用法" 2.变量 nil 3.函数 func append(slice []Type, elems ...Type) []Type 向slice中添加元素 func cap(v Type) int

Golang学习 - unsafe 包

------------------------------------------------------------ 指针类型: *类型:普通指针,用于传递对象地址,不能进行指针运算. unsafe.Pointer:通用指针类型,用于转换不同类型的指针,不能进行指针运算. uintptr:用于指针运算,GC 不把 uintptr 当指针,uintptr 无法持有对象.uintptr 类型的目标会被回收. unsafe.Pointer 可以和 普通指针 进行相互转换. unsafe.Point

Golang学习 - errors 包

------------------------------------------------------------ Go 语言使用 error 类型来返回函数执行过程中遇到的错误,如果返回的 error 值为 nil,则表示未遇到错误,否则 error 会返回一个字符串,用于说明遇到了什么错误. 其实 error 只是一个接口,定义如下: ------------------------------------------------------------ type error inte

Golang学习 - strconv 包--数据类型转换

// 将布尔值转换为字符串 true 或 false func FormatBool(b bool) string // 将字符串转换为布尔值 // 它接受真值:1, t, T, TRUE, true, True // 它接受假值:0, f, F, FALSE, false, False // 其它任何值都返回一个错误. func ParseBool(str string) (bool, error) ------------------------------ // ErrRange 表示值超

Golang学习 - regexp 包

// 函数 // 判断在 b(s.r)中能否找到 pattern 所匹配的字符串 func Match(pattern string, b []byte) (matched bool, err error) func MatchString(pattern string, s string) (matched bool, err error) func MatchReader(pattern string, r io.RuneReader) (matched bool, err error) /

Golang学习笔记--log包

个人站:http://www.cloudnoter.com/?p=137 一.快速使用 Golang的log包短小精悍,可以非常轻松的实现日志打印转存功能.不用多说,log支持并发操作(即协程安全-相对于JAVA中的线程安全而言),其结构定义如下: type Logger struct { mu sync.Mutex // ensures atomic writes; protects the following fields prefix string // prefix to write a

Golang学习--包管理工具glide

上一篇文章中我们已经成功的运行了go的代码,这是我们迈出的最基础的一步. 一个项目通常会依赖很多外部的库,当依赖的库比较多的时候,手工管理就会比较麻烦,这个时候就需要包管理工具出场了,帮你管理好所有依赖的库. php项目中使用composer,javascript项目中使用npm,那么在go项目中,我们需要使用什么? 包依赖工具的选择 当前go的包管理工具有glide.godep.govendor和gvt等,相关对比的文章可以查看<go依赖包管理工具对比>. 功能对比可以参考如下内容(虽然跟上

【golang学习】环境搭建

近期项目的需要开始了学习golang的旅程,在此将学习的过程做以记录,方便查看,也希望帮助到大家. 由于我使用的是64位linux环境(redhat 5.2),所以这里就介绍64位的安装方式,其他类似: 1. 下载安装包 自从2014年5月谷歌在国内被封杀之后,我们下载go安装包也得翻墙了,但是为了方便我上传了一个64位linux的包在(地址),你可以直接下载使用. 2.安装 下载完上传到你的linux系统中,比如/opt/go1.1.1.linux-amd64.tar.gz,这是就开始安装了,