CODEWITHSUNDEEP
go
dangerChihuahua007
dangerChihuahua007

Reputation: 20915

How do I catch the exception of a channel deadlocking?

I am learning Go and am working on this lesson from the GoTours. Here's what I have so far.

package main

import (
    "fmt"
    "code.google.com/p/go-tour/tree"
)

// Walk walks the tree t sending all values
// from the tree to the channel ch.
func Walk(t *tree.Tree, ch chan int) {
    if t != nil {
        Walk(t.Left, ch)
        ch <- t.Value
        Walk(t.Right, ch)
    }
}

func main() {
    var ch chan int = make(chan int)
    go Walk(tree.New(1), ch)
    for c := range ch {
        fmt.Printf("%d ", c)    
    }
}

As you see, I try to test out my Walk function by printing out the values I wrote into a channel. However, I get the following error.

1 2 3 4 5 6 7 8 9 10 throw: all goroutines are asleep - deadlock!

goroutine 1 [chan receive]:
main.main()
    main.go:25 +0x85

goroutine 2 [syscall]:
created by runtime.main
    /usr/local/go/src/pkg/runtime/proc.c:221

exit status 2

This error should be expected I think because I never close the channel. However, is there a way I could "catch" this deadlock error and deal with it programmatically?

Upvotes: 7

Views: 1741

Answers (5)

Ashfaq Ur Rahman N
Ashfaq Ur Rahman N

Reputation: 322

I came up with this solution, It basically uses 2 channels and concludes the trees are same if both the channels are closed.

package main

import "golang.org/x/tour/tree"
import "fmt"

// Walk walks the tree t sending all values
// from the tree to the channel ch.
func Walk(t *tree.Tree, ch chan int) {
    if t == nil {
        return
    }
    Walk(t.Left, ch)
    ch <- t.Value
    Walk(t.Right, ch)
}

// Same determines whether the trees
// t1 and t2 contain the same values.
func Same(t1, t2 *tree.Tree) bool {
    tc1 := make(chan int)
    tc2 := make(chan int)

    go func() {
        Walk(t1, tc1)
        close(tc1)
    }()
    go func() { 
       Walk(t2, tc2)
       close(tc2)
    }()

    for {
        x1, y1 := <-tc1;
        x2, y2 := <-tc2;
        if  x1 != x2  {
            return false
        }
        if !y1 || !y2 {
            return true
        }
    }
}


func main() {
    t1, t2 := tree.New(123), tree.New(1)
    fmt.Println(Same(t1, t2))
}

I'm following go-tour guide and only used resources taught so far (Unlike using sync package in the above solution.)

Upvotes: 0

Lin Du
Lin Du

Reputation: 102507

The channel deadlock error is:

fatal error: all goroutines are asleep - deadlock!

channel deadlock is not a panic error, it's a fatal error, see https://golang.org/pkg/log/#Fatal

Fatal is equivalent to Print() followed by a call to os.Exit(1).

As you can see, Fatal will call os.Exit(1) at last, so it's totally different with panic, and that's why it can't be recover

Upvotes: 0

voidlogic
voidlogic

Reputation: 6826

Deadlock is similar to a nil pointer deference in that is represents a BUG in your program. This class of error is usually not recoverable for this reason.

As lbonn mentioned, the problem here is you need to "close(myChan)" your channel. If you do not do this the for-range loop, that the loop will wait for the next element forever.

You can try something like this:

func main() {
    var ch chan int = make(chan int)
    go func() {
        Walk(tree.New(1), ch)
        close(ch)
    }()
    for c := range ch {
        fmt.Printf("%d ", c)
    }
}

If you want to traverse the tree in parallel you will need to make further changes:

package main

import (
    "code.google.com/p/go-tour/tree"
    "fmt"
    "sync"
)

// Walk walks the tree t sending all values
// from the tree to the channel ch.
func Walk(t *tree.Tree, ch chan int, done *sync.WaitGroup) {
    if t != nil {
        done.Add(2)
        go Walk(t.Left, ch, done) //look at each branch in parallel
        go Walk(t.Right, ch, done)
        ch <- t.Value
    }
    done.Done()
}

func main() {
    var ch chan int = make(chan int, 64) //note the buffer size
    go func() {
        done := new(sync.WaitGroup)
        done.Add(1)
        Walk(tree.New(1), ch, done)
        done.Wait()
        close(ch)
    }()
    for c := range ch {
        fmt.Printf("%d ", c)
    }
}

Upvotes: 8

lbonn
lbonn

Reputation: 2599

This deadlocks because, the range construct iterates until the channel is closed. http://golang.org/ref/spec#For_statements

Here, you need to either close the channel when the tree is fully explored or use another construct.

For this example, you know that the trees are of size 10, so you can simply do a for loop from 1 to 10 and read from the channel once at each iteration.

Upvotes: 8

zzzz
zzzz

Reputation: 91369

No, you cannot recover from a deadlock.

Upvotes: 6

Related Questions