一、使用goroutine来运行程序

1.Go的并发与并行

• 管理被创建的所有goroutine，为其分配执行时间
• 将操作系统线程与语言运行时的逻辑处理器绑定

• M：操作系统线程，这是真正的内核OS线程
• P：逻辑处理器，代表着调度的上下文，它使goroutine在一个M上跑
• G：goroutine，拥有自己的栈，指令指针等信息，被P调度

2.创建goroutine

二、处理竞争状态

• 使用原子函数操作
• 使用互斥锁锁住临界区
• 使用通道chan

1. 检测竞争状态

有时候竞争状态并不能一眼就看出来。Go 提供了一个非常有用的工具，用于检测竞争状态。使用方式是：

go build -race example4.go//用竞争检测器标志来编译程序




./example4 //运行程序


工具检测出了程序存在一处竞争状态，并指出发生竞争状态的几行代码是：
22
counter=value

18
value := counter

28
go addCount()

29
go addCount()

2. 使用原子函数

对整形变量或指针的同步访问，可以使用原子函数来进行。这里使用原子函数来修复example4.go中的竞争状态问题：
//example5.go

package main


import
(

"sync"
"runtime"
"fmt"
"sync/atomic"

)


var
(

//counter为访问的资源

counter int64


wg sync.
WaitGroup

)


funcaddCount
() {

defer
wg.
Done
()

for
count :
=0
; count
<2
; count
++
{

//使用原子操作来进行

atomic.
AddInt64
(
&
counter,
1
)

//当前goroutine从线程退出

runtime.
Gosched
()


}


}


funcmain
() {


wg.
Add
(
2
)


go addCount()


go addCount()


wg.
Wait
()


fmt.
Printf
(
"counter: %d\n"
,counter)


}

//output：

counter:
4
这里使用atomic.AddInt64函数来对一个整形数据进行加操作，另外一些有用的原子操作还有：
atomic.
StoreInt64
()
//写

atomic.
LoadInt64
()
//读
更多的原子操作函数请看atomic包中的声明。

3. 使用互斥锁

对临界区的访问，可以使用互斥锁来进行。对于example4.go的竞争状态，可以使用互斥锁来解决：
//example5.go

package main


import
(

"sync"
"runtime"
"fmt"

)


var
(

//counter为访问的资源

counter int


wg sync.
WaitGroup

mutex sync.
Mutex

)


funcaddCount
() {

defer
wg.
Done
()


for
count :
=0
; count
<2
; count
++
{

//加上锁，进入临界区域

mutex.
Lock
()


{


value :
=
counter

//当前goroutine从线程退出

runtime.
Gosched
()


value
++

counter
=
value


}

//离开临界区，释放互斥锁

mutex.
Unlock
()


}


}

funcmain
() {


wg.
Add
(
2
)


go addCount()


go addCount()


wg.
Wait
()


fmt.
Printf
(
"counter: %d\n"
, counter)


}


//output:

counter:
4
使用Lock()与Unlock()函数调用来定义临界区，在同一个时刻内，只有一个goroutine能够进入临界区，直到调用Unlock()函数后，其他的goroutine才能够进入临界区。
在Go中解决共享资源安全访问，更常用的使用通道chan。
回到顶部

三、利用通道共享数据

Go语言采用CSP消息传递模型。通过在goroutine之间传递数据来传递消息，而不是对数据进行加锁来实现同步访问。这里就需要用到通道chan这种特殊的数据类型。当一个资源需要在goroutine中共享时，chan在goroutine中间架起了一个通道。通道使用make来创建：
unbuffered :=
make
(char
int
)
//创建无缓存通道，用于int类型数据共享

buffered :=
make
(
chanstring
,
10
)
//创建有缓存通道，用于string类型数据共享

buffered<-
"hello world"//向通道中写入数据

value:= <-buffered
//从通道buffered中接受数据
通道用于放置某一种类型的数据。创建通道时指定通道的大小，将创建有缓存的通道。无缓存通道是一种同步通信机制，它要求发送goroutine和接收goroutine都应该准备好，否则会进入阻塞。

1. 无缓存的通道

无缓存通道是同步的——一个goroutine向channel写入消息的操作会一直阻塞，直到另一个goroutine从通道中读取消息。反过来也是，一个goroutine从channel读取消息的操作会一直阻塞，直到另一个goroutine向通道中写入消息。《Go in action》中关于无缓存通道的解释有一个非常棒的例子：网球比赛。在网球比赛中，两位选手总是处在以下两种状态之一：要么在等待接球，要么在把球打向对方。球的传递可看为通道中数据传递。下面这段代码使用通道模拟了这个过程：
//example6.go
package
main


import
(

"sync"
"fmt"
"math/rand"
"time"

)


var
wg sync.WaitGroup


funcplayer
(name
string
, court
chanint
) {

defer
wg.Done()

for
{

//如果通道关闭,那么选手胜利

ball, ok := <-court

if
!ok {


fmt.Printf(
"Player %s Won\n"
, name)

return

}


n := rand.Intn(
100
)


//随机概率使某个选手Miss
if
n%
13
==
0
{


fmt.Printf(
"Player %s Missed\n"
, name)

//关闭通道
close
(court)

return

}


fmt.Printf(
"Player %s Hit %d\n"
, name, ball)


ball++

//否则选手进行击球

court <- ball


}


}



funcmain
() {


rand.Seed(time.Now().Unix())


court :=
make
(
chanint
)

//等待两个goroutine都执行完

wg.Add(
2
)

//选手1等待接球
go
player(
"candy"
, court)

//选手2等待接球
go
player(
"luffic"
, court)

//球进入球场（可以开始比赛了）

court <-
1

wg.Wait()


}

//output:

Player luffic Hit
1

Player candy Hit
2

Player luffic Hit
3

Player candy Hit
4

Player luffic Hit
5

Player candy Missed


Player luffic Won

2. 有缓存的通道

有缓存的通道是一种在被接收前能存储一个或者多个值的通道，它与无缓存通道的区别在于：无缓存的通道保证进行发送和接收的goroutine会在同一时间进行数据交换，有缓存的通道没有这种保证。有缓存通道让goroutine阻塞的条件为：通道中没有数据可读的时候，接收动作会被阻塞；通道中没有区域容纳更多数据时，发送动作阻塞。向已经关闭的通道中发送数据，会引发panic，但是goroutine依旧能从通道中接收数据，但是不能再向通道里发送数据。所以，发送端应该负责把通道关闭，而不是由接收端来关闭通道。
回到顶部

小结

• goroutine被逻辑处理器执行，逻辑处理器拥有独立的系统线程与运行队列
• 多个goroutine在一个逻辑处理器上可以并发执行，当机器有多个物理核心时，可通过多个逻辑处理器来并行执行。
• 使用关键字 go 来创建goroutine。
• 在Go中，竞争状态出现在多个goroutine试图同时去访问一个资源时。
• 可以使用互斥锁或者原子函数，去防止竞争状态的出现。
• 在go中，更好的解决竞争状态的方法是使用通道来共享数据。
• 无缓冲通道是同步的，而有缓冲通道不是。