Golang -- 并发

1、通过通信共享

并发编程是一个很大的主题，这里只提供一些特定于go的重点内容。

在许多环境中，实现对共享变量的正确访问所需要的微妙之处使并发编程变得困难。Go鼓励一种不同的方法，在这种方法中，共享值在通道中传递，实际上，从不由单独的执行线程主动共享。在任何给定时间，只有一个goroutine可以访问该值。根据设计，数据竞争是不可能发生的。为了鼓励这种思维方式，我们把它简化为一句口号:

Do not communicate by sharing memory; instead, share memory by communicating.
不要通过共享内存进行通信;相反，通过通信共享内存。

这种方法可能走得太远。例如，引用计数最好通过在整数变量周围放置互斥来实现。但是作为一种高级方法，使用通道来控制访问可以更容易地编写清晰、正确的程序。

考虑这个模型的一种方法是考虑一个典型的单线程程序运行在一个CPU上。它不需要同步原语。现在运行另一个这样的实例;它也不需要同步。现在让这两个程序通信;如果通信是同步器，则仍然不需要其他同步。例如，Unix管道就完美地符合这个模型。尽管Go的并发方法起源于Hoare的通信顺序处理(communication Sequential Processes, CSP)，但它也可以被视为Unix管道的类型安全的泛化。

2、Goroutines

它们之所以被称为goroutine，是因为现有的术语——线程、协程、进程等等——传达了不准确的含义。goroutine有一个简单的模型:它是一个与相同地址空间中的其他goroutine并发执行的函数。它是轻量级的，比分配栈空间的成本高不了多少。而且栈开始时很小，所以它们很便宜，并通过根据需要分配(和释放)堆存储来增长。

goroutine被多路复用到多个操作系统线程上，因此如果一个线程阻塞，比如在等待I/O时，其他线程继续运行。它们的设计隐藏了线程创建和管理的许多复杂性。

在函数或方法调用前加上go关键字以在新的 goroutine 中运行该调用。当调用完成时，goroutine 将无声地退出。(效果类似于Unix shell的&符号，用于在后台运行命令。)

go list.Sort()  // run list.Sort concurrently; don't wait for it.

function literal在goroutine调用中很方便。

func Announce(message string, delay time.Duration) {
    
    
    go func() {
    
    
        time.Sleep(delay)
        fmt.Println(message)
    }()  // Note the parentheses - must call the function.
}

在Go中，函数字面量( function literals )是闭包: 实现确保函数引用的变量只要处于活动状态就能存活。

3、Channels

与map一样，通道也使用make进行分配，结果值作为对底层数据结构的引用。如果提供了可选的整数参数，它将设置通道的缓冲区大小。对于无缓冲通道或同步通道，默认值为0。

ci := make(chan int)            // unbuffered channel of integers
cj := make(chan int, 0)         // unbuffered channel of integers
cs := make(chan *os.File, 100)  // buffered channel of pointers to Files

无缓冲通道将通信(值的交换)与同步结合起来，确保两个计算(gorout例程)处于已知状态。

有很多使用通道的好习语。这是一个开始。在前一节中，我们在后台启动了排序。通道可以允许启动goroutine等待排序完成。

c := make(chan int)  // Allocate a channel.
// Start the sort in a goroutine; when it completes, signal on the channel.
go func() {
    
    
    list.Sort()
    c <- 1  // Send a signal; value does not matter.
}()
doSomethingForAWhile()
<-c   // Wait for sort to finish; discard sent value.

接收者总是阻塞，直到有数据接收。如果通道无缓冲，发送方将阻塞，直到接收方接收到该值。如果通道有缓冲区，发送方只阻塞直到值被复制到缓冲区;如果缓冲区已满，这意味着需要等待到某个接收器接收到一个值。 （参考3.1）

有缓冲通道可以像信号量（semaphore）一样使用，例如限制吞吐量。在本例中，传入的请求被传递给handle, handle将一个值发送到通道中，处理请求，然后从通道接收一个值，以便为下一个使用者准备“信号量”。通道缓冲区的容量限制了要处理的同时调用的数量。

var sem = make(chan int, MaxOutstanding)

func handle(r *Request) {
    
    
    sem <- 1    // Wait for active queue to drain.
    process(r)  // May take a long time.
    <-sem       // Done; enable next request to run.
}

func Serve(queue chan *Request) {
    
    
    for {
    
    
        req := <-queue
        go handle(req)  // Don't wait for handle to finish.
    }
}

一旦MaxOutstanding处理程序正在执行进程，试图向已充满的通道缓冲区发送的请求都将阻塞，直到现有的一个处理程序完成并从缓冲区接收。

但是，这种设计有一个问题:Serve为每个传入的请求创建一个新的goroutine ，尽管在任何时候, 只有MaxOutstanding多个可以运行。因此，如果请求来得太快，程序可能会消耗无限的资源。我们可以通过更改Serve来限制goroutines的创建来解决这个缺陷。这里有一个明显的解决方案，但要注意它有一个bug，我们随后会修复:

func Serve(queue chan *Request) {
    
    
    for req := range queue {
    
    
        sem <- 1
        go func() {
    
    
            process(req) // Buggy; see explanation below.
            <-sem
        }()
    }
}

bug 在于，在Go for循环中，循环变量在每次迭代中都被重用，因此req变量在所有goroutine中共享。这不是我们想要的。我们需要确保每个goroutine的req是唯一的。这里有一种方法，在goroutine中将req的值作为参数传递给闭包:

func Serve(queue chan *Request) {
    
    
    for req := range queue {
    
    
        sem <- 1
        go func(req *Request) {
    
    
            process(req)
            <-sem
        }(req)
    }
}

将此版本与前一个版本进行比较，查看闭包的声明和运行方式的差异。另一个解决方案是创建一个同名的新变量，如下例所示:

func Serve(queue chan *Request) {
    
    
    for req := range queue {
    
    
        req := req // Create new instance of req for the goroutine.
        sem <- 1
        go func() {
    
    
            process(req)
            <-sem
        }()
    }
}

这样写似乎有些奇怪

req := req

但在Go 中这样做是合法的和惯用的。您将得到一个具有相同名称的新变量，故意在局部掩盖循环变量，但对每个goroutine都是惟一的。

回到编写服务器的一般问题，另一种很好地管理资源的方法是启动固定数量的handle goroutines ，所有这些handle goroutines 都从请求通道读取。goroutine的数量限制了process同时调用的数量。这个Serve函数还接受一个通道，它将被告知退出该通道;在启动goroutines之后，它会阻止从该通道接收。

func handle(queue chan *Request) {
    
    
    for r := range queue {
    
    
        process(r)
    }
}

func Serve(clientRequests chan *Request, quit chan bool) {
    
    
    // Start handlers
    for i := 0; i < MaxOutstanding; i++ {
    
    
        go handle(clientRequests)
    }
    <-quit  // Wait to be told to exit.
}

3.1 Channel都有哪些特性

Go语言中的channel具有以下几个特性：

线程安全
channel是线程安全的，多个协程可以同时读写一个channel，而不会发生数据竞争的问题。这是因为Go语言中的channel内部实现了锁机制，保证了多个协程之间对channel的访问是安全的。

阻塞式发送和接收
当一个协程向一个channel发送数据时，如果channel已经满了，发送操作会被阻塞，直到有其他协程从channel中取走了数据。同样地，当一个协程从一个channel中接收数据时，如果channel中没有数据可供接收，接收操作会被阻塞，直到有其他协程向channel中发送了数据。这种阻塞式的机制可以保证协程之间的同步和通信。

顺序性
通过channel发送的数据是按照发送的顺序进行排列的。也就是说，如果协程A先向channel中发送了数据x，而协程B再向channel中发送了数据y，那么从channel中接收数据时，先接收到的一定是x，后接收到的一定是y。

可以关闭
通过关闭channel可以通知其他协程这个channel已经不再使用了。关闭一个channel之后，其他协程仍然可以从中接收数据，但是不能再向其中发送数据了。关闭channel的操作可以避免内存泄漏等问题。

缓冲区大小
channel可以带有一个缓冲区，用于存储一定量的数据。如果缓冲区已经满了，发送操作会被阻塞，直到有其他协程从channel中取走了数据；如果缓冲区已经空了，接收操作会被阻塞，直到有其他协程向channel中发送了数据。缓冲区的大小可以在创建channel时指定，例如：

ch := make(chan int, 10)

会panic的几种情况

1.向已经关闭的channel发送数据

2.关闭已经关闭的channel

3.关闭未初始化的nil channel

会阻塞的情况：

1.从未初始化 nil channel中读数据

2.向未初始化 nil channel中发数据

3.在没有读取的groutine时，向无缓冲channel发数据，
有缓冲区，但缓冲区已满，发送数据时

4.在没有数据时，从无缓冲或者有缓冲channel读数据

返回零值:

从已经关闭的channe接收数据

3.2 channel 的最佳实践

在使用channel时，应该遵循以下几个最佳实践：

避免死锁
使用channel时应该注意避免死锁的问题。如果一个协程向一个channel发送数据，但是没有其他协程从channel中取走数据，那么发送操作就会一直被阻塞，从而导致死锁。为了避免这种情况，可以使用select语句来同时监听多个channel，从而避免阻塞。

避免泄漏
在使用channel时应该注意避免内存泄漏的问题。如果一个channel没有被关闭，而不再使用了，那么其中的数据就无法被释放，从而导致内存泄漏。为了避免这种情况，可以在协程结束时关闭channel。

避免竞争
在使用channel时应该注意避免数据竞争的问题。如果多个协程同时读写一个channel，那么就可能会发生竞争条件，从而导致数据不一致的问题。为了避免这种情况，可以使用锁机制或者使用单向channel来限制协程的访问权限。

避免过度使用
在使用channel时应该注意避免过度使用的问题。如果一个程序中使用了大量的channel，那么就可能会导致程序的性能下降。为了避免这种情况，可以使用其他的并发编程机制，例如锁、条件变量等。

4、Channels of channels

Go最重要的属性之一是通道是first-class值，可以像其他值一样分配和传递。此属性的常见用途是实现安全的并行多路解复用。

在上一节的示例中，handle是请求的理想处理程序，但我们没有定义它处理的类型。如果该类型包含要在其上回复的通道，则每个客户机都可以为应答提供自己的路径。下面是Request类型的示意图定义。

type Request struct {
    
    
    args        []int
    f           func([]int) int
    resultChan  chan int
}

客户端提供了一个函数及其参数，以及请求对象内用于接收answer的通道。

func sum(a []int) (s int) {
    
    
    for _, v := range a {
    
    
        s += v
    }
    return
}

request := &Request{
    
    []int{
    
    3, 4, 5}, sum, make(chan int)}
// Send request
clientRequests <- request
// Wait for response.
fmt.Printf("answer: %d\n", <-request.resultChan)

在服务器端，唯一需要更改的是处理程序函数。

func handle(queue chan *Request) {
    
    
    for req := range queue {
    
    
        req.resultChan <- req.f(req.args)
    }
}

显然，要实现它还有很多工作要做，但这段代码是一个速率受限、并行、非阻塞RPC系统的框架，而且还没有看到mutex 。

5、并行（Parallelization）

这些思想的另一个应用是跨多个CPU核并行计算。如果计算可以被分解成可以独立执行的独立部分，那么它就可以被并行化，并在每个部分完成时用一个通道发出信号。

假设我们有一个昂贵的操作要对一个items的向量执行，并且每个item的操作值是独立的，就像在这个理想的例子中一样。

type Vector []float64

// Apply the operation to v[i], v[i+1] ... up to v[n-1].
func (v Vector) DoSome(i, n int, u Vector, c chan int) {
    
    
    for ; i < n; i++ {
    
    
        v[i] += u.Op(v[i])
    }
    c <- 1    // signal that this piece is done
}

我们在一个循环中独立地启动这些片段，每个CPU一个。它们可以按任何顺序完成，但这没有关系;我们只是在启动所有的goroutine之后通过排泄通道来计算完成信号。

const numCPU = 4 // number of CPU cores

func (v Vector) DoAll(u Vector) {
    
    
    c := make(chan int, numCPU)  // Buffering optional but sensible.
    for i := 0; i < numCPU; i++ {
    
    
        go v.DoSome(i*len(v)/numCPU, (i+1)*len(v)/numCPU, u, c)
    }
    // Drain the channel.
    for i := 0; i < numCPU; i++ {
    
    
        <-c    // wait for one task to complete
    }
    // All done.
}

我们不需要为numCPU创建一个常量，而是可以询问运行时哪个值是合适的。函数runtime.NumCPU返回机器中硬件CPU核数，因此我们可以这样写

还有一个函数 runtime.GOMAXPROCS，它报告(或设置)用户指定的Go程序可以同时运行的核数。默认值为runtime.NumCPU，但可以通过设置类似命名的shell环境变量或调用带有正数的函数来覆盖。用0调用它只是查询值。因此，如果我们想要满足用户的资源请求，我们应该写

var numCPU = runtime.GOMAXPROCS(0)

请务必不要混淆并发性(concurrency，将程序构造为独立执行的组件)和并行性(parallelism， 在多个cpu上并行执行计算以提高效率)这两个概念。尽管Go的并发特性可以使一些问题很容易构建为并行计算，但Go是一种并发语言，而不是并行语言，并且并不是所有的并行化问题都适合Go的模型。关于区别的讨论，请参阅本博客文章中引用的谈话。

6、漏桶缓冲区（A leaky buffer）

并发编程的工具甚至可以使非并发的想法更容易表达。下面是一个从RPC包中抽象出来的示例。客户端goroutine循环从某个源(可能是网络)接收数据。为了避免分配和释放缓冲区，它保留了一个空闲列表，并使用缓冲通道来表示它。如果通道为空，则分配一个新的缓冲区。一旦消息缓冲区准备好了，它就被发送到serverChan上的服务器。

var freeList = make(chan *Buffer, 100)
var serverChan = make(chan *Buffer)

func client() {
    
    
    for {
    
    
        var b *Buffer
        // Grab a buffer if available; allocate if not.
        select {
    
    
        case b = <-freeList:
            // Got one; nothing more to do.
        default:
            // None free, so allocate a new one.
            b = new(Buffer)
        }
        load(b)              // Read next message from the net.
        serverChan <- b      // Send to server.
    }
}

服务器循环从客户端接收每条消息，处理它，并将缓冲区返回到空闲列表。

func server() {
    
    
    for {
    
    
        b := <-serverChan    // Wait for work.
        process(b)
        // Reuse buffer if there's room.
        select {
    
    
        case freeList <- b:
            // Buffer on free list; nothing more to do.
        default:
            // Free list full, just carry on.
        }
    }
}

客户端尝试从freeList中检索缓冲区;如果没有可用的，则分配一个新的。服务器发送给freeList的消息会将b放回空闲列表中，除非空闲列表已满，在这种情况下，缓冲区将被丢弃在地板上，由垃圾收集器回收。(当没有其他case可用时，select语句中的default 子句将执行，这意味着select语句永远不会阻塞。)此实现仅用几行就构建了一个漏桶列表，依赖于缓冲通道和垃圾收集器进行记账。