WaitGroup在之前的等待已返回之前被重用

因此，我將進一步使用golang並深入研究它提供的併發性。我決定嘗試使用go例程來實現電話號碼中字符串的排列。WaitGroup在之前的等待已返回之前被重用

我遇到了使用sync.WaitGroup協調我一直在使用的例程的問題。特定錯誤的存在：

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（）或rathe等待組等待函數期間調用該行。我試圖複製一個較小的程序，但不能。我的假設是一旦它在調用go例程之後到達Wait（），我們就不能再編輯等待組了，但這聽起來不對。任何洞察爲什麼會發生的事情將是有益的

回購做參考，可以發現：https://github.com/sbiscigl/phonenumberperm

來源

2016-09-30 scigs

在你的遞歸情況下ThreadSafeCalcWords，調用wg.Add之前你打電話wg.Done。這意味着在你完成所有工作之前，wg可以下降到0（這將觸發Wait完成）。再次調用Add，而Wait仍處於解析過程中會觸發錯誤，但更重要的是，它可能只是簡單的不是你想要的。

更改操作順序，使您始終在做Done之前的任何新工作，並且Wait不會過早觸發。完成此操作的最簡單方法可能是在函數底部調用wg.Done()，或頂部調用一個defer，然後刪除所有其他調用。

來源

2016-09-30 22:09:31 hobbs

WaitGroup在之前的等待已返回之前被重用

回答

相關問題