标签 C 下的文章

图解Go运行时调度器

本文翻译自《Illustrated Tales of Go Runtime Scheduler》

译注:原文章结构有些乱,笔者自行在译文中增加了一些分级标题,让结构显得更清晰一些:)。

goroutines形式的Go并发是编写现代并发软件的一种非常方便的方法,但是您的Go程序是如何高效地运行这些goroutines的呢?

在这篇文章中,我们将深入Go运行时底层,从设计角度了解Go运行时调度程序是如何实现其魔法的,并运用这些原理去解释在Go性能调试过程中产生的Go调度程序跟踪信息

所有的工程奇迹都源于需要。因此,要了解为什么需要一个Go运行时调度程序以及它是如何工作的,我们可以让时间回到操作系统兴起的那个时代,回顾操作系统的历史可以使我们深入的了解问题的根源。如果不了解问题的根源,就没有解决它的希望。这就是历史所能做的。

一. 操作系统的历史

  1. 单用户(无操作系统)。
  2. 批处理,独占系统,直到运行完成。
  3. 多道程序(译注:允许多个程序同时进入内存并运行)

多道程序的目的是使CPU和I/O重叠(overlap)。(译注:多道程序出现之前,当操作系统执行I/O操作时,CPU是空闲的;多道程序的引入实现了在一个程序占用CPU的时候,另一个程序在执行I/O操作)

那怎么实现多道程序(的CPU与I/O重叠)呢?两种方式:多道批处理系统和分时系统。

  • 多道批处理系统

    • IBM OS/MFT(具有固定数量的任务的多道程序)
    • IBM OS/MVT(具有可变数量的任务的多道程序)在这里,每个作业(job)仅获得其所需的内存量。随着job的进出,内存的划分会发生变化。
  • 分时

    • 这是一种多道程序设计,可以在作业之间快速切换。决定何时切换以及切换到哪个作业的过程就称为调度(scheduling)

当前,大多数操作系统使用分时调度程序

那么这些调度程序将用来调度什么实体(entity)呢?

  • 不同的正在执行的程序(即进程process)
  • 或作为进程子集存在使用CPU的基本单元:线程

但是在这些实体的切换是有代价的。

  • 调度成本

img{512x368}

图: 进程和线程的状态变量

因此,使用一个包含多个线程的进程的效率更高,因为进程创建既耗时又耗费资源。但是随后出现了多线程问题:C10k成为主要问题。

例如,如果将调度周期定为10ms(毫秒),并且有2个线程,则每个线程将分别获得5ms。如果您有5个线程,则每个线程将获得2ms。但是,如果有1000个线程怎么办?给每个线程一个10μs(微秒)的时间片?错,这样做很愚蠢,因为您将花费大量时间进行上下文切换,但是真正要完成的工作却进展缓慢或停滞不前。

您需要限制时间片的长度。在最后一种情况下,如果最小时间片为2ms并且有1000个线程,则调度周期需要增加到2s(10002ms)。如果有10,000个线程,则调度程序周期为20秒(100002ms)。在这个简单的示例中,如果每个线程都将分配给它的时间片用完,那么所有线程都完成一次运行需要20秒。因此,我们需要一些可以使并发成本降低而又不会造成过多开销的东西。

  • 用户层线程
    • 线程完全由运行时系统(用户级库)管理。
    • 理想情况下,快速高效:切换线程的代价不比函数调用多多少。
    • 操作系统内核对用户层线程一无所知,并像对待单线程进程(single-threaded process)一样对其进行管理。

在Go中,我们知道这样的用户层线程被称为“Goroutine”。

  • Goroutine

img{512x368}

图: goroutine vs. 线程

goroutine是由Go运行时管理的轻量级线程(lightweight thread)。要启动一个新的goroutine,只需在函数前面使用go关键字:go add(a, b)

  • Goroutine之旅
func main() {
    var wg sync.WaitGroup
    for i := 0; i <= 10; i++ {
        wg.Add(1)
        go func(i int) {
        defer wg.Done()
        fmt.Printf("loop i is - %d\n", i)
        }(i)
    }
    wg.Wait()
    fmt.Println("Hello, Welcome to Go")
}

https://play.golang.org/p/73lESLiva0A

您能猜出上面代码片段的输出吗?

loop i is - 10
loop i is - 0
loop i is - 1
loop i is - 2
loop i is - 3
loop i is - 4
loop i is - 5
loop i is - 6
loop i is - 7
loop i is - 8
loop i is - 9
Hello, Welcome to Go

如果我们看一下输出的一种组合,你可能马上就会有两个问题:

  • 11个goroutine如何并行运行?魔法?
  • goroutine以什么顺序运行?

img{512x368}

图:gopher版奇异博士

上面的这两个提问给我们带来了问题。

  • 问题概述
    • 如何将这些goroutines分配到在CPU处理器上运行的多个操作系统线程上运行?
    • 这些goroutines应该以什么顺序运行才能保证公平?

本文后续的讨论将主要围绕Go运行时调度程序从设计角度如何解决这些问题。但是,与所有问题一样,我们的讨论也需要定义一个明确的边界。否则,问题陈述可能太含糊,无法形成结论。调度程序可能针对多个目标中的一个或多个,对于我们来说,我们将自己限制在以下需求之内:

  1. 应该是并行、可扩展且公平的。
  2. 每个进程应可扩展到数百万个goroutine(C10M
  3. 内存利用率高。(RAM很便宜,但不是免费的。)
  4. 系统调用不应导致性能下降。(最大化吞吐量,最小化等待时间)

让我们开始为调度程序建模,以逐步解决这些问题。

二. Goroutine调度程序模型 (译者自行加的标题)

1. 模型概述(译者自行加的标题)

a) 一个线程执行一个Goroutine

局限性:

  • 并行和可扩展
    • 并行(是的)
    • 可扩展(不是真的)
  • 每个进程不能扩展到数百万个goroutine(C10M)。

b) M:N线程—混合线程

M个操作系统内核线程执行N个“goroutine”

img{512x368}

图: M个内核线程执行N个goroutine

实际执行代码和并行执行都需要内核线程。但是线程创建起来很昂贵,因此我们将N个goroutines映射到M个内核线程上去执行。Goroutine是Go代码,因此我们可以完全控制它。而且它在用户空间中,创建起来很便宜。

但是由于操作系统对goroutine一无所知。因此每个goroutine都有一个状态,以帮助调度器根据goroutine状态知道要运行哪个goroutine。与内核线程的状态信息相比,goroutine的状态信息很小,因此goroutine的上下文切换变得非常快。

  • 正在运行(Running) – 当前在内核线程上运行的goroutine。
  • 可运行(Runnable) – 等待内核线程来运行的goroutine。
  • 已阻塞(Blocked) – 等待某些条件的Goroutine(例如,阻塞在channel操作,系统调用,互斥锁上的goroutine)

img{512x368}

图: 2个线程同时运行2个goroutine

因此,Go运行时调度器通过将N个Goroutine多路复用到M个内核线程的方式来管理处于各种不同状态的goroutines。

2. 简单的M:N调度器

在我们简单的M:N调度器中,我们有一个全局运行队列(global run queue),某些操作将一个新的goroutine放入运行队列。M个内核线程访问调度程序从“运行队列”中获取并运行goroutine。多个线程正在尝试访问相同的内存区域,因此使用互斥锁来同步对该运行队列的访问。

img{512x368}

图: 简单的M:N调度器

但是,那些已阻塞的goroutine在哪里?

下面是goroutine可能会阻塞的情况:

  1. 在channel上发送和接收
  2. 网络I/O操作
  3. 阻塞的系统调用
  4. 使用定时器
  5. 使用互斥锁

那么我们将这些阻塞的goroutine放在哪里呢?— 将这些阻塞的goroutine放置在哪里的设计决策基本上是围绕一个基本原理进行的:

阻塞的goroutine不应阻塞底层内核线程!(避免线程上下文切换的成本)

channel操作期间阻塞的Goroutine

每个channel都有一个recvq(waitq),用于存储试图从该channel读取数据而阻塞的goroutine。

Sendq(waitq)存储试图将数据发送到channel而被阻止的goroutine 。(channel实现原理:-https://codeburst.io/diving-deep-into-the-golang-channels-549fd4ed21a8)

img{512x368}

图: channel操作期间阻塞的Goroutine

channel本身会将channel操作后的未阻塞goroutine放入“运行”队列(run queue)。

img{512x368}

图: channel操作后未阻碍的goroutine

那系统调用呢?

首先,让我们看一下阻塞系统调用。系统调用会阻塞底层内核线程,因此我们无法在该线程上调度任何其他Goroutine。

隐含阻塞系统调用可降低并行度。

img{512x368}

图: 阻塞系统调用可降低并行度

一旦发生阻塞系统调用,我们无法再在M2线程上安排任何其他Goroutine运行,从而导致CPU浪费。由于我们有工作要做,但没法运行它。

恢复并行度的方法是在进入系统调用时,我们可以唤醒另一个线程,该线程将从运行队列中选择可运行的goroutine。

img{512x368}

图: 恢复并行度的方法

但是现在,系统调用完成后,我们有超额等待调度的goroutine。因此,我们不会立即运行从阻塞系统调用中返回的goroutine。我们会将其放入调度程序的运行队列中。

img{512x368}

图: 避免超额等待调度

因此,在程序运行时,线程数远大于cpu核数。尽管没有明确说明,线程数大于cpu核数,并且所有空闲线程也由运行时管理,以避免启动过多的线程。

https://golang.org/pkg/runtime/debug/#SetMaxThreads

初始设置为10,000个线程,如果超过10,000个线程,程序将崩溃。

非阻塞系统调用-将goroutine阻塞在Integrated runtime poller上 ,并释放线程以运行另一个goroutine。

img{512x368}

例如,在非阻塞I/O(例如HTTP调用)的情况下。由于资源尚未准备就绪,第一个syscall将不会成功,这将迫使Go使用network poller并将goroutine暂停。

部分net.Read函数的实现:

    n, err := syscall.Read(fd.Sysfd, p)
        if err != nil {
            n = 0
            if err == syscall.EAGAIN && fd.pd.pollable() {
                if err = fd.pd.waitRead(fd.isFile); err == nil {
                    continue
                }
            }
    }

一旦完成第一个系统调用并明确指出资源尚未准备就绪,goroutine将暂停,直到network poller通知它资源已准备就绪。在这种情况下,线程M将不会被阻塞。

Poller将基于操作系统使用select/kqueue/epoll/IOCP等机制来知道哪个文件描述符已准备好,一旦文件描述符准备好进行读取或写入,它将把goroutine放回到运行队列中。

还有一个Sysmon OS线程,如果超过10ms未轮询网络,它就将定期轮询网络,并将已就绪的G添加到队列中。

基本上所有goroutine都被阻塞在下面操作上:

  1. channel
  2. 互斥锁
  3. 网络IO
  4. 定时器

有某种队列,可以帮助调度这些goroutine。

现在,运行时拥有具有以下功能的调度程序。

  • 它可以处理并行执行(多线程)。
  • 处理阻塞系统调用和网络I/O。
  • 处理阻塞在用户级别(在channel上)的调用。

但这不是可伸缩的(scalable)。

img{512x368}

图: 使用Mutex同步全局运行队列

您可以通过Mutex同步全局运行队列,但最终会遇到一些问题,例如

  1. 缓存一致性保证的开销。
  2. 在创建,销毁和调度Goroutine G时进行激烈的锁竞争。

使用分布式调度程序解决可伸缩性问题。

分布式调度程序-每个线程一个运行队列

img{512x368}

图: 分布式运行队列的调度程序

这样,我们可以看到的直接好处是,每个线程的本地运行队列(local run queue)现在都没有使用mutex。仍然有一个带有mutex的全局运行队列,但仅在特殊情况下使用。它不会影响可伸缩性。

但是现在,我们有多个运行队列。

  1. 本地运行队列
  2. 全局运行队列
  3. 网络轮询器(network poller)

我们应该从哪里运行下一个goroutine?

在Go中,轮询顺序定义如下:
1. 本地运行队列
2. 全局运行队列
3. 网络轮询器
4. 工作偷窃(work stealing)

即首先检查本地运行队列,如果为空则检查全局运行队列,然后检查网络轮询器,最后进行“偷窃工作”。到目前为止,我们对1,2,3有了一些概述。让我们看一下“工作偷窃(work stealing)”。

工作偷窃

如果本地工作队列为空,请尝试“从其他队列中偷窃工作”

img{512x368}

图: 偷窃工作

当一个线程有太多工作要做而另一个线程空闲时,工作偷窃可以解决这个问题。在Go中,如果本地队列为空,工作偷窃将尝试满足以下条件之一。

  • 从全局队列中拉取工作。
  • 从网络轮询器中拉取工作
  • 从其他线程的本地队列中偷窃工作

到目前为止,Go运行时的调度器具有以下功能:

  • 它可以处理并行执行(使用多线程)。
  • 处理阻塞系统调用和网络I/O。
  • 处理用户级别(比如:在channel)的阻塞调用。
  • 可伸缩扩展(scalable)

但这仍不是最有效的。

还记得我们在阻塞系统调用中恢复并行度的方式吗?

img{512x368}

图: 系统调用操作

它暗示在一个系统调用中我们可以有多个内核线程(可以是10或1000),这可能会比cpu核数多很多。这个方案将最终在以下期间产生了恒定的开销:

  • 偷窃工作时,它必须同时扫描所有内核线程(空闲的和运行goroutine的)本地运行队列,并且大多数都将是空闲的。
  • 垃圾回收,内存分配器都会遇到相同的扫描问题。(https://blog.learngoprogramming.com/a-visual-guide-to-golang-memory-allocator-from-ground-up-e132258453ed)

使用M:P:N线程克服效率问题。

M:P:N(3级调度程序)— 引入逻辑处理器P

P —表示处理器,可以将其视为在线程上运行的本地调度程序

img{512x368}

图: M:P:N模型

逻辑进程P的数量始终是固定的。(默认为当前进程可以使用的逻辑CPU数量)

然后,我们将本地运行队列(LRQ)放入固定数量的逻辑处理器(P)中(译者注:而不是每个内核线程一个本地运行队列)。

img{512x368}

图: 分布式三级运行队列调度程序

Go运行时将首先根据计算机的逻辑CPU数量(或根据请求)创建固定数量的逻辑处理器P。

每个goroutine(G)将在分配了逻辑CPU(P)的OS线程(M)上运行。

所以现在我们在以下期间没有了恒定的开销:

  • 偷窃工作 -只需扫描固定数量的逻辑处理器(P)的本地运行队列。
  • 垃圾回收,内存分配器也将获得相同的好处。

使用固定逻辑处理器(P)的系统调用呢?

Go通过将它们包装在运行时中来优化系统调用(无论是否阻塞)。

img{512x368}

图: 阻塞系统调用的包装器

阻塞SYSCALL方法封装在runtime.entersyscall(SB)和 runtime.exitsyscall(SB)之间。

从字面上看,某些逻辑在进入系统调用之前被执行,而某些逻辑在系统调用返回之后执行。进行阻塞的系统调用时,此包装器将自动将P与线程M(即将执行阻塞系统调用的线程)解绑,并允许另一个线程在其上运行。

img{512x368}

图:阻塞Syscall的M交出P

这使得Go运行时可以高效地处理阻塞的系统调用,而无需增加运行队列(译注:本地运行队列数量始终是和P数量一致的)。

一旦阻塞系统调用返回,会发生什么?

  • 运行时会尝试获取之前绑定的那个P,然后继续执行。
  • 运行时尝试在P空闲列表中获取一个P并恢复执行。
  • 运行时将goroutine放在全局队列中,并将关联的M放回M空闲列表。

自旋线程和空闲线程

当M2线程在syscall返回后变得空闲时。如何处理这个空闲的M2线程。从理论上讲,如果线程完成了所需的操作,则应将其销毁,然后再安排进程中的其他线程到CPU上执行。这就是我们通常所说的操作系统中线程的“抢占式调度”。

考虑上述syscall中的情况。如果我们销毁了M2线程,而同时M3线程即将进入syscall。此时,在OS创建新的内核线程并将其调度执行之前,我们无法处理可运行的goroutine。频繁的线程前抢占操作不仅会增加OS的负载,而且对于性能要求更高的程序几乎是不可接受的。

因此,为了适当地利用操作系统的资源并防止频繁的线程抢占给操作系统带来的负担,我们不会销毁内核线程M2,而是使其执行自旋操作并以备将来使用。尽管这看起来是在浪费一些资源。但是,与线程之间的频繁抢占以及频繁的创建和销毁操作相比,“空闲线程”要付出的代价更少。

Spinning Thread(自旋线程) — 例如,在具有一个内核线程M(1)和一个逻辑处理器(P)的Go程序中,如果正在执行的M被syscall阻塞,则运行时会请求与P数量相同的“Spinning Threads”以允许等待的可运行goroutine继续执行。因此,在此期间,内核线程的数量M将大于P的数量(自旋线程+阻塞线程)。因此,即使将runtime.GOMAXPROCS的值设置为1,程序也将处于多线程状态。

调度中的公平性如何?—公平地选择下一个要执行的goroutine

与许多其他调度程序一样,Go也具有公平性约束,并且由goroutine的实现所强加,因为Runnable goroutine应该最终得到调度并运行。

这是Go Runtime Scheduler的四个典型的公平性约束:

任何运行时间超过10ms的goroutine都被标记为可抢占(软限制)。但是,抢占仅在函数执行开始处才能完成。Go当前在函数开始处中使用了由编译器插入的协作抢占点。

  • 无限循环 – 抢占(约10毫秒的时间片)- 软限制

但请小心无限循环,因为Go的调度程序不是抢先的(直到Go 1.13)。如果循环不包含任何抢占点(例如函数调用或分配内存),则它们将阻止其他goroutine的运行。一个简单的例子是:

package main

func main() {
    go println("goroutine ran")
    for {}
}

如果你运行:

GOMAXPROCS=1 go run main.go

直到Go(1.13)才可能打印该语句。由于缺少抢占点,main Goroutine将独占处理器。

  • 本地运行队列 -抢占(〜10ms时间片)- 软限制
  • 通过每61次调度就检查一次全局运行队列,可以避免全局运行队列处于“饥饿”状态。
  • 网络轮询器饥饿 后台线程会在主工作线程未轮询的情况下偶尔会轮询网络。

Go 1.14有一个新的“非合作抢占”机制。

有了这种机制,Go运行时便有了具有所有必需功能的Scheduler。

  • 它可以处理并行执行(多线程)。
  • 处理阻塞系统调用和网络I/O。
  • 处理用户级别(在channel上)的阻塞调用。
  • 可扩展
  • 高效
  • 公平

这提供了大量的并发性,并且始终尝试实现最大的利用率和最小的延迟。

现在,我们总体上对Go运行时调度程序有了一些了解,我们如何使用它?Go为我们提供了一个跟踪工具,即调度程序跟踪(scheduler trace),目的是提供有关调度行为的信息并用来调试与goroutine调度器伸缩性相关的问题。

三. 调度器跟踪

使用GODEBUG=schedtrace=DURATION环境变量运行Go程序以启用调度程序跟踪。(DURATION是以毫秒为单位的输出周期。)

img{512x368}

图:以100ms粒度对schedtrace输出采样

有关调度器跟踪的内容,Go Wiki拥有更多信息。

参考:Dmitry Vyukov的可扩展Go Scheduler设计文档和演讲 https://docs.google.com/document/d/1TTj4T2JO42uD5ID9e89oa0sLKhJYD0Y_kqxDv3I3XMw/edit

Gopher艺术作品致谢:Ashley Mcnamara。


我的网课“Kubernetes实战:高可用集群搭建、配置、运维与应用”在慕课网上线了,感谢小伙伴们学习支持!

我爱发短信:企业级短信平台定制开发专家 https://51smspush.com/
smspush : 可部署在企业内部的定制化短信平台,三网覆盖,不惧大并发接入,可定制扩展; 短信内容你来定,不再受约束, 接口丰富,支持长短信,签名可选。

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式:

微博:https://weibo.com/bigwhite20xx
微信公众号:iamtonybai
博客:tonybai.com
github: https://github.com/bigwhite

微信赞赏:
img{512x368}

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

Go语言之禅

本文翻译自Go社区知名Gopher和博主Dave Cheney的文章《The Zen of Go》

img{512x368}

本文来自我在GopherCon Israel 2020上的演讲。文章很长:) 如果您希望阅读精简版,请移步到the-zen-of-go.netlify.com

该演讲视频还未上线。如上线,我会把它更新到本文中的。

我应该如何编写出好代码?

我最近一直在思考很多事情,每当反思自己的工作成果时,眼前常会出现一行字幕:我该如何编写出好代码? 主观上,没人愿意去编写糟糕的代码,那么问题来了:你是怎么知道你编写出好的Go代码了呢?

如果好与坏之间存在连续性,那么我们怎么知道哪些是好的部分?它的特性、属性、标志、模式和惯用法又是什么呢?

Go语言惯用法(idiomatic Go)

img{512x368}

这让我走进Go惯用法。说某种东西是惯用的,就是说它遵循了时代的风格。如果某些东西不是惯用的,那它没有遵循流行的风格,感觉不时髦。

更重要的是,对某人说他们的代码不复合惯用法并不能解释为什么这些代码不符合惯用法。为什么会这样?像所有真相一样,答案可以在词典中找到:

idiom (noun): a group of words established by usage as having a meaning not deducible from those of the individual words.
惯用法(名词):一组由用法确定的且其含义无法从单个单词的含义中推导出来的单词。

惯用法是共享价值观(value)的标志。Go惯用法不是您从书本中学到的东西,而是通过成为社区的一部分而获得的

img{512x368}

Go惯用法字样用多了,便形成了“口头禅”,这引起我的担忧:这种口头禅在许多方面它可能是具有排他性的。比如:有人说“你不能和我们坐在一起。” 但毕竟这不是我们批评某人的代码不符合惯用法时的索要表达的意思,是吧?他们只是没有做对,看起来不对,它没有遵循流行的风格而已。

我认为Go惯用法不是教如何编写好的Go代码的合适机制,因为从根本上说,它仍然告诉某人做错了(译注:这容易引起对方反感)。如果在他们最愿意接受建议的时候,我们给出让他们不感觉疏远的建议是否会更好些?

谚语(Proverbs)

摆脱有问题的惯用法,Gopher们还有哪些其他的文化手工艺品吗?也许我们可以转向Rob Pike精彩的Go 谚语。这些谚语是合适的教学工具吗?它们会告诉Go新手如何编写好的Go代码吗?

总的来说,我不这么认为。这并不是要驳斥Rob Pike的作品。只是像濑越宪作(Segoe Kensaku)的原著一样,Go谚语只是观察,而不是价值观的陈述。我们再次搬出字典:

proverb (noun): a short, well-known pithy saying, stating a general truth or piece of advice.
谚语(名词):简短而众所周知的俗语,陈述一般的真理或一段忠告。

Go Proverbs的目的是揭示有关语言设计的更深层次的真理,但是像empty interface says nothing这样的建议对于一个来自商没有结构化类型的语言的新手来说有什么用呢?

重要的是要认识到,在一个不断发展的社区中,任何时候学习Go语言的人的数量都远超过那些声称掌握了该语言的人的数量。因此,在这种情况下,谚语可能也不是最佳的教学工具。

工程价值观

丹·卢(Dan Luu)找到了马克·卢科夫斯基(Mark Lucovsky)关于Windows团队在Windows NT-Windows 2000开发阶段时的工程文化的演讲。我之所以提到它,是因为卢科夫斯基将一种文化描述为一种评估设计和权衡取舍的常用方法。

img{512x368}

讨论文化的方法有很多,但是就工程文化而言,Lucovsky的描述是恰当的。其中心思想是在未知的设计空间中用价值观指导决策。Windows NT团队的价值观是:可移植性,可靠性,安全性和可扩展性。粗略地说工程价值观就是在这里完成工作的方式。

Go的价值观

Go的显式价值观是什么呢?定义Go程序员解释世界方式的核心信念或哲学又是什么?他们如何发布宣传?他们怎么传授?如何执行?它们又是如何随着时间变化的?

作为新Go程序员,您将如何被灌输Go的工程价值观?或者,你是一位经验丰富的Go专家,你如何将你的价值观传播给“下一代”?就像我们知道的那样,知识传递的过程不是一个可选项。没有新的血液和新的观念,我们的社区将变得短视和枯萎。

其他语言的价值观

为了给我所要了解的场景做铺垫,我们可以先看看其他语言,我们看看它们的工程价值观。

例如,C++(包括其扩展:Rust)认为程序员不必为自己不使用的特性付费。如果程序未使用该语言的某些计算成本昂贵的特性,则不应强迫该程序承担该特性的成本。该价值观从语言扩展到其标准库,并用作判断所有用C++编写的代码设计的标准。

在Java,Ruby和Smalltalk中,一切都是对象的核心价值观驱动着围绕着消息传递,信息隐藏和多态的程序设计风格。在程序中采用过程式或函数式设计风格会被认为是错误的,或者按照Gophers的说法,是不符合惯用法的。

回到我们自己的Go社区,烙印在Go程序员心中的工程价值观是什么呢?在我们社区中的讨论是很容易引战的,因此要从第一条原则衍生出一套价值观念将是一个巨大的挑战。共识很关键,但随着讨论贡献者数量的增加,难度就成倍增加。但是,如果有人已经为我们完成了这些艰苦的工作了呢?

~~Python~~ Go之禅

几十年前,蒂姆·彼得斯(Tim Peters)坐下来写下了PEN-20(Python之禅)。Peters试图记录他认为Guido van Rossum(Python之父)在Python社区扮演的BDFL(仁慈的独裁者)角色时所应用的工程价值观。

在本文的剩余部分中,我将着眼于Python之禅,并问问大家:是否有什么可以用来揭秘Go程序员的工程价值观的?

一个好的package始于一个好名字

让我们从香辛的东西开始

“Namespaces are one honking great idea–let’s do more of those!” The Zen of Python, Item 19
“命名空间是一个很棒的主意-让我们多做些吧!” Python之禅,条款19

这是相当明确的,Python程序员应该使用命名空间,多多益善。

package就是Go语言的命名空间。我怀疑是否有人质疑将组件分组到程序包中利好设计和潜在重用。但关于这么做的正确方法的困惑肯定会有的,尤其是你拥有另一门语言10年的使用经验。

在Go中,每个程序包都应有一个目的/用途,而了解程序包目的/用途的最佳方法是通过其名字-一个名词。包的名字描述了它提供的内容。因此,这里重新解释一下Peters的话:每个Go软件包(package)都应该仅有一个单一的目的/用途。

这不是一个新主意,我已经说了一段时间了,但是为什么要这样做而不是使用将软件包用于细粒度分类的方法呢?为什么,因为变化(change)。

“Design is the art of arranging code to work today, and be changeable forever.” - Sandi Metz
“设计是安排代码以使其至今天仍然可以工作并且永远可以更改的艺术。” - 桑迪·梅斯

变化是我们所从事的游戏的名称(译注:这里的游戏指代程序开发工作)。作为程序员,我们要做的就是管理变变化。当我们做得很好时,我们称之为设计或架构。当我们做得不好时,我们称其为技术债务或遗留代码。

如果你编写的程序对于一组固定的输入可以一次性地完美地工作,那么没人会在乎代码的好坏,因为最终程序的输出才是企业和业务所关心的。

但这是不正确的。软件具有缺陷(bug),需求变更,输入变更,并且很少有程序被编写为仅执行一次,因此您的程序会随着时间而变化。可能是您要为此承担任务,更有可能是其他人,但是必须更改该代码。有人必须维护该代码。

那么,如何使程序更改变得容易呢?无所不在的接口?使一切变得易于mock?邪恶的依赖注入(译注:作者对DI似乎很排斥,用了带有感情色彩的词汇)?好吧,也许,对于某类程序,但不是很多,这些技术将很有用。但是,对于大多数程序而言,预先设计一些灵活的方法要比工程设计更为重要。

相反,如果我们采取的立场是取代组件而不是增强组件,该怎么办?知道何时需要更换某些物品的最佳方法是什么时候该物品没有按照锡盒/罐头盒上的说明进行操作。

一个好的包始于选择一个好的名字。把你的包名字想象成电梯游说(Elevator pitch,即用极具吸引力的方式简明扼要地阐述自己的观点), 仅用一个词就可以描述包的内容。当名字不再符合要求时,请查找替代名字。

简单性很重要

“Simple is better than complex.” - The Zen of Python, Item 3
“简单胜于复杂。” - Python之禅,条款3

PEP-20说:简单胜于复杂,我完全同意。几年前,我发布了这条推文:

大多数编程语言开始都是为了简单,但最终只是为了功能强大而努力。— Dave Cheney(@davecheney)2014年12月2日

至少在当时,我的观察是,我想不出一生中使用的哪门语言不标榜着简单。每种新语言都为其固有的简单性提供了理由和诱因。但是,当我研究时,我发现简单性并不是与Go语言同时代的许多现代语言的核心价值观。也许这只是一个便宜的镜头1,但是可能是这些语言不是很简单,或者它们不认为自己很简单。他们不认为简单是其核心价值观。

但是什么时候简单变得过时了?为什么商业软件开发行业会忘记这个基本原则?

“There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult.” - C. A. R. Hoare, The Emperor’s Old Clothes, 1980 Turing Award Lecture

“构建软件设计的方式有两种:一种方式是使其变得如此简单,以至于显然没有缺陷,另一种方式是使得它变得如此复杂以至于没有明显的缺陷。第一种方法要困难得多。” - CAR Hoare,皇帝的旧衣,1980年图灵奖演讲

我们知道:简单并不意味着容易。通常,使某些东西易于使用而不是易于构建需要更多的工作。

“Simplicity is prerequisite for reliability.” - Edsger W Dijkstra, EWD498, 18 June 1975
“简单性是可靠性的前提。”-  埃兹格·迪克斯特拉(Essger W Dijkstra),EWD498,1975年6月18日

我们为什么要追求简单?为什么Go程序简单很重要?简单并不意味着粗糙,它意味着可读性和可维护性。简单并不意味着“不复杂”,它意味着可靠,有共鸣且易于理解。

“Controlling complexity is the essence of computer programming.” - Brian W. Kernighan, Software Tools (1976)
“控制复杂性是计算机编程的本质。” - Brian W. Kernighan,软件工具  (1976)

Python是否遵守其简单性的说法尚有争议,但Go坚持将简单性作为核心价值观。我认为我们都可以认同,就Go而言,简单代码比聪明代码更可取

避免包级别状态

“Explicit is better than implicit.” - The Zen of Python, Item 2
“显式胜于隐式。” - Python的禅宗,第2项

我认为彼得斯在这个地方的抱负胜于实际。Python中的许多内容并不明确;装饰器,dunder方法(译注:不知此为何物)等。毫无疑问,这些特性的功能强大,存在这些特性是有原因的。每个特性都是因某人非常关心的事情,尤其是复杂的特性。但是大量使用这些特性使读者很难预测操作的成本。

好消息是,像Go程序员一样,我们可以选择显式代码。显式可能意味着很多事情,也许您可能认为显式只是一种表达官僚主义和漫长风气的好方法,但这只是肤浅的解释。只关注页面的语法、烦恼行长和自制表达式是一种错误的说法。在我看来,更有价值的地方是与耦合和状态有关。

耦合(coupling)是衡量一件东西依赖另一件东西的数量的方法。如果两件事紧密结合,它们就会一起运动。影响其中一个事物的行为会直接反映在另一个事物中。想象一下,一列火车,每个车厢连在一起;发动机行驶到哪里,车厢就跟随到哪里。

描述耦合的另一种方法是内聚(cohesion)一词。内聚衡量两件事自然地在一起的程度。当我们进行一个内聚的争论,或者一个内聚的团队,它们的所有零件都可以自然装配在一起,就像设计的一样。

为什么耦合很重要?因为就像火车一样,当您需要更改一段代码时,与之紧密相关的所有代码都必须更改。一个再适合不过的例子:有人发布了他们的API的新版本,现在您的代码无法通过编译了。

API是不可避免的耦合源,但是存在更多隐蔽的耦合形式。显然,每个人都知道,如果API的原型发生更改,则该调用的传入和返回数据都会发生变化。就在函数原型中;我采用这些类型的值,并返回其他类型的值。但是,如果API以其他方式传递数据怎么办?如果每次调用此API的结果都是基于上次调用该API的结果,即使您没有更改参数该怎么办?

这是状态,状态管理是计算机科学中的问题。

package counter

var count int

func Increment(n int) int {
        count += n
        return count
}

假设我们有这个简单的counter包。您可以调用Increment以增加计数器,即便传入0,你也可以得到返回值。

假设您必须测试此代码,那么每次测试后如何重置计数器?假设您想并行运行这些测试,可以吗?现在,假设您要为每个程序进行不止一个计数,您可以这样做吗?

不,当然不行。显然,答案是将count变量封装为类型。

package counter

type Counter struct {
        count int
}

func (c *Counter) Increment(n int) int {
        c.count += n
        return c.count
}

现在想象一下,这个问题不局限于计数器,还包括应用程序的主要业务逻辑。您可以单独测试吗?您可以并行测试吗?您一次可以使用多个实例吗?如果回答那些问题为否,则原因是软件的包级别状态。

避免包级别状态。通过提供一种类型需要的依赖项作为该类型上的字段,而不是使用包变量,来减少耦合和怪异的行为。

为失败而计划,而不是成功而计划

“Errors should never pass silently.” - The Zen of Python, Item 10
“错误绝不能默默传递。” - Python之禅,条款10

有人说过,支持异常处理的语言遵循武士原则(Samurai principle)。要么全胜归来,要么(失败)全不回来。在基于异常的语言中,函数仅返回有效结果。如果他们没有成功,那么控制流程将采纳完全不同的路径。

未检查的异常显然是不安全的编程模型。当您不知道哪些语句可能引发异常时,如何在存在错误的情况下编写健壮的代码?Java尝试通过引入checked exception的概念来使异常更安全,据我所知,这种checked exception在另一种主流语言中没有被引入。有很多使用异常的语言,但是除了Java,所有语言都使用未经检查的各种异常(unchecked exception)。

显然,Go选择了不同的路径。Go程序员认为,健壮的程序是由处理失败情况的片段组成的,然后再处理happy path。在Go设计的空间中:服务器程序,多线程程序,处理网络输入的程序,如果要构建可靠的程序,那么处理意外数据、超时、连接失败和损坏的数据必须是程序员的首要任务。

“I think that error handling should be explicit, this should be a core value of the language.” - Peter Bourgon, GoTime #91
“我认为错误处理应该是显式的,这应该是语言的一个核心价值观。” - 彼得·布尔贡(Peter Bourgon),GoTime#91

我想回应彼得的主张,因为这是本文的动力。我认为Go的成功很大程度上归功于显式的处理错误的方式。Go程序员首先考虑失败情况。我们首先解决如果...怎么办的情况。这导致程序在编写时处理故障,而不是在生产中处理故障。

反复出现的下面代码片段:

if err != nil {
    return err
}

所付出的成本已基本被在故障发生时刻意处理每个故障情况的价值超过了(译者注:上面的重复代码段也是利大于弊)。关键还在于显式处理每个错误的文化价值观。

早点返回,而不是深层嵌套

“Flat is better than nested.” - The Zen of Python, Item 5
“扁平比嵌套更好。” - Python的禅宗,条款5

这是一个明智的建议,而且它来自以缩进作为控制流主要形式的语言。我们如何用Go来解释这个建议呢?gofmt控制Go程序的整体风格(空白与缩进),因此无需执行任何额外操作。

我之前写过关于package名字的文章,这里可能有一些建议:避免复杂的软件包层次结构。以我的经验,程序员越努力细分和分类Go代码库,他们越有可能陷入包导入循环的死角。

我认为第5项条款建议的最佳应用是函数内的控制流。简而言之,避免需要控制流缩进过深。

“Line of sight is a straight line along which an observer has unobstructed vision.” - May Ryer, "Code: Align the happy path to the left edge" https://medium.com/@matryer/line-of-sight-in-code-186dd7cdea88

“代码行展现给观察者的视觉效果应该是一条畅通的直线。- May Ryer, “代码:将快乐路径对齐到左边缘”

Mat Ryer将这种想法描述为视线编码(line of sight coding )。视线编码意味着:

  • 如果不满足前提条件,则使用保护子句尽早返回。
  • 将成功的return语句放在函数的末尾,而不是放在条件代码块中。
  • 通过提取函数和方法来降低函数的整体缩进级别。

该建议的关键是您所关心的事情,功能所要做的事情永远不会有在屏幕右侧滑出视线的危险。这种风格有一个额外的副作用,您可以避免团队中对行长度的毫无意义的争论。

每次缩进时,都会向程序员堆栈添加另一个先决条件,从而消耗他们的7±2个短期内存插槽之一(译注:7±2指的是人类能短期记忆的事件数量大约是7,±2是个体差异)。将函数的成功执行路径贴近屏幕左手侧,不要深入嵌套。

如果你认为它性能差,请通过基准测试证明

“In the face of ambiguity, refuse the temptation to guess.” - The Zen of Python, Item 12
“面对模棱两可,拒绝猜测的诱惑。” - Python之禅,条款12

编程基于数学和逻辑,这两个概念很少涉及机会元素。但是,作为程序员,我们每天都在猜测许多事情。这个变量有什么作用?此参数有什么作用?如果我在这类传入nil会怎样?如果我调用Register两次会怎样?实际上,现代编程中存在很多猜测,尤其是在使用不是你编写的库时。

“APIs should be easy to use and hard to misuse.”  - Josh Bloch
“API应该易于使用并且不容易被滥用。” - 乔什·布洛赫(Josh Bloch)

我知道的帮助程序员避免猜测的最好方法之一是在构建API时,应专注于默认用例。使调用者尽可能轻松地执行最常见的事情。但是,我过去写过很多关于API设计的文章,所以我对第12项的解释是:不要猜测性能

尽管您可能考虑到Knuth的建议,但Go语言成功的推动力之一是其高性能的执行。您可以在Go中编写高性能的程序,因此人们会因此选择Go。关于性能有很多误解,所以我的要求是,当您希望对代码进行性能调优时,或者遇到一些教条式的建议时,例如defer缓慢,CGO昂贵,或者始终使用原子操作而不是互斥锁时,请不要猜。

不要因为过时的教条而使您的代码复杂化,并且,如果您认为某些事情很慢,请首先使用基准测试进行证明。Go提供了出色的基准测试和性能分析工具,这些工具均可免费获得。使用它们来找出您程序中的性能瓶颈。

在启动goroutine之前,请知道它何时会停止

在这一点上,我认为我已经从PEP-20中挖掘了有价值的要点,并且可能扩展其重新解释的范围。我认为很好,因为尽管这是一种有用的修辞手法,但最终我们还是在谈论两种不同的语言。

“You type go, a space, and then a function call. Three keystrokes, you can’t make it much shorter than that. Three keystrokes and you’ve just started a sub process.” - Rob Pike, Simplicity is Complicated, dotGo 2015

“您键入go,一个空格和一个函数调用。三次按键,您不能做到比这还短了。三次按键,您就启动了一个子过程。” - 罗伯·派克(Rob Pike),Simplicity is Complicated,dotGo,2015年

接下来的两个建议,我将专注于goroutines。Goroutines是语言的标志性功能,这是我们给出的关于一等公民(first class)并发的答案。它们非常易于使用,只需将单词go放在语句前面,即可异步启动该函数。非常简单,没有线程,没有堆栈大小,没有线程池执行程序(thread pool executor),没有ID,没有跟踪完成状态。

Goroutines代价很低。由于运行时(runtime)能够将goroutine多路复用到一个小的线程池中(您不必管理),因此可以轻松容纳数十万,数百万个goroutine。这开创了在竞争性并发模型(例如线程或事件回调)下不可行的设计。

但是,即便如goroutine一样便宜,但它们也不是免费的。至少它们的堆栈有几千字节,当您启动10^6个goroutine时,它们的确开始累加。这并不是说就不应该使用数百万个goroutine,如果你的设计需要,可以做。但是当您这样做时,请务必对其进行跟踪,因为10^6数量级的任何东西累计可能消耗的资源都不是少量的。

Goroutines是Go中资源所有权的关键。为了程序有用,goroutine必须做一些事情,这意味着它几乎总是持有对资源的引用或所有权:锁、网络连接、带有数据的缓冲区、channel的发送端。当该goroutine处于活动状态时,将持有锁,保持网络连接打开,保留缓冲区,并且channel的接收器将继续等待更多数据。

释放这些资源的最简单方法是将它们与goroutine的生命周期相关联-当goroutine退出时,资源释放。因此,尽管开始执行goroutine几乎是微不足道的,但在进行三次按键(go+空格)前,请确保您对以下问题有答案:

  • goroutine在什么情况下会停止? Go没有办法告诉goroutine退出。没有停止或终止功能,这是有充分的理由的。如果我们无法命令goroutine停止,则必须礼貌地对其提出要求。这几乎总是归结于channel操作。当channel关闭时,针对一个channel的range loop将退出循环。如果一个channel关闭,它将变为可选(selectable)。从一个goroutine到另一个goroutine的信号最好表示为一个关闭的channel。

  • 出现这种情况需要什么? 如果channel既是在goroutines之间进行通讯的工具,又是它们传达完成信号的机制,那么程序员面临的下一个问题就是,谁将关闭channel,何时会发生?

  • 您将使用什么信号知道goroutine已停止? 当您发出信号告知goroutine要停止时,在将来的某个时间gouroutine停止动作会发生。就人类的感知而言,它可能很快发生,但是计算机每秒执行数十亿条指令,并且从每个goroutine的角度来看,它们的指令执行是不同步的。解决方案通常是使用channel发应答信号或fan-in方法需要的waitgroup。

将并发留给调用者

在您编写的任何严肃的Go程序中,都可能涉及并发。这就提出了一个问题,我们编写的许多库和代码都采用每个连接一个goroutine或采用工作者(worker)模式。您将如何管理这些goroutine的生命周期?

net/http是一个很好的例子。关闭拥有监听套接字的server相对来说是直截了当的,但是从该接受套接字产生的goroutines呢?net/http确实在请求对象中提供了一个上下文(context)对象,该上下文对象可用于向正在监听的代码发出信号,表明应该取消请求(cancel),从而终止goroutine,但是尚不清楚如何知道何时完成所有这些操作。一种方法是调用context.Cancel,知道取消已经完成是另一回事。2

我想说明的一点net/http是,它是良好实践的反例。由于每个连接都是由net/http.Server类型内部产生的goroutine处理的,因此驻留在程序net/http包外部的程序无法控制接受套接字产生的goroutine。

这是一个仍在不断发展的设计领域,例如go-kitrun.Group和Go团队等努力ErrGroup提供了执行,取消和等待异步运行功能的框架。

这里更大的设计准则是针对库编写者的,或者是任何编写可以异步运行的代码的人,将使用goroutine的责任留给调用者。让调用者选择他们希望如何启动,跟踪和等待函数执行。

编写测试以锁定包API的行为

也许您希望从我这里读到一篇我不咆哮测试的文章。可悲的是,今天不是那天。

测试是关于您的软件做什么和不做什么的契约。程序包级别的单元测试应锁定程序包API的行为。他们用代码描述了程序包承诺要做的事情。如果针对每个输入排列组合都有一个单元测试,那么您已经定义了代码将在代码(而不是文档)中执行的约定 。

通过简单的输入go test,您就可以断言代码是否遵守契约。在任何阶段,您都可以高度自信地知道人们在更改之前所依赖的行为在更改之后将继续有效。

测试会锁定api行为。添加,修改或删除公共api的任何更改都必须包括对其测试的更改。

适度是一种美德

Go是一种简单的语言,只有25个关键字。在某些方面,这使该语言内置的功能脱颖而出。同样,这些是语言销售的功能,轻量级并发,结构化类型。

我想我们所有人都经历过尝试立即使用Go的所有功能所带来的困惑。谁对使用channel如此兴奋以至于他们尽可能多地,尽可能多地使用它们?就我个人而言,我发现结果很难测试,脆弱且最终过于复杂。只有我一个人吗?

我在goroutines上经历了相同的经历,试图将工作分解成很小的单元,我创建了一群难以管理的goroutines,最终观察到我的大多数goroutines总是阻塞等待–代码最终是顺序的,我增加了很多复杂性,几乎没有给现实世界带来任何好处。谁经历过这样的事情?

我在嵌入机制方面(embedding)也有同样的经历。最初,我将其误认为是继承。然后,我通过将已经承担多个职责的复杂类型组合成更复杂的巨大类型重现了创建脆弱的基类问题。

这可能是最不可行的建议,但我认为这一点很重要。建议始终是相同的,所有事情都要适度,Go的特性也不例外。如果可以的话,请不要寻求goroutine或channel,也不要嵌入结构,匿名函数,过渡用package,为每样东西建立接口(interface),要用简单方法而不是聪明的方法。

可维护性很重要

我想谈谈关于PEP-20的最后一项,

“可读性很重要。” - Python之禅,条款7
“Readability Counts.” - The Zen of Python, Item 7

关于可读性的重要性已经被谈论了很多,不仅在Go语言中,而且在所有编程语言中。像我这样的人,倡导在Go的舞台上使用简单,可读性,清晰度,生产力等词,但最终它们都是一个词的同义词- 可维护性

真正的目标是编写可维护的代码。原始作者之后的代码可以存活下了。存在的代码不仅可以作为时间点投资,而且可以作为未来价值的基础。不是可读性并不重要,而是可维护性更重要。

Go并不是为聪明人而优化的语言。Go不是一种为了在程序中编写最少行数而进行优化的语言。我们没有针对磁盘上源代码的大小进行优化,也没有针对将程序键入编辑器花费的时间进行优化。而是,我们希望优化我们的代码以使读者清晰(clear)。因为需要维护此代码的人正是读者。

如果您是为自己编写程序,则也许只需要运行一次,或者您是唯一会看到该程序的人,然后程序为您工作。但是,如果这是一个将由多个人贡献的软件,或者将由人们使用足够长的时间以致其需求,功能或运行环境可能发生变化,那么您的目标必须是针对程序的可维护性。如果无法维护软件,则它将被重写;那可能是您的公司最后一次投资Go。

你离开后,您努力实现东西可以维护吗?您今天该如何做才能使某人明天更容易维护您的代码?



我的网课“Kubernetes实战:高可用集群搭建、配置、运维与应用”在慕课网上线了,感谢小伙伴们学习支持!

我爱发短信:企业级短信平台定制开发专家 https://51smspush.com/
smspush : 可部署在企业内部的定制化短信平台,三网覆盖,不惧大并发接入,可定制扩展; 短信内容你来定,不再受约束, 接口丰富,支持长短信,签名可选。

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式:

微博:https://weibo.com/bigwhite20xx
微信公众号:iamtonybai
博客:tonybai.com
github: https://github.com/bigwhite

微信赞赏:
img{512x368}

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。


  1. 演讲的这一部分具有Ruby,Swift,Elm,Go,NodeJS,Python,Rust的网站登录页面的几个屏幕截图,展示了该语言如何描述自己。 

  2. 我倾向于选择net/http很多东西,但这并不是因为它很糟糕,实际上是相反的,它是Go代码库中最成功,最古老,最常用的API。因此,它的设计,发展和缺点已被彻底地接受。你可以认为这是奉承,而不是批评。 

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! 图片广告位1 图片广告位2 图片广告位3 商务合作请联系bigwhite.cn AT aliyun.com

欢迎使用邮件订阅我的博客

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats