关于goroutine:Go-并发模型Goroutines

6次阅读

共计 5692 个字符，预计需要花费 15 分钟才能阅读完成。

Goroutines 是 Go 语言次要的并发原语。它看起来十分像线程，然而相比于线程它的 创立和治理老本很低。Go 在运行时将 goroutine 无效地调度到实在的线程上，以避免浪费资源，因而您能够轻松地创立大量的 goroutine（例如每个申请一个 goroutine），并且您能够编写简略的，命令式的阻塞代码。因而，Go 的网络代码往往比其它语言中的等效代码更间接，更容易了解（这点从下文中的示例代码能够看出）。

对我来说，goroutine 是将 Go 这门语言与其它语言辨别开来的一个次要特色。这就是为什么大家更喜爱用 Go 来编写须要并发的代码。在上面探讨更多对于 goroutine 之前，咱们先理解一些历史，这样你就能了解为什么你想要它们了。

高性能服务器须要同时解决来自多个客户端的申请。有很多办法能够设计一个服务端架构来解决这个问题。最容易想到的就是让一个主过程在循环中调用 accept，而后调用 fork 来创立一个解决申请的子过程。这篇 Beej’s Guide to Network Programming 指南中提到了这种形式。

在网络编程中，fork 是一个很好的模式，因为你能够专一于网络而不是服务器架构。然而它很难依照这种模式编写出一个高效的服务器，当初应该没有人在实践中应用这种形式了。

fork 同时也存在很多问题，首先第一个是老本: Linux 上的 fork 调用看起来很快，但它会将你所有的内存标记为 copy-on-write。每次写入 copy-on-write 页面都会导致一个小的页面谬误，这是一个很难测量的小提早，过程之间的上下文切换也很低廉。

另一个问题是规模: 很难在大量子过程中协调共享资源（如 CPU、内存、数据库连贯等）的应用。如果流量激增，并且创立了太多过程，那么它们将互相抢夺 CPU。然而如果限度创立的过程数量，那么在 CPU 闲暇时，大量迟缓的客户端可能会阻塞每个人的失常应用，这时应用超时机制会有所帮忙（无论服务器架构如何，超时设置都是很必要的）。

通过应用线程而不是过程，下面这些问题在肯定水平上能失去缓解。创立线程比创立过程更“便宜”，因为它共享内存和大多数其它资源。在共享地址空间中，线程之间的通信也绝对容易，应用信号量和其它构造来治理共享资源，然而，线程依然有很大的老本，如果你为每个连贯创立一个新线程，你会遇到 扩大问题。与过程一样，你此时须要限度正在运行的线程的数量，以防止重大的 CPU 争用，并且须要使慢速申请超时。创立一个新线程依然须要工夫，只管能够通过应用线程池在申请之间回收线程来缓解这一问题。

无论你是应用过程还是线程，你依然有一个难以答复的问题: 你应该创立多少个线程？如果您容许有限数量的线程，客户端可能会用完所有的内存和 CPU，而流量会呈现小幅激增。如果你限度服务器的最大线程数，那么一堆迟缓的客户端就会阻塞你的服务器。尽管超时是有帮忙的，但它依然很难无效地应用你的硬件资源。

那么既然无奈轻易预测出须要多少线程，当如果尝试将申请与线程解耦时会产生什么呢？如果咱们只有一个线程专门用于利用程序逻辑（或者可能是一个小的、固定数量的线程），而后在后盾应用异步零碎调用解决所有的网络流量，会怎么样？这就是一种事件驱动的服务端架构。

事件驱动架构模式是围绕 select 零碎调用设计的。起初像 poll 这样的机制曾经取代了 select，然而 select 是广为人知的，它们在这里都服务于雷同的概念和目标。select 承受一个文件描述符列表（通常是套接字），并返回哪些是筹备好读写的。如果所有文件描述符都没有筹备好，则抉择阻塞，直到 至多有一个筹备好。

#include <sys/select.h>
#include <poll.h>

int select(int nfds, 
           fd_set *restrict readfds, 
           fd_set *restrict writefds, 
           fd_set *restrict exceptfds, 
           struct timeval *restrict timeout);

int poll(struct pollfd *fds, 
         nfds_t nfds, 
         int timeout);

为了实现一个事件驱动的服务器，你须要跟踪一个 socket 和网络上被阻塞的每个申请的一些状态。在服务器上有一个繁多的主事件循环，它调用 select 来解决所有被阻塞的套接字。当 select 返回时，服务器晓得哪些申请能够进行了，因而对于每个申请，它调用利用程序逻辑中的存储状态。当应用程序须要再次应用网络时，它会将套接字连同新状态一起增加回“阻塞”池中。这里的状态能够是应用程序复原它正在做的事件所需的任何货色: 一个要回调的 closure，或者一个 Promise。

从技术上讲，这些其实都能够用一个线程实现。这里不能议论任何特定实现的细节，然而像 JavaScript
这样不足线程的语言也很好的遵循了这个模型。Node.js 更是将本人形容为“an event-driven JavaScript runtime, designed to build scalable network applications.”

事件驱动的服务器通常比纯正基于 fork 或线程的服务器更好地利用 CPU 和内存。你能够为每个外围生成一个应用程序线程来并行处理申请。线程不会互相抢夺 CPU，因为 线程的数量等于内核的数量。当有申请能够进行时，线程永远不会闲暇，十分高效。效率如此之高，以至于当初大家都应用这种形式来编写服务端代码。

从实践上讲，这听起来不错，然而如果你编写这样的利用程序代码，就会发现这是一场噩梦。。。具体是什么样的噩梦，取决于你所应用的语言和框架。在 JavaScript 中，异步函数通常返回一个 Promise，你给它附加回调。在 Java gRPC 中，你要解决的是 StreamObserver。如果你不小心，你最终会失去很多深度嵌套的“箭头代码”函数。如果你很小心，你就把函数和类离开了，混同了你的控制流。不管怎样，你都是在 callback hell 里。

上面是一个 Java gRPC 官网教程中的一个示例：

public void routeChat() throws Exception {info("*** RoutChat");
  final CountDownLatch finishLatch = new CountDownLatch(1);
  StreamObserver<RouteNote> requestObserver =
      asyncStub.routeChat(new StreamObserver<RouteNote>() {
        @Override
        public void onNext(RouteNote note) {info("Got message \"{0}\"at {1}, {2}", note.getMessage(), note.getLocation()
              .getLatitude(), note.getLocation().getLongitude());
        }

        @Override
        public void onError(Throwable t) {Status status = Status.fromThrowable(t);
          logger.log(Level.WARNING, "RouteChat Failed: {0}", status);
          finishLatch.countDown();}

        @Override
        public void onCompleted() {info("Finished RouteChat");
          finishLatch.countDown();}
      });

  try {RouteNote[] requests =
        {newNote("First message", 0, 0), newNote("Second message", 0, 1),
            newNote("Third message", 1, 0), newNote("Fourth message", 1, 1)};

    for (RouteNote request : requests) {info("Sending message \"{0}\"at {1}, {2}", request.getMessage(), request.getLocation()
          .getLatitude(), request.getLocation().getLongitude());
      requestObserver.onNext(request);
    }
  } catch (RuntimeException e) {
    // Cancel RPC
    requestObserver.onError(e);
    throw e;
  }
  // Mark the end of requests
  requestObserver.onCompleted();

  // Receiving happens asynchronously
  finishLatch.await(1, TimeUnit.MINUTES);
}

下面代码官网的初学者教程，它不是一个残缺的例子，发送代码是同步的，而接管代码是异步的。在 Java 中，你可能会为你的 HTTP 服务器、gRPC、数据库和其它任何货色解决不同的异步类型，你须要在所有这些服务器之间应用适配器，这很快就会变得一团糟。

同时这里如果应用锁也很危险，你须要小心跨网络调用持有锁。锁和回调也很容易犯错误。例如，如果一个同步办法调用一个返回 ListenableFuture 的函数，而后附加一个内联回调，那么这个回调也须要一个同步块，即便它嵌套在父办法外部。

终于到了咱们的配角——goroutines。它是 Go 语言版本的线程。像它语言（比方：Java）中的线程一样，每个 gooutine 都有本人的堆栈。goroutine 能够与其它 goroutine 并行执行。与线程不同，goroutine 的创立老本非常低:它不绑定到 OS 线程上，它的堆栈开始十分小（初始只有 2 K），但能够依据须要增长。当你创立一个 goroutine 时，你实际上是在调配一个 closure，并在运行时将其增加到队列中。

在外部实现中，Go 的运行时有一组执行程序的 OS 线程（通常每个内核一个线程）。当一个线程可用并且一个 goroutine 筹备运行时，运行时将这个 goroutine 调度到线程上，执行利用程序逻辑。如果一个运行例程阻塞了像 mutex 或 channel 这样的货色时，运行时将它增加到阻塞的运行 goroutine 汇合中，而后将下一个就绪的运行例程调度到同一个 OS 线程上。

这也实用于网络: 当一个线程程序在未筹备好的套接字上发送或接收数据时，它将其 OS 线程交给调度器。这听起来是不是很相熟？Go 的调度器很像事件驱动服务器中的主循环。除了仅仅依赖于 select 和专一于文件描述符之外，调度器解决语言中可能阻塞的所有内容。

你不再须要防止阻塞调用，因为调度程序能够无效地利用 CPU。能够自在地生成许多 goroutine（能够每个申请一个!），因为创立它们的老本很低，而且不会抢夺 CPU，你不须要放心线程池和执行器服务，因为运行时实际上有一个大的线程池。

简而言之，你能够用洁净的命令式格调编写简略的阻塞利用程序代码，就像在编写一个基于线程的服务器一样，但你保留了事件驱动服务器的所有效率劣势，两败俱伤。这类代码能够很好地跨框架组合。你不须要 streamobserver 和 ListenableFutures 之间的这类适配器。

上面让咱们看一下来自 Go gRPC 官网教程的雷同示例。能够发现这里的控制流比 Java 示例中的更容易理
解，因为 发送和接管代码都是同步的。在这两个 goroutines 中，咱们都能够在一个 for 循环中调用 stream.Recv 和 stream.Send。不再须要回调、子类或执行器这些货色了。

stream, err := client.RouteChat(context.Background())
waitc := make(chan struct{})
go func() {
  for {in, err := stream.Recv()
    if err == io.EOF {
      // read done.
      close(waitc)
      return
    }
    if err != nil {log.Fatalf("Failed to receive a note : %v", err)
    }
    log.Printf("Got message %s at point(%d, %d)", in.Message, in.Location.Latitude, in.Location.Longitude)
  }
}()
for _, note := range notes {if err := stream.Send(note); err != nil {log.Fatalf("Failed to send a note: %v", err)
  }
}
stream.CloseSend()
<-waitc

如何你应用 Java 这门语言，到目前为止，你要么必须生成数量不合理的线程，要么必须解决 Java 特有的回调天堂。令人高兴的是，JEP 444 中减少了 virtual threads，这看起来很像 Go 语言中的 goroutine。

创立虚构线程的老本很低。JVM 将它们调度到平台线程（platform threads，内核中的实在线程）上。平台线程的数量是固定的，个别每个内核一个平台线程。当一个虚构线程执行阻塞操作时，它会开释它的平台线程，JVM
可能会将另一个虚构线程调度到它下面。与 gooutine 不同，虚构线程调度是合作的: 虚构线程在执行阻塞操作之前不会遵从于调度程序。这意味着紧循环能够无限期地放弃线程。目前不分明这是实现限度还是有更深层次的问题。Go 以前也有这个问题，直到 1.14 才实现了齐全抢占式调度（可见 GopherCon 2021）。

Java 的虚构线程当初能够预览，预计在 JDK 21 中成为 stable（官方消息是预计 2023 年 9 月公布）状态。哈哈，很期待到时候能删除大量的 ListenableFutures。每当引入一种新的语言或运行时个性时，都会有一个漫长的迁徙过渡期，集体认为 Java 生态系统在这方面还是过于激进了。

正文完