像這樣在一段時間后停止 gouroutine 是否并發(fā)安全？代碼：（注意：由于另一個 goroutine 的變化導致數(shù)據(jù)競爭）：okpackage mainimport ( "fmt" "time")func main() { var ok byte time.AfterFunc(1000*time.Millisecond, func() { ok = 1 }) var i uint64 for ok == 0 { i++ // CPU intensive task } fmt.Println(i) // 2_776_813_033}終端：go run -race .==================WARNING: DATA RACEWrite at 0x00c000132010 by goroutine 8: main.main.func1() ./main.go:11 +0x46Previous read at 0x00c000132010 by main goroutine: main.main() ./main.go:15 +0xf4Goroutine 8 (running) created at: time.goFunc() go/src/time/sleep.go:180 +0x51==================80849692Found 1 data race(s)代碼（無數(shù)據(jù)競爭）：package mainimport ( "fmt" "sync/atomic" "time")func main() { var ok int32 time.AfterFunc(1000*time.Millisecond, func() { atomic.StoreInt32(&ok, 1) }) var i uint64 for atomic.LoadInt32(&ok) == 0 { i++ // CPU intensive task } fmt.Println(i) // 2_835_935_488}終端：go run -race .31934042
2 回答
墨色風雨
TA貢獻1853條經(jīng)驗 獲得超6個贊
即使被另一個 goroutineok設(shè)置為，也不能保證忙等待循環(huán)將終止。false在設(shè)置和讀取 的過程中沒有顯式同步ok，因此不能保證主 goroutine 看到對其所做的更改。換句話說，沒有辦法在兩個 goroutine 之間建立發(fā)生前的關(guān)系。
代碼的第二個版本是安全的，即使在 Go 內(nèi)存模型中ok沒有關(guān)于 . 原子讀/寫具有發(fā)生之前關(guān)系所必需的內(nèi)存屏障。您應(yīng)該使用同步原語之一（互斥體、通道）來保證這一點。
月關(guān)寶盒
TA貢獻1772條經(jīng)驗 獲得超5個贊
Go 內(nèi)存模型：
建議
修改多個 goroutine 同時訪問的數(shù)據(jù)的程序必須序列化這種訪問。
要序列化訪問，請使用通道操作或其他同步原語（例如同步和同步/原子包中的同步原語）保護數(shù)據(jù)。
對于第一個代碼，您應(yīng)該使用適當?shù)耐?，例如?/p>
“上下文”、“同步/原子” sync.Mutex、或通道。
去1.14
Goroutines 現(xiàn)在是異步可搶占的。因此，沒有函數(shù)調(diào)用的循環(huán)不再可能使調(diào)度程序死鎖或顯著延遲垃圾收集。這在除 windows/arm、darwin/arm、js/wasm 和 plan9/* 之外的所有平臺上都受支持。
一段時間后停止 gouroutine
BenchmarkAfterFunc-8 1000000000 0.4468 ns/op 0 B/op 0 allocs/op
BenchmarkDoneChannel-8 121966824 9.855 ns/op 0 B/op 0 allocs/op
BenchmarkTimeSince-8 89790115 12.95 ns/op 0 B/op 0 allocs/op
BenchmarkContextErr-8 58508900 19.78 ns/op 0 B/op 0 allocs/op
BenchmarkAfterFuncMutex-8 58323207 20.00 ns/op 0 B/op 0 allocs/op
BenchmarkContext-8 48947625 27.43 ns/op 0 B/op 0 allocs/op
測試：
package main
import (
"context"
"sync"
"sync/atomic"
"testing"
"time"
)
const d = 200 * time.Millisecond // To stop a task after a period of time
func BenchmarkTimeSince(b *testing.B) {
t0 := time.Now()
var count = 0
for i := 0; i < b.N; i++ {
if time.Since(t0) < d {
count++
}
}
_ = count
}
func BenchmarkContext(b *testing.B) {
var ctx, cancel = context.WithTimeout(context.Background(), d)
defer cancel()
var count = 0
for i := 0; i < b.N; i++ {
select {
case <-ctx.Done():
// break
default:
count++
}
}
_ = count
}
func BenchmarkContextErr(b *testing.B) {
var ctx, cancel = context.WithTimeout(context.Background(), d)
defer cancel()
var count = 0
for i := 0; i < b.N; i++ {
if ctx.Err() == nil {
count++
}
}
_ = count
}
func BenchmarkAfterFunc(b *testing.B) {
var done uint32
time.AfterFunc(d, func() { atomic.StoreUint32(&done, 1) })
var count = 0
for i := 0; i < b.N; i++ {
if atomic.LoadUint32(&done) == 0 {
count++
}
}
_ = count
}
func BenchmarkDoneChannel(b *testing.B) {
var done = make(chan struct{})
time.AfterFunc(d, func() { close(done) })
var count = 0
for i := 0; i < b.N; i++ {
select {
case <-done:
// break
default:
count++
}
}
_ = count
}
type foo struct {
sync.Mutex
state bool
}
func (p *foo) end() {
p.Lock()
p.state = true
p.Unlock()
}
func (p *foo) isDone() bool {
var b bool
p.Lock()
b = p.state
p.Unlock()
return b
}
func BenchmarkAfterFuncMutex(b *testing.B) {
var it = foo{}
time.AfterFunc(d, func() { it.end() })
var count = 0
for i := 0; i < b.N; i++ {
if it.isDone() {
count++
}
}
_ = count
}
https://medium.com/a-journey-with-go/go-asynchronous-preemption-b5194227371c
搶占是調(diào)度器的重要組成部分，它可以在 goroutine 之間分配運行時間。事實上，如果沒有搶占，一個長時間運行的占用 CPU 的 goroutine 會阻止其他 goroutine 被調(diào)度。1.14 版本引入了一種異步搶占的新技術(shù)，為調(diào)度程序提供了更多的權(quán)力和控制權(quán)。
- 2 回答
- 0 關(guān)注
- 181 瀏覽
添加回答
舉報
0/150
提交
取消