panic: sync: negative WaitGroup counter

最新推荐文章于 2022-07-13 17:02:02 发布

pardon110

最新推荐文章于 2022-07-13 17:02:02 发布

阅读量4.7k

点赞数 1

分类专栏： Golang 探究 bugLog

本文链接：https://blog.csdn.net/u011584949/article/details/106121077

版权

Golang 探究同时被 2 个专栏收录

45 篇文章

订阅专栏

bugLog

40 篇文章

订阅专栏

本文深入分析了Go语言中并发问题的一个典型案例——无限循环抽烟问题，通过剖析WaitGroup的不当使用导致的运行时错误，揭示了goroutine间的同步与阻塞问题，并提出了解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

问题

先看报错信息

Table: 0 grass: 0 match: 0
Apple smokes a cigarette
Table chooses paper: Sandy
Table: 0 grass: 1 match: 1
Table: 0 grass: 1 match: 0
Table: 0 grass: 0 match: 0
Sandy smokes a cigarette
panic: sync: negative WaitGroup counter

goroutine 6 [running]:
sync.(*WaitGroup).Add(0xc0000140c0, 0xffffffffffffffff)
        D:/Program Files/Go1136/src/sync/waitgroup.go:74 +0x140
sync.(*WaitGroup).Done(...)
        D:/Program Files/Go1136/src/sync/waitgroup.go:99
main.smoker(0xc0000044c0, 0x4d8bb5, 0x5, 0x0, 0xc0000341c0)
        d:/code-base/gomod/gott/main.go:84 +0x668
created by main.main
        d:/code-base/gomod/gott/main.go:102 +0x1de
exit status 2

D:\code-base\gomod\gott>

分析

刚开始的时候，下意识的认为是 WaitGroup 使用不当。还查阅了地址stackoverflow
但实际上的代码表现出来是前半段正常，然后突然不正常，感觉就像多减了一次

无限循环抽烟问题

下面是循环模拟抽烟问题

package main

import (
	"math/rand"
	"fmt"
	"sync"
	"time"
)

const (
	paper = iota
	grass
	match
)

var smokeMap = map[int]string{
	paper:"paper",
	grass:"grass",
	match:"match",
}

var names = map[int]string{
	paper:"Sandy",
	grass:"Apple",
	match:"Daisy",
}

type Table struct {
	paper chan int
	grass chan int
	match chan int
}

func arbitrate(t *Table, smokers [3]chan int){
	for {
		time.Sleep(time.Microsecond*500)
		next := rand.Intn(3)
		fmt.Printf("Table chooses %s: %s\n", smokeMap[next],names[next])

		switch next {
		case paper:
			t.grass <- 1
			t.match <- 1
		case grass:
			t.paper <- 1
			t.match <- 1
		case match:
			t.grass <- 1
			t.paper <- 1
		}
		for _, smoker := range smokers {
			smoker <- next
		}
		wg.Add(1)
		wg.Wait()
	}
}

func smoker(t *Table, name string, smokes int, signal chan int){
	var chosen = -1
	for{
		chosen = <-signal // 阻塞
		if smokes != chosen {
			continue
		}

		fmt.Printf("Table: %d grass: %d match: %d\n", len(t.paper),len(t.grass), len(t.match))
		select{
		case <- t.paper:
		case <- t.grass:
		case <- t.match:
		}
		fmt.Printf("Table: %d grass: %d match: %d\n", len(t.paper), len(t.grass), len(t.match))
		time.Sleep(10 * time.Millisecond)
		select {
		case <-t.paper:
		case <-t.grass:
		case <-t.match:
		}
		fmt.Printf("Table: %d grass: %d match: %d\n", len(t.paper), len(t.grass), len(t.match))
		fmt.Printf("%s smokes a cigarette\n", name)
		time.Sleep(time.Microsecond *500)
		// 此处需要确保wg.Add在wg.Done之前执行
		wg.Done()
		time.Sleep(time.Millisecond *100)
	}
}

const LIMIT = 1
var wg *sync.WaitGroup

func main() {
	wg = new(sync.WaitGroup)	
	table := new(Table)
	table.match = make(chan int, LIMIT)
	table.paper = make(chan int, LIMIT)
	table.grass = make(chan int, LIMIT)
	var signals [3] chan int
	for i := 0; i < 3; i++ {
		signal := make(chan int , 1)
		signals[i] = signal
		go smoker(table,names[i], i, signal)
	}
	fmt.Printf("%s, %s, %s, sit with \n%s, %s, %s\n\n", names[0], names[1], names[2], smokeMap[0], smokeMap[1], smokeMap[2])

	// 裁决谁在抽烟
	arbitrate(table, signals)
	
}

正常情况下，应该表现如下无限循环

D:\code-base\gomod\gott>go run "d:\code-base\gomod\gott\main.go"
Sandy, Apple, Daisy, sit with
paper, grass, match

Table chooses match: Daisy
Table: 1 grass: 1 match: 0
Table: 1 grass: 0 match: 0
Table: 0 grass: 0 match: 0
Daisy smokes a cigarette
Table chooses paper: Sandy
Table: 0 grass: 1 match: 1
Table: 0 grass: 1 match: 0
Table: 0 grass: 0 match: 0
Sandy smokes a cigarette
Table chooses match: Daisy
Table: 1 grass: 1 match: 0