在Go语言中，通道是非常棒的，你可以使用它们在goroutines之间进行通信。但是，为了方便起见，您可能希望在某些情况下使用sync.Mutex。这些情况如下：

• 保卫一个内部国家
• 缓存问题
• 以获得更好的性能

这里有三个examples and explanations
1.简单计数器

1.乒乓球比赛

1.最简单的缓存

一些示例信道用例：

*限制并发任务数（例如运行goroutine的数量）使用缓冲的通道容量（和/或长度）
*转移一个对象的所有权（一个且只有一个goroutine写它，而没有其他goroutine阅读它）
*协调、同步、发送信号、数据。

一些示例基元用例：

*保护结构体的内部状态（例如sync.Mutex或sync.RWMutex）
*性能关键（依赖于算法和用例，不是一般规则）

示例

为了让它更清楚，假设我们需要一个一秒计数器，所以在下面的例子中，我们计数一秒，然后打印计数器值，看看它计数的速度有多快：

No |         Count |       Method
------------------------------------------------------
 1 |     17_729_027 | Using sync.RWMutex for increment   
 2 |     12_180_741 | Using channel for increment    
 3 |    106_743_095 | Using channel for timer 
 4 |    104_178_671 | Using time.AfterFunc and channel sync

注意：go版本go1.13.5 Linux/amd 64
代码：
1 -使用sync.RWMutex进行增量：

package main

import (
    "sync"
    "time"
)

func main() {
    var i rwm
    go func() {
        for {
            i.inc() // free running counter
        }
    }()
    time.Sleep(1 * time.Second)
    println(i.read()) // sampling the counter
}

type rwm struct {
    sync.RWMutex
    i int
}

func (l *rwm) inc() {
    l.Lock()
    defer l.Unlock()
    l.i++
}
func (l *rwm) read() int {
    l.RLock()
    defer l.RUnlock()
    return l.i
}

2 -使用通道进行增量：

package main

import (
    "time"
)

func main() {
    ch := make(chan int, 1)
    ch <- 1
    timeout := time.NewTimer(1 * time.Second)
loop:
    for {
        select {
        case <-timeout.C:
            timeout.Stop()
            break loop
        default:
            ch <- 1 + <-ch
        }
    }

    println(<-ch)
}

3 -使用定时器的通道：

package main

import "time"

func main() {
    ch := make(chan int)
    go func() {
        timeout := time.NewTimer(1 * time.Second)
        defer timeout.Stop()
        i := 1
        for {
            select {
            case <-timeout.C:
                ch <- i
                return
            default:
                i++
            }
        }
    }()

    println(<-ch)
}

4 -使用time.AfterFunc和通道同步：

package main

import (
    "fmt"
    "time"
)

func main() {
    d := 1 * time.Second
    i := uint64(0)
    ch := make(chan struct{})

    time.AfterFunc(d, func() {
        close(ch)
    })

loop:
    for {
        select {
        case <-ch:
            break loop
        default:
            i++
        }
    }

    fmt.Println(i) // 104_178_671
}