Question

因此，我正在进一步使用golang并更多地了解它提供的并发性。我决定尝试使用go例程来实现电话号码中字符串的排列。

我遇到了使用sync.WaitGroup协调我一直使用的go例程的问题。具体错误是：

WaitGroup is reused before previous Wait has returned

代码是：

main.go

package main

import (
    "fmt"
    "sync"

    "github.com/sbiscigl/phonenumberperm/intstack"
    "github.com/sbiscigl/phonenumberperm/permutations"
)

var wg sync.WaitGroup

func main() {
    num := []int{2, 7, 1, 4, 5, 5, 2}    
    stack := intstack.New(num)
    permutationChannel := make(chan string)
    wg.Add(1)
    go permutations.ThreadSafeCalcWords(stack, "", permutationChannel, &wg)
    wg.Wait()
    /*Then consume, but not implimented*/
}

排列/ perm.go

package permutations

import (
    "fmt"
    "sync"

    "github.com/sbiscigl/phonenumberperm/intstack"
)

var letterMap = map[int][]string{
    2: []string{"a", "b", "c"},
    3: []string{"d", "e", "f"},
    4: []string{"g", "h", "i"},
    5: []string{"j", "k", "l"},
    6: []string{"m", "n", "o"},
    7: []string{"p", "q", "r", "s"},
    8: []string{"t", "u", "v"},
    9: []string{"w", "x", "y", "z"},
}

func ThreadSafeCalcWords(s intstack.IntStack, word string, ch chan<- string,
    wg *sync.WaitGroup) {
    if s.IsEmpty() {
        ch <- fmt.Sprint(word)
        wg.Done()
    } else {
        /*Check to see if the values are 1 or zero as they*/
        /*have no letters associated with them*/
        if s.Peek() == 1 || s.Peek() == 0 {
            wg.Done()
            s.Pop()
            wg.Add(1)
            go ThreadSafeCalcWords(s, word, ch, wg)
        } else {
            wg.Done()
            for _, letter := range letterMap[s.Pop()] {
                wg.Add(1)
                go ThreadSafeCalcWords(s, word+letter, ch, wg)
            }
        }
    }
}

intstack / intstack.go

package intstack

import "fmt"

const (
    maxSize = 100
)

/*IntStack implimentaiton of a stack for integers*/
type IntStack struct {
    valueList []int
    maxSize   int
}

/*New returns bew instace of IntStack*/
func New(nums []int) IntStack {
    return IntStack{
        valueList: nums,
        maxSize:   maxSize,
    }
}

/*Pop pops the top value off the stack*/
func (s *IntStack) Pop() int {
    var val int
    if !s.IsEmpty() {
        val = s.valueList[0]
        s.valueList = s.valueList[1:]
    } else {
        fmt.Println("stack is empty")
    }
    return val
}

/*Peek returns top value*/
func (s IntStack) Peek() int {
    return s.valueList[0]
}

/*IsEmpty checks if the stack is empty*/
func (s IntStack) IsEmpty() bool {
    if len(s.valueList) > 0 {
        return false
    }
    return true
}

/*Print prints out the contents of the stack*/
func (s IntStack) Print() {
    for _, element := range s.valueList {
        fmt.Print(element)
    }
    fmt.Print("\n")
}

所以经过研究，在wg.Wait（）或者等待组等待函数期间调用该行。我尝试用较小的程序复制，但不能。我的假设是，一旦它在调用go例程后到达Wait（），我们就不能再编辑等待组，但这听起来是错误的。任何有关为什么会发生这种情况的见解都会有所帮助

repo for refrence可在以下网址找到：https://github.com/sbiscigl/phonenumberperm

Answer 1

在ThreadSafeCalcWords的递归案例中，您在调用wg.Done之前调用了wg.Add 。这意味着在您完成所有工作之前，wg可以下降到0（这将触发Wait完成）。在Add仍处于解决过程中再次调用Wait是触发错误的原因，但更重要的是，它可能只是简单的不是你想要的。

更改操作顺序，以便在对现有工作执行Add之前始终Done任何新工作，并且Wait不会过早触发。完成此操作的最简单方法可能是在函数底部单个调用wg.Done()，或在顶部调用单个defer，并删除所有其他内容。

在上一次Wait返回之前重新使用WaitGroup

1 个答案: