Waiting when no tomb.Go call has been made about tomb HOT 6 CLOSED

Yes, it is intentional. If nothing ever runs there's no way to properly flag the tomb's death. You should also be able to use the Dead and Dying channels instead of Wait for holding out, for instance, and there's no means for us to guess that these channels have to be closed if the tomb is never called.

from tomb.

As a side note, the example provided feels unnecessarily hackish. You can simply do the obvious:

func rmain() error {
        if somethingBad {
                return err
        }
        ...
        obj.tomb.Go(obj.action)
        return obj.tomb.Wait()
}

I also more often organize it as:

func StartFoo() (*Foo, error) {
        ...
        foo.tomb.Go(foo.loop)
        return foo, nil
}

func (foo *Foo) Stop() error {
        foo.tomb.Kill(nil)
        return foo.tomb.Wait()
}

from tomb.

Ok, thanks!

The reason I wanted to do it is because I have code between the Go call and the Wait call, like this:

        obj.tomb.Go(obj.action)

        if err := ...; err != nil {
            // return err // whoops, no waiting, can't do this
            obj.tomb.Kill(err) // at least we'll wait, but it's also going to execute functions it shouldn't
        }

        if err := ...; err != nil {
            // ...
        }

        return obj.tomb.Wait()

from tomb.

There are two easy ways to solve the problem:

1. Do not call Go while you're not ready to spawn a new goroutine
2. Move the logic that can fail to within the goroutine

Both sound like good advices despite the specific issue being discussed.

from tomb.

Do not call Go while you're not ready to spawn a new goroutine

It's not that I'm not ready, in fact it's better if the goroutine already started before I run my other functions.

Move the logic that can fail to within the goroutine

Unfortunately, they need to run concurrently to the goroutine. Or are you saying I should run an unmonitored goroutine within the Go-routine?

from tomb.

You can run as many things concurrently as desired by just firing more monitored goroutines from any goroutine already being monitored. For example:

func StartFoo() (*Foo, error) {
        ...
        foo.tomb.Go(foo.loop)
        return foo, nil
}

func (foo *Foo) Stop() error {
        foo.tomb.Kill(nil)
        return foo.tomb.Wait()
}

func (foo *Foo) loop() error {
        foo.tomb.Go(foo.task1)
        foo.tomb.Go(foo.task2)
        ...
}

from tomb.