Need to run several func() bool and get the first false

I'm trying to optimize a validation process which runs several functions in a IF statement, so I'm trying to use go's concurrency to solve this, but its not working

I run the following code and tried a lot of different ways to implement channel close and wait groups, but I keep receiving the following error:

fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main.func1(0xc000074f60, 0x3, 0x3, 0xc000024180, 0xc0000241e0)
/home/raphael/projects/go/go-herupaa/main.go:24 +0x9f
main.main()
/home/raphael/projects/go/go-herupaa/main.go:25 +0xcb
goroutine 6 [chan send]:
main.a1(0xc0000241e0)
/home/raphael/projects/go/go-herupaa/main.go:49 +0x72
created by main.main.func1
/home/raphael/projects/go/go-herupaa/main.go:22 +0x71
goroutine 7 [chan send]:
main.a2(0xc0000241e0)
/home/raphael/projects/go/go-herupaa/main.go:56 +0x72
created by main.main.func1
/home/raphael/projects/go/go-herupaa/main.go:22 +0x71
goroutine 8 [chan send]:
main.a3(0xc0000241e0)
/home/raphael/projects/go/go-herupaa/main.go:63 +0x72
created by main.main.func1
/home/raphael/projects/go/go-herupaa/main.go:22 +0x71
exit status 2

package main
import (
"fmt"
"sync"
"time"
)
var wg sync.WaitGroup
func main() {
v := []func(chan<- bool){
a1,
a2,
a3,
}
q := make(chan bool)
c := make(chan bool)
func(c chan bool) {
for _, f := range v {
wg.Add(1)
go f(c)
}
q <- true
}(c)
p := receive(c, q)
fmt.Println(p)
wg.Wait()
}
func receive(c, q chan bool) bool {
for {
select {
case v := <-c:
if !v {
fmt.Println("Received ", v)
return false
}
case <-q:
fmt.Println("Received Exit")
return true
}
}
}
func a1(c chan<- bool) {
defer wg.Done()
time.Sleep(time.Millisecond * 2000)
c <- true
fmt.Println("Finish 1")
}
func a2(c chan<- bool) {
defer wg.Done()
time.Sleep(time.Millisecond * 2000)
c <- true
fmt.Println("Finish 2")
}
func a3(c chan<- bool) {
defer wg.Done()
time.Sleep(time.Millisecond * 2000)
c <- true
fmt.Println("Finish 3")
}

Your first issue is with the q <- true in:

func(c chan bool) {
for _, f := range v {
wg.Add(1)
go f(c)
}
q <- true
}(c)

Enclosing this in a func() block does nothing (I suspect you were running this in a go routine at some point). As written it will start three go routines and then hit q <- true. As nothing is receiving on q this will block.

Once you fix that you will hit the next issue:

p := receive(c, q)
fmt.Println(p)
wg.Wait()

receive grabs something from either v or q; you probably expect this to get three values from v and then one from q but its just as likely (probably more likely) to receive from q before v (and that leads to another deadlock at wg.Wait)..

There are a few ways of addressing this; as mentioned by Peter in the comments you could use buffered channels (e.g. c := make(chan bool, len(v))); sending to a blocked channel will not block unless the channel is full. Alternatively I suspect that what you were intending is something like this (playground):

func main() {
	v := []func(chan<- bool){
		a1,
		a2,
		a3,
	}
	q := make(chan bool)
	c := make(chan bool)

	for _, f := range v {
		wg.Add(1)
		go f(c)
	}
	// When the above go routines have completed send to q
	go func() {
		wg.Wait()
		q <- true
	}()

	p := receive(c, q)
	fmt.Println(p)
}

As Peter points out you do need to cater for the situation where receive receives false on v and exits early. This can be solved by using a buffered channel or you can spin up a go routine that just dumps data received on the channel i.e.:

case v := <-c:
if !v {
fmt.Println("Received ", v)
// Throw away anything else received on v to allow other go routines to complete
go func() { for _ = range v {}}()
return false
}

If you take this approach you need to ensure v is closed eventually; in fact you can use that as the signal to exit which can simplify things considerably:

go func() {
wg.Wait()
close(c)
}()

This removes the need for q completely. Your receive can range over the channel e.g. for v := range c {...).

this adds up on great and detailed answer of Brits.

This example uses context cancellation to skip writes, It always drains c.

The problem in your original code is that you try to exit by stopping the stream from its exit point, you are litterally obstructing it.

As demonstrated in Brits answer it is not the right way to stop processing of the stream because it leaves unmanaged data in the pipe.

The general idea is to stop sending data into the pipe (close the input source of data) when the cancellation signal arrives and let the pipeline finish its job over the on going data by fully draining it.

package main

import (
	"context"
	"fmt"
	"os"
	"os/signal"
	"sync"
	"time"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	go func() {
		s := make(chan os.Signal, 10)
		signal.Notify(s)
		<-s
		cancel()
	}()
	// let us simulate cancellation
	go func() {
		<-time.After(time.Millisecond * 200)
		cancel()
	}()
	v := []func(context.Context, chan<- bool){
		a1,
		a2,
		a3,
	}
	c := make(chan bool)

	var wg sync.WaitGroup
	for _, f := range v {
		wg.Add(1)
		f := f
		go func() {
			f(ctx, c)
			wg.Done()
		}()
	}
	go func() {
		wg.Wait()
		close(c)
	}()

	for v := range c {
		fmt.Println("Received ", v)
	}
}

func a1(ctx context.Context, c chan<- bool) {
	<-time.After(time.Millisecond * 1000)
	select {
	case c <- true:
		fmt.Println("Finish 1")
	case <-ctx.Done():
		fmt.Println("Cancelled 1")
	}
}

func a2(ctx context.Context, c chan<- bool) {
	<-time.After(time.Millisecond * 1000)
	select {
	case c <- true:
		fmt.Println("Finish 2")
	case <-ctx.Done():
		fmt.Println("Cancelled 2")
	}
}

func a3(ctx context.Context, c chan<- bool) {
	<-time.After(time.Millisecond * 1000)
	select {
	case c <- true:
		fmt.Println("Finish 3")
	case <-ctx.Done():
		fmt.Println("Cancelled 3")
	}
}

Finally to answer to the question title Need to run several func() bool and get the first false

You might want to implement stream reduction. capture all values, implement a small logic to close your reduction target asap. but always keep draining it completely.

package main

import (
	"context"
	"fmt"
	"os"
	"os/signal"
	"sync"
	"time"
)

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	go func() {
		s := make(chan os.Signal, 10)
		signal.Notify(s)
		<-s
		cancel()
	}()
	// let us simulate cancellation
	go func() {
		<-time.After(time.Millisecond * 200)
		cancel()
	}()
	v := []func(context.Context, chan<- bool){
		a1,
		a2,
		a3,
	}
	c := make(chan bool)

	var wg sync.WaitGroup
	for _, f := range v {
		wg.Add(1)
		f := f
		go func() {
			f(ctx, c)
			wg.Done()
		}()
	}
	// When the above go routines have completed send to q
	go func() {
		wg.Wait()
		close(c)
	}()

	firstRes := make(chan bool)
	go func() {
		var closed bool
		for v := range c {
			if !v && !closed {
				firstRes <- v
				closed = true
				close(firstRes)
			}
			fmt.Println("Received ", v)
		}
		if !closed {
			close(firstRes)
		}
	}()
	var wasFalsy bool
	for v := range firstRes {
		wasFalsy = !v
	}
	fmt.Println("was falsy ", wasFalsy)
}

func a1(ctx context.Context, c chan<- bool) {
	<-time.After(time.Millisecond * 2000)
	select {
	case c <- !true:
		fmt.Println("Finish 1")
	case <-ctx.Done():
		fmt.Println("Cancelled 1")
	}
}

func a2(ctx context.Context, c chan<- bool) {
	<-time.After(time.Millisecond * 2000)
	select {
	case c <- true:
		fmt.Println("Finish 2")
	case <-ctx.Done():
		fmt.Println("Cancelled 2")
	}
}

func a3(ctx context.Context, c chan<- bool) {
	<-time.After(time.Millisecond * 2000)
	select {
	case c <- true:
		fmt.Println("Finish 3")
	case <-ctx.Done():
		fmt.Println("Cancelled 3")
	}
}