Go routine blocks another go routine

I have two go rutines that are working with the same function, but with different params. When I run the program it runs well, but only 1 rutine was working, and the other was dead/sleeping for some reason.
I used mutex for block the read/write. I used two mutex:

• mutexSearch: To use in busquedaBid function
• mutexCompare: To use in checkEqualityValues function

When one rutine take the lock and reach the unlock it never releases the code block causing the other routine to never work.

This is what I tried:

package main
import (
"fmt"
"math"
"math/rand"
"sort"
"sync"
"time"
)
var mutexCompare sync.Mutex
type Cola struct {
tomarLista         int
contadorSoluciones int
cola               [][]int
}
func main() {
in := time.Now()
puzzleInicial := []int{1,2,3,4,5,6,7,8,0}
grafo := make(map[int][]int)
grafo[0] = []int{1, 3}
grafo[1] = []int{0, 2, 4}
grafo[2] = []int{1, 5}
grafo[3] = []int{0, 4, 6}
grafo[4] = []int{1, 3, 5, 7}
grafo[5] = []int{2, 4, 8}
grafo[6] = []int{3, 7}
grafo[7] = []int{4, 6, 8}
grafo[8] = []int{5, 7}
puzzleFinal := []int{1, 3, 6, 5, 2, 0, 4, 7, 8}
colaInicial := [][]int{}
colaFinal := [][]int{}
colaInicial = append(colaInicial, puzzleInicial)
colaFinal = append(colaFinal, puzzleFinal)
tomarListaInicial := 0
contadorSolucionesInicial := 0
mutexSearch := &sync.Mutex{}
done := make(chan bool)
colaI := Cola{tomarListaInicial, contadorSolucionesInicial, colaInicial}
colaF := Cola{tomarListaInicial, contadorSolucionesInicial, colaFinal}
go busquedaBid(&colaI, &colaF, grafo, mutexSearch, done)
go busquedaBid(&colaF, &colaI, grafo, mutexSearch, done)
<-done
f := time.Since(in)
fmt.Println(f)
}
func busquedaBid(colaActual *Cola, colaCheck *Cola, grafo map[int][]int, mut *sync.Mutex,
done chan bool) {
for {
mut.Lock()
nodo := getIndex(colaActual.cola[colaActual.tomarLista])
for _, neighbour := range grafo[nodo] {
sliceAux := append([]int(nil), colaActual.cola[colaActual.tomarLista]...)
valorAux := sliceAux[neighbour]
indCero := getIndex(sliceAux)
sliceAux[neighbour] = 0
sliceAux[indCero] = valorAux
if !checkRepetitionsSlices(colaActual.cola, sliceAux) {
colaActual.cola = append(colaActual.cola, sliceAux)
}
}
colaActual.tomarLista += 1
mut.Unlock()
if checkEqualityValues(colaActual.cola, colaCheck.cola, done) {
break
}
}
}
func checkEqualityValues(cola_inicial [][]int, cola_final [][]int, done chan bool) bool {
mutexCompare.Lock()
for _, item1 := range cola_inicial {
for _, item2 := range cola_final {
if checkRepetitionsSliceSlice(item1, item2) {
fmt.Println(len(cola_inicial), len(cola_final))
close(done)
return true
}
}
}
mutexCompare.Unlock()
return false
}

For example this is an output:
115 1

That output says to me that only one rutine was worked, because the other one didn't put any slice in the queue (the queue it's a slice of slices)

Sorry if a maked a bigmistake, I'm new and I'm learning go

I think I solve the problem. I made a for loop that contains 3 goroutines:

• Two for the function "busquedaBid" (this function make a type of bidirectional search)
• One for "checkEqualityValues" (this function determines if two slices are equals)

Adittionally I used sync.WaitGroup and I puted the wg.Done() sentence in functions, that solve the block problem between routines.

(I don't know if this solution is in a go way)

package main
import (
"fmt"
"math"
"math/rand"
"sort"
"sync"
"time"
)
var mutexCompare sync.Mutex
var flag bool = false
type Cola struct {
tomarLista         int
contadorSoluciones int
cola               [][]int
}
func main() {
in := time.Now()
puzzleInicial := []int{1,2,3,4,5,6,7,8,0}
grafo := make(map[int][]int)
grafo[0] = []int{1, 3}
grafo[1] = []int{0, 2, 4}
grafo[2] = []int{1, 5}
grafo[3] = []int{0, 4, 6}
grafo[4] = []int{1, 3, 5, 7}
grafo[5] = []int{2, 4, 8}
grafo[6] = []int{3, 7}
grafo[7] = []int{4, 6, 8}
grafo[8] = []int{5, 7}
puzzleFinal := []int{1, 3, 6, 5, 2, 0, 4, 7, 8}
colaInicial := [][]int{}
colaFinal := [][]int{}
colaInicial = append(colaInicial, puzzleInicial)
colaFinal = append(colaFinal, puzzleFinal)
mutexSearch := &sync.Mutex{}
colaI := Cola{0, 0, colaInicial}
colaF := Cola{0, 0, colaFinal}
mutexSearch := &sync.Mutex{}
wg := &sync.WaitGroup{}
for {
if flag {
return
}
wg.Add(3)
go busquedaBid(&colaF, &colaI, grafo, mutexSearch, wg)
go busquedaBid(&colaI, &colaF, grafo, mutexSearch, wg)
go checkEqualityValues(colaI.cola, colaF.cola, wg)
wg.Wait()
}
}
func busquedaBid(colaActual *Cola, colaCheck *Cola, grafo map[int][]int, mut *sync.Mutex, wg *sync.WaitGroup) {
mut.Lock()
nodo := getIndex(colaActual.cola[colaActual.tomarLista])
for _, neighbour := range grafo[nodo] {
sliceAux := append([]int(nil), colaActual.cola[colaActual.tomarLista]...)
sliceAux[getIndex(sliceAux)] = sliceAux[neighbour]
sliceAux[neighbour] = 0
if checkRepetitionsMapSlice(colaActual.cola, sliceAux) == false {
colaActual.cola = append(colaActual.cola, sliceAux)
}
}
colaActual.tomarLista += 1
mut.Unlock()
wg.Done()
}
func checkEqualityValues(cola_inicial [][]int, cola_final [][]int, wg *sync.WaitGroup) {
mutexCompare.Lock()
for _, item1 := range cola_inicial {
for _, item2 := range cola_final {
if checkRepetitionsSliceSlice(item1, item2) {
flag = true
fmt.Println(runtime.NumGoroutine())
mutexCompare.Unlock()
wg.Done()
}
}
}
mutexCompare.Unlock()
wg.Done()
}