1

是否有可能：假设，我有 3 个并发例程可以相互发送整数。现在，假设并发例程 2 和 3 都向并发例程 1 发送一个整数。例程 1 是否有可能同时获取两个值并进一步处理它？为了清楚起见，我有以下代码：

package main
import "rand"

func Routine1(command12 chan int, response12 chan int, command13 chan int, response13 chan int ) {
for i := 0; i < 10; i++ {
    i := rand.Intn(100)
if i%2 == 0 {
command12 <- i 
}

if i%2 != 0 {
command13 <- i 
}

print(<-response13, " 1st\n");
}
close(command12)
}

func Routine2(command12 chan int, response12 chan int, command23 chan int, response23 chan int) {
for i := 0; ; i++ {
    x, open := <-command12
    if !open {
        return;
    }
     print(x , " 2nd\n");
    y := rand.Intn(100)
    if i%2 == 0 {
command12 <- y 
}

if i%2 != 0 {
command23 <- y 
}
}
}

func Routine3(command13 chan int, response13 chan int, command23 chan int, response23 chan int) {
for i := 0; ; i++ {
    x, open := <-command13
    if !open {
        return;
    }
     print(x , " 3nd\n");
    y := rand.Intn(100)
    response23 <- y
}
}

func main() {
   command12 := make(chan int)
   response12 := make(chan int)
   command13 := make(chan int)
   response13 := make(chan int)
   command23 := make(chan int)
   response23 := make(chan int)

   go Routine1(command12, response12,command13, response13 )
   Routine2(command12, response12,command23, response23)
   Routine3(command13, response13,command23, response23 )
}

在这里，在这个例子中，例程 1 可以向例程 2 或 3 发送一个 int。我假设它是例程 3。现在假设例程 3 也向例程 2 发送一个 int。例程 2 是否可以采用这两个值并处理进一步（动态并发例程）？任何机构都可以帮助相应地修改这个程序。

4

2 回答 2

2

我讨厌抽象的例子，无论如何我会尽力回答你的问题。

例程 1 是否有可能同时采用两个值并进一步处理它？

你要存档什么？在routine1 中，您可以执行以下操作：

// Read exactly one command from routine2 as well as exactly
// one command from routine3
cmd1 := <-command12
cmd2 := <-command13
// Process the pair of the two commands here

或者

// Process a single command only, which was either sent by routine2
// or by routine3. If there are commands available on both channels
// (command12 and command13) the select statement chooses a branch
// fairly.
select {
    case cmd1 := <-command12:
        // process command from routine 2
    case cmd2 := <-command13
        // process command from routine 3
}

我希望这能回答你的问题。另请注意，Go 频道默认支持多个写入者（以及多个读取者）。因此，每个 goroutine 只使用一个输入通道可能就足够了。例如，routine1 可能只从名为 command1 的通道读取命令，但routine2 和routine3 可能使用相同的 command1 通道向routine1 发送消息。

Go 中另一个常见的习惯用法是将回复通道作为消息的一部分传递。例如：

type Command struct {
    Cmd string
    Reply chan-> int
}

func routine2() {
    reply := make(chan int)
    command1 <- Command{"doSomething", reply}
    status := <-reply
}

func routine1() {
    cmd <- command1;
    // process cmd.Cmd
    cmd.Reply <- 200 // SUCCESS (status code)
}

根据您的实际问题，这可能会大大简化您的程序:)

于 2011-11-23T10:44:17.607 回答
0

这在 GO 中是不可能的，我的意思是创建并发通道。

于 2011-11-23T00:12:19.180 回答