Checking simultaneous connection of channels
I would like to know if the go language allows you to check for the existence of multiple channels at the same time .
Here's a somewhat contrived example of what I'm trying to do. (The actual reason is to see if I can implement petrinets natively in go)
package main
import "fmt"
func mynet(a, b, c, d <-chan int, res chan<- int) {
for {
select {
case v1, v2 := <-a, <-b:
res <- v1+v2
case v1, v2 := <-c, <-d:
res <- v1-v2
}
}
}
func main() {
a := make(chan int)
b := make(chan int)
c := make(chan int)
d := make(chan int)
res := make(chan int, 10)
go mynet(a, b, c, d, res)
a <- 5
c <- 5
d <- 7
b <- 7
fmt.Println(<-res)
fmt.Println(<-res)
}
It doesn't compile as shown. It can be made to compile by only checking one pipe, but then it can trivially slow down if that pipe is ready and the other is not.
package main
import "fmt"
func mynet(a, b, c, d <-chan int, res chan<- int) {
for {
select {
case v1 := <-a:
v2 := <-b
res <- v1+v2
case v1 := <-c:
v2 := <-d
res <- v1-v2
}
}
}
func main() {
a := make(chan int)
b := make(chan int)
c := make(chan int)
d := make(chan int)
res := make(chan int, 10)
go mynet(a, b, c, d, res)
a <- 5
c <- 5
d <- 7
//a <- 5
b <- 7
fmt.Println(<-res)
fmt.Println(<-res)
}
In general, I may have multiple waiting times on one channel, for example
case v1, v2 := <-a, <-b:
...
case v1, v2 := <-a, <-c:
...
so I cannot commit any branches when the value is ready on channel a: only when all the values are ready.
source to share
You cannot select on multiple channels at the same time. What you can do is implement a pattern to embed your values from multiple channels.
A sample example based on your code might look like this:
func collect(ret chan []int, chans ...<-chan int) {
ints := make([]int, len(chans))
for i, c := range chans {
ints[i] = <-c
}
ret <- ints
}
func mynet(a, b, c, d <-chan int, res chan<- int) {
set1 := make(chan []int)
set2 := make(chan []int)
go collect(set1, a, b)
go collect(set2, c, d)
for {
select {
case vs := <-set1:
res <- vs[0] + vs[1]
case vs := <-set2:
res <- vs[0] + vs[1]
}
}
}
source to share
Individual channels for two different pairs that you accumulate can work:
package main
import "fmt"
func mynetPlus(a, b <-chan int, res chan<- int) {
for {
select {
case v1 := <-a:
v2 := <-b
res <- v1 + v2
case v2 := <-b:
v1 := <-a
res <- v1 + v2
}
}
}
func mynetMinus(c, d <-chan int, res chan<- int) {
for {
select {
case v1 := <-c:
v2 := <-d
res <- v1 + v2
case v2 := <-d:
v1 := <-c
res <- v1 + v2
}
}
}
func main() {
a := make(chan int)
b := make(chan int)
c := make(chan int)
d := make(chan int)
res := make(chan int, 10)
go mynetPlus(a, b, res)
go mynetMinus(c, d, res)
a <- 5
c <- 5
d <- 7
//a <- 5
b <- 7
fmt.Println(<-res)
fmt.Println(<-res)
}
source to share