基于共享变量的并发

竞争条件

竞争条件指的是程序在多个goroutine交叉执行操做时，没有给出正确的结果。竞争条件是很恶劣的一种场景，由于这种问题会一直潜伏在你的程序里，而后在很是少见的时候蹦出来，或许只是会在很大的负载时才会发生，又或许是会在使用了某一个编译器、某一种平台或者某一种架构的时候才会出现。这些使得竞争条件带来的问题很是难以复现并且难以分析诊断。

 

传统上常常用经济损失来为竞争条件作比喻，因此咱们来看一个简单的银行帐户程序。

示例1：一个银行帐户程序

// Package bank implements a bank with only one account.
package bank
var balance int
func Deposit(amount int) { balance = balance + amount }
func Balance() int { return balance }

两个访问者向同一个帐户存钱

// Alice:
go func() {
       bank.Deposit(200)                // A1
       fmt.Println("=", bank.Balance()) // A2
}()

// Bob:
go bank.Deposit(100)                 // B

当Bob的存款会在Alice存款操做中间，在余额被读到(balance + amount)以后，在余额被更新以前(balance = ...)，这样会致使Bob的交易丢失。而这是由于Alice的存款操做A1其实是两个操做的一个序列，读取而后写；能够称之为A1r和A1w。下面是交叉时产生的问题：

Data race
0
A1r      0     ... = balance + amount
B      100
A1w    200     balance = ...
A2  "= 200"

在A1r以后，balance + amount会被计算为200，因此这是A1w会写入的值，并不受其它存款操做的干预。最终的余额是$200。银行的帐户上的资产比Bob实际的资产多了$100。(译注：由于丢失了Bob的存款操做，因此实际上是说Bob的钱丢了).

 

数据竞争 会在两个以上的goroutine并发访问相同的变量且至少其中一个为写操做时发生。 有以下3种方式避免数据竞争：

 第一种方法是不要去写变量，只去读变量。

第二种方法，避免从多个goroutine访问变量。

聊天服务器中的broadcaster goroutine是惟一一个可以访问clients map的goroutine。这些变量都被限定在了一个单独的goroutine中。

因为其它的goroutine不可以直接访问变量，它们只能使用一个channel来发送给指定的goroutine请求来查询更新变量。这也就是Go的口头禅“不要使用共享数据来通讯；使用通讯来共享数据”。一个提供对一个指定的变量经过cahnnel来请求的goroutine叫作这个变量的监控(monitor)goroutine。例如broadcaster goroutine会监控(monitor)clients map的所有访问。

下面是一个重写了的银行的例子，这个例子中balance变量被限制在了monitor goroutine中，名为teller：

// Package bank provides a concurrency-safe bank with one account.
package bank

var deposits = make(chan int) // send amount to deposit
var balances = make(chan int) // receive balance

func Deposit(amount int) { deposits <- amount }
func Balance() int       { return <-balances }

func teller() {
	var balance int // balance is confined to teller goroutine
	for {
		select {
		case amount := <-deposits:
			balance += amount
		case balances <- balance:
		}
	}
}

func init() {
	go teller() // start the monitor goroutine
}

串行绑定

即便当一个变量没法在其整个生命周期内被绑定到一个独立的goroutine，绑定依然是并发问题的一个解决方案。例如在一条流水线上的goroutine之间共享变量是很广泛的行为，在这二者间会经过channel来传输地址信息。若是流水线的每个阶段都可以避免在将变量传送到下一阶段时再去访问它，那么对这个变量的全部访问就是线性的。其效果是变量会被绑定到流水线的一个阶段，传送完以后被绑定到下一个，以此类推。这种规则有时被称为串行绑定。

type Cake struct{ state string }

func baker(cooked chan<- *Cake) {
	for {
		cake := new(Cake)
		cake.state = "cooked"
		cooked <- cake // baker never touches this cake again
	}
}

func icer(iced chan<- *Cake, cooked <-chan *Cake) {
	for cake := range cooked {
		cake.state = "iced"
		iced <- cake // icer never touches this cake again
	}
}

第三种避免数据竞争的方法是容许不少goroutine去访问变量，可是在同一个时刻最多只有一个goroutine在访问。这种方式被称为“互斥”，在下一节来讨论这个主题。