Go例程中的有限循环

我试图在完成主题后同步执行两个或多个go例程

我编写了一些代码来测试go例程的行为 （我把它当作一个队列，顺便说一句，go并发教程页面并没有真正帮助我）

主程序包
进口(
“fmt”
“同步”
)
常数大小=10
var vChan chan int=制造（chan int，尺寸）
func justSend（wg*sync.WaitGroup）{
推迟工作组完成（）
对于i:=1；i您已将goroutine放入
main
中，并且
main
函数在您的go例程完成之前完成。因此，要么不要在
main
中使用goroutine，要么在
main
的末尾使用某种布尔接收通道，当goroutine完成时，该通道将
true
。
您已将goroutine i放入n
main
和
main
函数在go例程完成之前完成。因此不要在
main
中使用goroutine，或者在
main
的末尾使用某种布尔接收通道，当goroutine完成时，该通道将获得
true
。
不，不要使用无限循环。
同步最好使用通道或同步包的设施。
main（）
也是一个goroutine（主程序），因此如果
main
在其他goroutine之前退出，您的任务仍然未完成。
一种方法是使用
sync.WaitGroup
等待其他goroutine完成（请参见示例1、2和3）。另一种方法是使用通道等待其他goroutine完成（请参见示例4和5）。我提供了一些示例，以便您可以选择适合您的情况：


1-一个发送和多个接收（保持通道打开），尝试：


6-多发送多接收，尝试：

主程序包
进口(
“fmt”
“同步”
)
func main（）{
工作组.添加（5）
对于i:=1；iNo，不要使用无限循环。
同步最好使用通道或同步包的设施。
main（）
也是一个goroutine（主程序），因此如果
main
在其他goroutine之前退出，您的任务仍然未完成。
一种方法是使用
sync.WaitGroup
等待其他goroutine完成（请参见示例1、2和3）。另一种方法是使用通道等待其他goroutine完成（请参见示例4和5）。我提供了一些示例，以便您可以选择适合您的情况：


1-一个发送和多个接收（保持通道打开），尝试：


6-多发送多接收，尝试：

主程序包
进口(
“fmt”
“同步”
)
func main（）{
工作组.添加（5）
对于i:=1；在您有机会获得任何输出之前，您的应用程序将退出
语句完成-没有任何东西阻止程序退出。我不确定您试图完成什么，但我提供以下信息：感谢@CeriseLimón游乐场的支持，但这是否意味着我需要先关闭频道，然后才能在另一个go例程中读取其值？可能重复
wg.Add（大小）
在您有机会获得任何输出之前，您的应用程序将退出。
go func（）{…}）（）
语句完成-没有任何东西阻止程序退出。我不确定您想要完成什么，但我提供以下信息：感谢@CeriseLimón游乐场的支持，但这是否意味着我需要先关闭频道，然后才能在另一个go例程中从中读取值？可能重复
wg.Add（size）
package main

import (
        "fmt"
        "sync"
)

const size = 10
var vChan chan int = make(chan int, size)

func justSend(wg *sync.WaitGroup) {
        defer wg.Done()
        for i := 1; i <= 10; i++ {
                vChan <- i
        }
}

func justPrint(wg *sync.WaitGroup) {
        defer wg.Done()
        v := <- vChan
        fmt.Printf("%4d ", v);
}

func main() {
        wg := new(sync.WaitGroup)

        go func() {
                wg.Add(1)
                go justSend(wg)
                wg.Wait()
                wg.Add(size)
                go justPrint(wg)
                wg.Wait()
                close(vChan)
        }()
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    go tx()
    wg.Add(20)
    for i := 1; i <= 20; i++ {
        go rx()
    }
    wg.Wait()
}

func tx() {
    for i := 1; i <= 20; i++ {
        vChan <- i
    }
}

func rx() {
    defer wg.Done()
    fmt.Println(<-vChan)
}

var wg sync.WaitGroup

var vChan = make(chan int, 10)

package main

import (
    "fmt"
    "sync"
)

func main() {
    go tx()
    wg.Add(1)
    go rx()
    wg.Wait()
}

func tx() {
    for i := 1; i <= 20; i++ {
        vChan <- i
    }
}

func rx() {
    defer wg.Done()
    for i := 1; i <= 20; i++ {
        fmt.Println(<-vChan)
    }
}

var wg sync.WaitGroup

var vChan = make(chan int, 10)

package main

import (
    "fmt"
    "sync"
)

func main() {
    go tx()
    wg.Add(1)
    go rx()
    wg.Wait()
}

func tx() {
    for i := 1; i <= 5; i++ {
        vChan <- i
    }
    close(vChan)
}

func rx() {
    defer wg.Done()
    for v := range vChan {
        fmt.Println(v)
    }
}

var wg sync.WaitGroup

var vChan = make(chan int, 10)

package main

import (
    "fmt"
)

func main() {
    go tx()
    for v := range vChan {
        fmt.Println(v)
    }
}

func tx() {
    for i := 1; i <= 20; i++ {
        vChan <- i
    }
    close(vChan)
}

var vChan = make(chan int, 10)

package main

import (
    "fmt"
)

func main() {
    go tx()
    go rx()
    <-quit
}
func rx() {
    for v := range vChan {
        fmt.Println(v)
    }
    quit <- struct{}{}
}
func tx() {
    for i := 10; i <= 15; i++ {
        vChan <- i
    }
    close(vChan)
}

var quit = make(chan struct{}, 1)
var vChan = make(chan int, 10)

10
11
12
13
14
15

package main

import (
    "fmt"
    "sync"
)

func main() {
    wg.Add(5)
    for i := 1; i <= 5; i++ {
        go tx()
        go rx()
    }
    wg.Wait()
}

var n = 10

func tx() {
    vChan <- n
    n++
}

func rx() {
    defer wg.Done()
    fmt.Println(<-vChan)
}

var wg sync.WaitGroup

var vChan = make(chan int, 10)

package main

import (
    "fmt"
    "sync"
)

func main() {
    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go tx()
    }

    go rx()
    wg.Wait()
}

func rx() {
    for {
        fmt.Println(<-vChan)
        wg.Done()
    }
}

var n = 20

func tx() {
    vChan <- n
    n++
}

var wg sync.WaitGroup

var vChan = make(chan int, 10)