blocks|key|3038837|text|您不能以这种方式使用信号量(在本例中为通道)。在处理值和分配更多的goroutines时，不能保证它不会是空的。在这种情况下，这不是一个特别的问题，因为您是在同步地分配工作，但是因为没有无竞争的方法来检查通道的长度，所以没有基本的方法来等待一个通道的长度达到0。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3038838|使用sync.WaitGroup等待所有峡谷的完成|offset|length|style|CODE|3038839|sem+:=+make(chan+struct{},+2)

var+wg+sync.WaitGroup

for+_,+i+:=+range+ints+{
++++wg.Add(1)
++++//+acquire+semaphore
++++sem+<-+struct{}{}
++++//+start+long+running+go+routine
++++go+func(id+int)+{
++++++++defer+wg.Done()
++++++++//+do+something
++++++++//+release+semaphore
++++++++<-sem
++++}(i)
}

wg.Wait()|code-block|syntax|javascript|3038840|entityMap^0|0|2|E|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can't use a semaphore (channel in this case) in that manner. There's no guarantee it won't be empty any point while you are processing values and dispatching more goroutines. That's not a concern in this case specifically since you're dispatching work synchronously, but because there's no race-free way to check a channel's length, there's no primitive to wait for a channel's length to reach 0.

Use a <code>sync.WaitGroup</code> to wait for all goroutines to complete

<pre><code>sem := make(chan struct{}, 2)

var wg sync.WaitGroup

for _, i := range ints {
 wg.Add(1)
 // acquire semaphore
 sem &lt;- struct{}{}
 // start long running go routine
 go func(id int) {
 defer wg.Done()
 // do something
 // release semaphore
 &lt;-sem
 }(i)
}

wg.Wait()
</code></pre>

blocks|key|3447111|text|很明显，没有人在等你的常规程序来完成。因此，程序结束之前，最后两个围棋例程完成.在程序结束之前，您可以使用一个工作组来等待所有的运行例程完成。这说明它更好-+https://nathanleclaire.com/blog/2014/02/15/how-to-wait-for-all-goroutines-to-finish-executing-before-continuing/|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3447112|entityMap|0|LINK|mutability|MUTABLE|url|https://nathanleclaire.com/blog/2014/02/15/how-to-wait-for-all-goroutines-to-finish-executing-before-continuing/^0|27|34|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Clearly there is no one waiting for your go-routines to complete. Thus the program ends before the last 2 go-routines are completed. You may use a workgroup to wait for all your go-routines complete before the program ends. This tells it better - <a href="https://nathanleclaire.com/blog/2014/02/15/how-to-wait-for-all-goroutines-to-finish-executing-before-continuing/" rel="nofollow">https://nathanleclaire.com/blog/2014/02/15/how-to-wait-for-all-goroutines-to-finish-executing-before-continuing/</a>

blocks|key|3447117|text|使用“员工池”处理数据。它比运行每个+int更便宜，为其中的变量分配内存等等。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3447118|ints+:=+[]int{1,+2,+3,+4,+5,+6,+7,+8,+9,+10}

ch+:=+make(chan+int)

var+wg+sync.WaitGroup

//+run+worker+pool
for+i+:=+2;+i+>+0;+i--+{
++++wg.Add(1)

++++go+func()+{
++++++++defer+wg.Done()

++++++++for+id+:=+range+ch+{
++++++++++++//+do+something
++++++++++++fmt.Println(id)
++++++++}
++++}()
}

//+send+ints+to+workers
for+_,+i+:=+range+ints+{
++++ch+<-+i
}

close(ch)

wg.Wait()|code-block|syntax|javascript|3447119|entityMap^0|G|2|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Use "worker pool" to process you data. It is cheeper than run goroutine for each int, allocate memory for variables inside it and so on...

<pre><code>ints := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

ch := make(chan int)

var wg sync.WaitGroup

// run worker pool
for i := 2; i &gt; 0; i-- {
 wg.Add(1)

 go func() {
 defer wg.Done()

 for id := range ch {
 // do something
 fmt.Println(id)
 }
 }()
}

// send ints to workers
for _, i := range ints {
 ch &lt;- i
}

close(ch)

wg.Wait()
</code></pre>

blocks|key|3038972|text|您可以在for循环中等待当前goroutine的“”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3038973|semLimit+:=+2
sem+:=+make(chan+struct{},+semLimit)

for+_,+i+:=+range+ints+{
++//+acquire+semaphore
++sem+<-+struct{}{}

++//+start+long+running+go+routine
++go+func(id+int,+sem+chan+struct{})+{
++++//+do+something

++++//+release+semaphore
++++<-+sem
++}(i,+sem)
}

//+wait+semaphore
for+i+:=+0;+i+<+semLimit;+i%2B%2B+{+
++wg<-struct{}{}+
}|code-block|syntax|javascript|3038974|在import+sync的经济背景下，也有可能设计一个极简的“信号服务群”。|offset|length|style|CODE|3038975|semLimit+:=+2
//+mini+semaphored+waitgroup+
wg+:=+make(chan+struct{},+semLimit)
//+mini+methods
wgAdd+:=+func(){+wg<-struct{}{}+}
wgDone+:=+func(){+<-wg+}
wgWait+:=+func(){+for+i+:=+0;+i+<+semLimit;+i%2B%2B+{+wgAdd()+}+}

for+_,+i+:=+range+ints+{
++//+acquire+semaphore
++wgAdd()

++//+start+long+running+go+routine
++go+func(id+int,+sem+chan+struct{})+{
++++//+do+something

++++//+release+semaphore
++++wgDone()
++}(i,+sem)
}

//+wait+semaphore
wgWait()|3038976|entityMap^0|0|0|1|B|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

You can wait your "sub-goroutines" with the current goroutine in a for loop

<pre class="lang-golang prettyprint-override"><code>semLimit := 2
sem := make(chan struct{}, semLimit)

for _, i := range ints {
 // acquire semaphore
 sem &lt;- struct{}{}

 // start long running go routine
 go func(id int, sem chan struct{}) {
 // do something

 // release semaphore
 &lt;- sem
 }(i, sem)
}

// wait semaphore
for i := 0; i &lt; semLimit; i++ { 
 wg&lt;-struct{}{} 
}

</code></pre>

Optionnaly it is also possible to program a minimalistic "semaphored waitgroup" with the economy of <code>import sync</code>

<pre><code>semLimit := 2
// mini semaphored waitgroup 
wg := make(chan struct{}, semLimit)
// mini methods
wgAdd := func(){ wg&lt;-struct{}{} }
wgDone := func(){ &lt;-wg }
wgWait := func(){ for i := 0; i &lt; semLimit; i++ { wgAdd() } }

for _, i := range ints {
 // acquire semaphore
 wgAdd()

 // start long running go routine
 go func(id int, sem chan struct{}) {
 // do something

 // release semaphore
 wgDone()
 }(i, sem)
}

// wait semaphore
wgWait()
</code></pre>

blocks|key|1781323|text|下面是一个有用的例子。末端的for循环迫使程序等待任务完成：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1781324|package+main
import+"time"

func+w(n+int,+e+chan+error)+{
+++//+do+something
+++println(n)
+++time.Sleep(time.Second)
+++//+release+semaphore
+++<-e
}

func+main()+{
+++a+:=+[]int{1,+2,+3,+4,+5,+6,+7,+8,+9,+10}
+++e+:=+make(chan+error,+2)
+++for+_,+n+:=+range+a+{
++++++//+acquire+semaphore
++++++e+<-+nil
++++++//+start+long+running+go+routine
++++++go+w(n,+e)
+++}
+++for+n+:=+cap(e);+n+>+0;+n--+{
++++++e+<-+nil
+++}
}|code-block|syntax|javascript|1781325|entityMap^0|E|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Here is a working example. The <code>for</code> loop at the end forces the program to wait
until the jobs are done:
<pre><code>package main
import &quot;time&quot;

func w(n int, e chan error) {
 // do something
 println(n)
 time.Sleep(time.Second)
 // release semaphore
 &lt;-e
}

func main() {
 a := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 e := make(chan error, 2)
 for _, n := range a {
 // acquire semaphore
 e &lt;- nil
 // start long running go routine
 go w(n, e)
 }
 for n := cap(e); n &gt; 0; n-- {
 e &lt;- nil
 }
}
</code></pre>

I have a slice of integers, which are manipulated concurrently:
<pre><code>ints := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
</code></pre>
I'm using a buffered channel as semaphore in order to have an upper bound of concurrently running go routines:
<pre><code>sem := make(chan struct{}, 2)

for _, i := range ints {
 // acquire semaphore
 sem &lt;- struct{}{}

 // start long running go routine
 go func(id int, sem chan struct{}) {
 // do something

 // release semaphore
 &lt;- sem
 }(i, sem)
}
</code></pre>
The code above works pretty well until the last or last two integers are reached, because the program ends before those last go routines are finished.
Question: how do I wait for the buffered channel to drain?

How to wait until buffered channel (semaphore) is empty?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一段整数，这些整数是并发操作的：ints := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}为了具有并发运行go例程的上限，我使用缓冲通道作为信号量：sem := make(chan struct{}, 2)for _, i := range ints {  // acquire sem...

问如何等到缓冲通道(信号量)为空？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何等到缓冲通道(信号量)为空？EN