<p>I have came up with the following code, but I don't like that I have to catch a panic message. Is there a better way to have counters implemented with channels?</p>
<p>package lce</p>
<pre><code>import (
"log"
)
type Counter struct {
next int
ch chan int
}
func NewCounter(next_id int) *Counter {
return &Counter{
next: next_id,
ch: make(chan int),
}
}
func (self Counter) Run() {
go func() {
defer func() {
if r := recover(); r != nil {
log.Printf("Counter run loop is terminating. Detail: %v\n", r)
}
}()
for {
if self.ch != nil {
self.ch <- self.next
self.next++
} else {
log.Print("Counter is closed.")
}
}
}()
}
func (self Counter) Close() {
if self.ch != nil {
close(self.ch)
self.ch = nil
}
}
</code></pre>
<hr/>**评论：**<br/><br/>condanky: <pre><p>you can use mutex locks around an increment function instead of using channels. Are you using the count somewhere else?</p></pre>TheMerovius: <pre><p>In another thread, a while back, I came up with <a href="https://github.com/Merovius/go-misc/blob/master/owned/owned.go" rel="nofollow">this pattern</a> which is kind of neat. The <code>New</code> function encapsulates the logic. An increment would be expressible by passing in <code>func(v interface{}) interface{} { return v.(int) + 1 }</code>. More readable would be, to change the type used in the code from the generic <code>interface{}</code> to <code>int</code>. In that case it's</p>
<pre><code>v := New(0)
inc := func(i int) int { return i + 1 }
v <- inc
v <- inc
</code></pre>
<p>This pattern is at least much more readable and stable than yours :)</p>
<p>All of that being said: Using a mutex is a lot simpler and faster. Using <a href="https://godoc.org/sync/atomic#AddInt64" rel="nofollow">sync/atomic</a> even more so (though that's probably overkill and too subtle for normal programs. Just use a mutex).</p></pre>captncraig: <pre><p>You should check out this talk from gophercon: <a href="https://www.youtube.com/watch?v=1V7eJ0jN8-E" rel="nofollow">https://www.youtube.com/watch?v=1V7eJ0jN8-E</a></p>
<p>You think he's gonna talk about this big monitoring system he built, but he really spends 20 minutes talking about how to increment a number aomically. He ends up with a pretty cool usage of the <code>sync/atomic</code> stuff.</p></pre>DarkRye: <pre><p>Thank you. I appreciate the link.</p></pre>DarkRye: <pre><p>It does fee like an overkill. I am learning go as I go.</p></pre>alienwork: <pre><p>Use the atomic package for this.
<a href="https://golang.org/pkg/sync/atomic/#AddInt32" rel="nofollow">https://golang.org/pkg/sync/atomic/#AddInt32</a></p></pre>gohacker: <pre><p>Wow, what a freaking misuse of channels!</p></pre>
