Go语言协程

在了解协程（Go routine）之前，我们先来了解一些基础概念.

进程

进程（Process）是计算机中运行的程序的实例。它是操作系统进行资源分配和调度的基本单位，包含了程序的代码、数据和执行状态等信息。每个进程都拥有独立的内存空间，使得多个进程可以并发执行而互不干扰。

进程由操作系统进行创建、管理和调度。当一个程序被启动时，操作系统会为其分配一个新的进程，并为其分配一定的系统资源，如内存空间、CPU时间片等。每个进程都有自己的地址空间、程序计数器、堆栈以及一些操作系统资源，如打开的文件、网络连接等。

进程之间通常是相互独立的，它们不能直接访问彼此的内存空间。如果进程之间需要通信或共享数据，通常需要使用进程间通信（Inter-Process Communication，IPC）机制，如管道（Pipe）、信号（Signal）、消息队列（Message Queue）、共享内存（Shared Memory）等。

在现代操作系统中，多进程并发是实现多任务的基本方式之一。通过多进程并发，可以实现多个任务的同时执行，提高系统的资源利用率和响应能力。然而，进程切换和资源管理也会带来一定的开销，因此在某些场景下，使用线程等更轻量级的并发机制可能更为合适。

线程

线程（Thread）是操作系统能够进行运算调度的最小单位。它被包含在进程中，是进程中的实际运作单位。线程是比进程更小的执行单位，一个进程可以拥有多个线程，这些线程共享进程的内存空间和系统资源。相比于进程，线程的创建、销毁和切换开销更小，因此更适合用于实现并发执行任务。

每个线程都有自己的执行堆栈（Stack）、程序计数器（Program Counter）和一组寄存器，同时共享同一进程的地址空间和其他资源。线程可以并发执行，允许程序在多个任务之间快速切换执行，实现并发执行的效果。

在多线程编程中，线程可以分为主线程和工作线程。主线程通常是程序的起点，负责执行程序的初始化和控制流程。而工作线程则是由主线程创建并执行具体的任务，例如处理用户输入、执行计算、进行网络通信等。通过多线程编程，可以更有效地利用多核处理器的性能，提高程序的并发处理能力和响应速度。

然而，多线程编程也带来了一些挑战，如竞态条件（Race Condition）、死锁（Deadlock）、资源争用（Resource Contention）等问题，需要开发人员通过合理的同步和互斥机制来解决。

Goroutine

在java/c++中我们要实现并发编程的时候，我们通常需要自己维护一个线程池，并且需要自己去包装一个又一个的任务，同时需要自己去调度线程执行任务并维护上下文切换，这一切通常会耗费程序员大量的心智。那么能不能有一种机制，程序员只需要定义很多个任务，让系统去帮助我们把这些任务分配到CPU上实现并发执行呢？

Go语言中的goroutine就是这样一种机制，goroutine的概念类似于线程，但 goroutine是由Go的运行时（runtime）调度和管理的。Go程序会智能地将 goroutine 中的任务合理地分配给每个CPU。Go语言之所以被称为现代化的编程语言，就是因为它在语言层面已经内置了调度和上下文切换的机制。

在Go语言编程中你不需要去自己写进程、线程、协程，你的技能包里只有一个技能–goroutine，当你需要让某个任务并发执行的时候，你只需要把这个任务包装成一个函数，开启一个goroutine去执行这个函数就可以了，就是这么简单粗暴。

使用goroutine

Go语言中使用goroutine非常简单，只需要在调用函数的时候在前面加上go关键字，就可以为一个函数创建一个goroutine。

一个goroutine必定对应一个函数，可以创建多个goroutine去执行相同的函数。

启动单个goroutine

启动goroutine的方式非常简单，只需要在调用的函数（普通函数和匿名函数）前面加上一个go关键字。

举个例子如下：

func hello() {
    fmt.Println("Hello Goroutine!")
}
func main() {
    hello()
    fmt.Println("main goroutine done!")
}

这个示例中hello函数和下面的语句是串行的，执行的结果是打印完Hello Goroutine!后打印main goroutine done!。

接下来我们在调用hello函数前面加上关键字go，也就是启动一个goroutine去执行hello这个函数。

func main() {
    go hello() // 启动另外一个goroutine去执行hello函数
    fmt.Println("main goroutine done!")
}

这一次的执行结果只打印了main goroutine done!，并没有打印Hello Goroutine!。为什么呢？

在程序启动时，Go程序就会为main()函数创建一个默认的goroutine。

当main()函数返回的时候该goroutine就结束了，所有在main()函数中启动的goroutine会一同结束，main函数所在的goroutine就像是权利的游戏中的夜王，其他的goroutine都是异鬼，夜王一死它转化的那些异鬼也就全部GG了。

所以我们要想办法让main函数等一等hello函数，最简单粗暴的方式就是time.Sleep了。

func main() {
    go hello() // 启动另外一个goroutine去执行hello函数
    fmt.Println("main goroutine done!")
    time.Sleep(time.Second)
}

执行上面的代码你会发现，这一次先打印main goroutine done!，然后紧接着打印Hello Goroutine!。

首先为什么会先打印main goroutine done!是因为我们在创建新的goroutine的时候需要花费一些时间，而此时main函数所在的goroutine是继续执行的。

启动多个goroutine

在Go语言中实现并发就是这样简单，我们还可以启动多个goroutine。让我们再来一个例子： （这里使用了sync.WaitGroup来实现goroutine的同步）

var wg sync.WaitGroup

func hello(i int) {
    defer wg.Done() // goroutine结束就登记-1
    fmt.Println("Hello Goroutine!", i)
}
func main() {

    for i := 0; i < 10; i++ {
        wg.Add(1) // 启动一个goroutine就登记+1
        go hello(i)
    }
    wg.Wait() // 等待所有登记的goroutine都结束
}

多次执行上面的代码，会发现每次打印的数字的顺序都不一致。这是因为10个goroutine是并发执行的，而goroutine的调度是随机的。

注意

• 如果主协程退出了，其他任务还执行吗（运行下面的代码测试一下吧）

package main

import (
    "fmt"
    "time"
)

func main() {
    // 合起来写
    go func() {
        i := 0
        for {
            i++
            fmt.Printf("new goroutine: i = %d\n", i)
            time.Sleep(time.Second)
        }
    }()
    i := 0
    for {
        i++
        fmt.Printf("main goroutine: i = %d\n", i)
        time.Sleep(time.Second)
        if i == 2 {
            break
        }
    }
}

答案是不执行.在给定的代码中，主协程在 i == 2 时退出了。由于没有其他协程在运行，因此程序会立即退出，其他任务不会继续执行。