goruntine介绍 | braveheart-博客

go 协程介绍

线程和进程介绍
线程属于进程。进程和线程都需要内核调度，占用cpu的时间。即对于cpu的时间片进行抢占。对于每个线程或者进程，如果涉及到切换，都需要从用户态切换到内核态，这个过程，开销比较大。
协程
对于协程，这个属于用户级线程，对于内核来说是透明的。系统不知道协程的存在，是完全由用户自己的程序进行调度的，因为是由用户程序自己控制，那么就很难像抢占式调度那样做到强制的 CPU 控制权切换到其他进程/线程，通常只能进行协作式调度，需要协程自己主动把控制权转让出去之后，其他协程才能被执行到。
goruntine
本质上，goroutine 就是协程。不同的是，Golang 在 runtime、系统调用等多方面对 goroutine 调度进行了封装和处理，当遇到长时间执行或者进行系统调用时，会主动把当前 goroutine 的CPU (P) 转让出去，让其他 goroutine 能被调度并执行，也就是 Golang 从语言层面支持了协程。Golang 的一大特色就是从语言层面原生支持协程，在函数或者方法前面加 go关键字就可创建一个协程。
比较
1、内存消耗方面
每个 goroutine (协程) 默认占用内存远比 Java 、C 的线程少。
goroutine：2KB
线程：8MB

2、线程和 goroutine 切换调度开销方面
线程/goroutine 切换开销方面，goroutine 远比线程小
线程：涉及模式切换(从用户态切换到内核态)、16个寄存器、PC、SP…等寄存器的刷新等。
goroutine：只有三个寄存器的值修改 - PC / SP / DX.

协程底层实现原理

线程是操作系统内核对象，多线程编程时候，如果线程数过多，会导致频繁的上线问切换，浪费cpu的时间。在一些高并发的网络服务器编程中，使用一个线程服务一个 socket 连接是很不明智的。于是操作系统提供了基于事件模式的异步编程模型。用少量的线程来服务大量的网络连接和I/O操作。但是采用异步和基于事件的编程模型，复杂化了程序代码的编写，非常容易出错。因为线程穿插，也提高排查错误的难度。
协程，是在应用层模拟的线程，他避免了上下文切换的额外耗费，兼顾了多线程的优点。简化了高并发程序的复杂度。举个例子，一个高并发的网络服务器，每一个socket连接进来，服务器用一个协程来对他进行服务。代码非常清晰。而且兼顾了性能。

原理：
他和线程的原理是一样的，当 a线程切换到 b线程的时候，需要将 a线程的相关执行进度压入栈，然后将 b线程的执行进度出栈，进入 b线程的执行序列。协程只不过是在应用层实现这一点。但是，协程并不是由操作系统调度的，而且应用程序也没有能力和权限执行 cpu 调度。怎么解决这个问题？
答案是，协程是基于线程的。内部实现上，维护了一组数据结构和 n个线程，真正的执行还是线程，协程执行的代码被扔进一个待执行队列中，由这 n个线程从队列中拉出来执行。这就解决了协程的执行问题。那么协程是怎么切换的呢？答案是：golang 对各种 io函数进行了封装，这些封装的函数提供给应用程序使用，而其内部调用了操作系统的异步io函数，当这些异步函数返回 busy 或 bloking 时，golang 利用这个时机将现有的执行序列压栈，让线程去拉另外一个协程的代码来执行，基本原理就是这样，利用并封装了操作系统的异步函数。包括 linux 的epoll、select 和 windows 的 iocp、event 等。

协程特点归纳
协程（Coroutine）是在1963年由Melvin E. Conway USAF, Bedford, MA等人提出的一个概念。而且协程的概念是早于线程（Thread）提出的。但是由于协程是非抢占式的调度，无法实现公平的任务调用。也无法直接利用多核优势。因此，我们不能武断地说协程是比线程更高级的技术。
基本归纳为：
1、协程调度机制无法实现公平调度
2、协程的资源开销是非常低的，一台普通的服务器就可以支持百万协程。

协程和线程的比较

理论上单个线程占用的内存是8MB ,对于协程来说，协程的量级在KB。通过如下例子来验证下。
案例：用10000次运行一个方法体，这个方法体内很简单的sleep 30秒。看下耗时多少？

理论上，如果开启10000个线程同时做这件事情，那么开销在肯定是>30秒的。由于10000个线程，涉及到的存储是10000*8/1024=78G，电脑无法开启，java会报如下的错误：

Exception in thread "main" java.lang.OutOfMemoryError: unable to create native thread: possibly out of memory or process/resource limits reached
    at java.base/java.lang.Thread.start0(Native Method)
    at java.base/java.lang.Thread.start(Thread.java:803)
    at java.base/java.util.concurrent.ThreadPoolExecutor.addWorker(ThreadPoolExecutor.java:937)
    at java.base/java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1343)
    at java.base/java.util.concurrent.AbstractExecutorService.submit(AbstractExecutorService.java:118)
    at ThreadTest.main(ThreadTest.java:16)

我们采用50个线程，100次循环，这个里面涉及到线程上下问到切换，理论上大于30*2秒的：

1 2	2019-04-18T19:42:29.663997 2019-04-18T19:43:29.682241

源码如下：

public class ThreadTest {
    public static void main(String[] args ){
        ExecutorService executorService = newFixedThreadPool(50);

        CountDownLatch latch = new CountDownLatch(100);

        System.out.println(LocalDateTime.now());
        for(int i = 0 ; i < 100 ; i ++) {
            executorService.submit(() ->{
                try {
                    TimeUnit.SECONDS.sleep(30);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    latch.countDown();
                }
            });
        }
        try {
            latch.await();
            System.out.println(LocalDateTime.now());
            executorService.shutdownNow();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

我们看下goruntine怎么来处理：

func init() {
    runtime.GOMAXPROCS(3)

}
var wg1 sync.WaitGroup
func main() {
    wg1.Add(10000)
    fmt.Println(time.Now())
    for i := 0; i<10000 ; i++ {
        go func() {
            test()
            wg1.Done()
        }()
    }
    wg1.Wait()
    fmt.Println(time.Now())
    //convert("http://1257722377.vod2.myqcloud.com/d7bc634dvodcq1257722377/dc626ff45285890788124008587/playlist2.m3u8")
}

func test() {
    time.Sleep(60 * 1e9)
}

运行结果：

1 2	2019-04-18 19:45:47.862291 +0800 CST m=+0.001222859 2019-04-18 19:46:47.909738 +0800 CST m=+60.048577290

对于10000次的运行，开启协程，在线程基础上执行，轻而易举，整个过程不耗费任何cpu和内存资源

这里有几个说明下：
1、sync.WaitGroup：类似于java的countdownlatch。协调协程和主线程。否则在main执行完后，相应的协程就结束了。不会继续执行。
2、runtime.GOMAXPROCS(3)：使用多少线程来执行协程。官方建议core-1个，性能最佳。本机器是4core,所以取3。

由上可见，goruntine的强大，对于10000个任务，处理轻而易举，而且资源占用率极低，在3个线程的基础上进行。