标签 GC 下的文章

理解unsafe-assume-no-moving-gc包

本文永久链接 – https://tonybai.com/2023/04/16/understanding-unsafe-assume-no-moving-gc

1. 背景

在之前的《Go与神经网络:张量计算》一文中,不知道大家是否发现了,所有例子代码执行时,前面都加了一个环境变量ASSUME_NO_MOVING_GC_UNSAFE_RISK_IT_WITH,就像下面这样:

$ASSUME_NO_MOVING_GC_UNSAFE_RISK_IT_WITH=go1.20 go run tensor.go

这是怎么回事儿呢?如果不加上这个环境变量会发生什么呢?我们来试试:

// https://github.com/bigwhite/experiments/blob/master/go-and-nn/tensor-operations/tensor.go

$go run tensor.go
panic: Something in this program imports go4.org/unsafe/assume-no-moving-gc to declare that it assumes a non-moving garbage collector, but your version of go4.org/unsafe/assume-no-moving-gc hasn't been updated to assert that it's safe against the go1.20 runtime. If you want to risk it, run with environment variable ASSUME_NO_MOVING_GC_UNSAFE_RISK_IT_WITH=go1.20 set. Notably, if go1.20 adds a moving garbage collector, this program is unsafe to use.

goroutine 1 [running]:
go4.org/unsafe/assume-no-moving-gc.init.0()
    /Users/tonybai/Go/pkg/mod/go4.org/unsafe/assume-no-moving-gc@v0.0.0-20220617031537-928513b29760/untested.go:25 +0x1ba
exit status 2

我们看到,程序panic了!我们看到panic的错误信息提到了go4.org/unsafe/assume-no-moving-gc这个包,显然是这个包在“作祟”,那么assume-no-moving-gc这个包究竟是做什么的呢?究竟有何功用?为何gorgonia.org/tensor会依赖这个包?这超出了《Go与神经网络:张量计算》那篇文章的范畴,所以我并未提及。在这篇文章中,我就和大家一起来理解一下unsafe-assume-no-moving-gc这个包。

2. unsafe-assume-no-moving-gc究竟是什么包?

unsafe-assume-no-moving-gc这个包的canonical import path是go4.org/unsafe/assume-no-moving-gc,显然它是go4.org这个组织开源的包。我们看看go4.org的主页(如下图):

这个站点主页非常“简陋”,最大的价值在于解释了go4的来历:gopher的谐音。go4.org开源了一些Go包,这个在其官方github站点可以看到:

项目不多,Star数也不多,但随便翻看一个项目的contributor,我们能看到前Googler、前Go核心团队成员、net/http包的设计者Brad Fitzpatrick(bradfitz)以及Go runtime的核心贡献者Josh Bleecher Snyder(josharian)。现在这两人似乎都在初创公司tailscale任职,做基于wireguard协议的远程安全控制平台(简单理解就是VPN平台)。tailscale汇集了一撮Go语言的原核心开发,go4.org就是他们开源的一些misc go包。而unsafe-assume-no-moving-gc这个包就是其中之一。

那么这个包究竟是做什么的呢?我们接着往下看。

3. unsafe-assume-no-moving-gc的工作原理

unsafe-assume-no-moving-gc是一个非常简单的包:

$tree unsafe-assume-no-moving-gc -F
unsafe-assume-no-moving-gc
├── LICENSE
├── README.md
├── assume-no-moving-gc.go
├── assume-no-moving-gc_test.go
├── go.mod
└── untested.go

0 directories, 6 files

除了test源文件外,它的源文件只有两个assume-no-moving-gc.go和untested.go。打开这两个源文件,你会发现这个包甚至都没有提供任何API。那这个包究竟是做什么用的呢?下面是这个包的README:

大致的理解就是如果你的代码中使用了Go中的unsafe tip,那么你的程序可以正常工作的前提是Go运行时垃圾回收器不是一个带迁移机制的回收器(collector)

所谓带迁移机制的collector,即在GC回收时可能将某些heap object挪到其他内存地址上。你的程序如果导入unsafe-assume-no-moving-gc这个包,就可以在Go GC支持迁移机制时以“程序启动崩溃”的行为提醒你。

我们来看一个例子:

// main.go
package main

import (
    "fmt"

    _ "go4.org/unsafe/assume-no-moving-gc"
)

func main() {
    fmt.Println("unsafe-assume-no-moving-gc demo")
}

go mod tidy后,使用Go 1.20版本运行该源文件:

$go mod tidy
go: finding module for package go4.org/unsafe/assume-no-moving-gc
go: downloading go4.org/unsafe/assume-no-moving-gc v0.0.0-20230221090011-e4bae7ad2296
go: downloading go4.org v0.0.0-20230225012048-214862532bf5

$go run main.go
unsafe-assume-no-moving-gc demo

由于目前最新Go 1.20.x版本的GC并非带迁移机制的GC,因此使用Go 1.20跑上面程序不会导致panic。

我们将unsafe-assume-no-moving-gc包回退到以前的版本,比如:v0.0.0-20230221090011-e4bae7ad2296,然后再run一遍main.go:

$go get go4.org/unsafe/assume-no-moving-gc@v0.0.0-20201222180813-1025295fd063
go: downgraded go4.org/unsafe/assume-no-moving-gc v0.0.0-20230221090011-e4bae7ad2296 => v0.0.0-20201222180813-1025295fd063

$go run main.go
panic: Something in this program imports go4.org/unsafe/assume-no-moving-gc to declare that it assumes a non-moving garbage collector, but your version of go4.org/unsafe/assume-no-moving-gc hasn't been updated to assert that it's safe against the go1.20 runtime. If you want to risk it, run with environment variable ASSUME_NO_MOVING_GC_UNSAFE_RISK_IT_WITH=go1.20 set. Notably, if go1.20 adds a moving garbage collector, this program is unsafe to use.

goroutine 1 [running]:
go4.org/unsafe/assume-no-moving-gc.init.0()
    /Users/tonybai/Go/pkg/mod/go4.org/unsafe/assume-no-moving-gc@v0.0.0-20201222180813-1025295fd063/untested.go:24 +0x1ba
exit status 2

从输出的panic error信息中,我们看到go4.org/unsafe/assume-no-moving-gc尚未被升级到可以信任go 1.20版本的版本,因此以Go 1.20运行该程序可能有风险。如果你能确认不会存在问题,可以用ASSUME_NO_MOVING_GC_UNSAFE_RISK_IT_WITH=go1.20这个环境变量来避免panic,比如下面这个输出:

$ASSUME_NO_MOVING_GC_UNSAFE_RISK_IT_WITH=go1.20 go run main.go
unsafe-assume-no-moving-gc demo

那么unsafe-assume-no-moving-gc包是怎么做到上述“检测”的呢?其诀窍就在untested.go这个源文件中。我们下载go4.org/unsafe/assume-no-moving-gc源码,并将其“回退”到1025295fd063这个commit时刻:

$git checkout 1025295fd063
Note: checking out '1025295fd063'.

... ...

HEAD is now at 1025295 flesh out package doc

查看untested.go:

// Copyright 2020 Brad Fitzpatrick. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// +build go1.18

package assume_no_moving_gc

import (
    "os"
    "runtime"
    "strings"
)

func init() {
    dots := strings.SplitN(runtime.Version(), ".", 3)
    v := runtime.Version()
    if len(dots) >= 2 {
        v = dots[0] + "." + dots[1]
    }
    if os.Getenv(env) == v {
        return
    }
    panic("Something in this program imports go4.org/unsafe/assume-no-moving-gc to declare that it assumes a non-moving garbage collector, but your version of go4.org/unsafe/assume-no-moving-gc hasn't been updated to assert that it's safe against the " + v + " runtime. If you want to risk it, run with environment variable " + env + "=" + v + " set. Notably, if " + v + " adds a moving garbage collector, this program is unsafe to use.")
}

这个文件有两个特点:

  • 使用了build constraint:// +build go1.18,这意味着在你使用Go 1.18及更高版本时,该源文件才会参与编译。
  • 包含了init函数,你的代码在导入assume_no_moving_gc包时,该init函数会执行,产生“副作用”。

注:关于build constraint的用法,参见go help buildconstraint。

这样,我们使用go 1.20版本运行上面main.go时,由于go 1.20版本大于go 1.18版本,untested.go将被编译且其中的init函数将被执行,如果env这个常量(“ASSUME_NO_MOVING_GC_UNSAFE_RISK_IT_WITH”)所对应的环境变量没有设置,那么init函数将走到panic,从而导致程序退出并输出panic信息。

现在我们将assume_no_moving_gc包的版本切换回最新版本,最新版本的untested.go中的build constraint如下:

  //go:build go1.21
  // +build go1.21

这意味着你使用Go 1.21或以上版本时,untested.go文件才会被编译,如果我们使用go 1.20版本运行main.go,我们便不会“触发”untested.go中init函数的副作用,于是main.go得以正常运行。

注:截至go 1.20版本,Go GC依然不会挪动heap object。

在理解unsafe-assume-no-moving-gc包之前,我就该包的功用“咨询”了ChatGPT,ChatGPT的回答如下:

可以看出,ChatGPT基本上是一本正经地“胡说八道”。

4. 小结

unsafe-assume-no-moving-gc只针对GC对heap object的迁移,而不会保证栈地址的迁移,我们知道,Go中栈地址是会变的,因为goroutine的初始栈才2KB,一旦超出这个范围,Go runtime就会对栈进行扩展,即分配一个更大的地址范围作为goroutine的栈,然后将原栈上的变量迁移到新栈中,这样原先栈上变量的地址就都会发生变化。

不过,如果你的Go源码中采用了unsafe tips,依赖了heap object的地址,那么这里建议你导入unsafe-assume-no-moving-gc包。但要注意,随着go最新版本的发布,你要及时更新依赖的unsafe-assume-no-moving-gc的版本。否则当用户使用最新版本go时,依赖你的包的程序就会以panic来提醒。


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2023年,Gopher部落将进一步聚焦于如何编写雅、地道、可读、可测试的Go代码,关注代码质量并深入理解Go核心技术,并继续加强与星友的互动。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商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
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite

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

2023年的Rust与Go[译]

本文永久链接 – https://tonybai.com/2023/02/22/rust-vs-go-in-2023

本文译自《Rust vs Go in 2023》

注:从2022年下半年开始,我们研发团队的产品研发不再局限于云端,车端也是将来的一个重要方向。于是我除了继续对Go语言保持常规的高度关注之外,也逐步开始留意Rust语言的发展。


Rust和Go哪个更好?Go还是Rust?在2023年,你应该为你的下一个项目选择哪种语言,为什么?两者在性能、简单性、安全性、功能、规模和并发性等方面如何比较?它们的共同点是什么,它们有哪些根本性的不同?让我们在这个友好而公平的Rust和Go的比较中找到答案。

Rust和Go都很棒

首先,我必须要说的是,Go和Rust都是绝对优秀的编程语言。它们都是现代的、强大的、被广泛采用的编程语言,并且都提供出色的性能。

你可能读过一些说Go比Rust好的文章,或者相反。但这真的没有意义;每一种编程语言都代表了一系列的权衡和取舍。每种语言都有自己的优化重点,所以你对语言的选择应该由适合你的东西和你想用它解决的问题决定。

在这篇文章中,我将尝试告诉你何时使用Go是理想选择以及何时使用Rust更佳。我也会试着介绍一下这两种语言的本质(如果你愿意的话,就是Go和Rust的道)。

虽然它们在语法和风格上有很大不同,但Rust和Go都是构建软件的一流工具。接下来,让我们仔细看看这两种语言。

Go和Rust的相似之处

Rust和Go有很多共同点,这也是你经常听到它们一起被提及的原因之一。两种语言的共同目标是什么呢?

Rust是一种低级静态类型的多范式编程语言,专注于安全和性能。 – Gints Dreimanis

Go是一种开源的编程语言,可以轻松构建简单、可靠、高效的软件。 – go.dev

内存安全

Go和Rust都属于现代编程语言,它们的首要任务是内存安全。经过几十年对C和C++等旧语言的使用,我们可以清楚地看到,导致错误和安全漏洞的最大原因之一是不安全地或不正确地访问内存。

Rust和Go以不同的方式处理这个问题,但它们的目标都是在管理内存方面比其他语言更聪明、更安全,并帮助你写出正确高性能的程序。

快速、紧凑的可执行文件

Go和Rust都是编译型语言,这意味着你的程序被直接翻译成可执行的机器码,因此你可以以单一二进制文件形式来部署你的程序;与Python和Ruby等解释型语言不同,你不需要将解释器和大量的库和依赖关系与你的程序一起分发,这是一个很大的优点。这也使得Rust和Go的程序与解释型语言相比都非常快。

通用语言

Rust和Go都是强大的、可扩展的通用编程语言,你可以用它们来开发各种现代软件,从网络应用到分布式微服务,或者从嵌入式微控制器到移动应用程序。

两者都有优秀的标准库、繁荣的第三方生态系统以及巨大的商业支持和庞大的用户基础。它们都已经存在了很多年,并将在未来几年内继续被广泛使用。今天学习Go或Rust将是对你时间和精力的合理投资。

务实的编程风格

Go和Rust都不是以函数式编程为主的语言(例如像Scala或Elixir),也不是完全面向对象的语言(像Java和C#)。相反,虽然Go和Rust都有与函数式和面向对象编程相关的特性,但它们是务实的语言,旨在以最合适的方式解决问题,而不是强迫你采用特定的做事方式。

如果你喜欢函数式编程风格,你会在Rust中发现更多对这种风格的支持,因为Rust在语法特性数量上要比Go更多。

我们可以讨论什么是“面向对象”语言,但可以说C++、Java或C#用户所期望的面向对象编程风格在Go或Rust中都不存在。 – Jack Mott

规模化的开发

Rust和Go都有一些有用的特性,使它们适合于大规模的编程,不管是指大型团队,还是大型代码库,或者两者兼具。

例如,C语言的程序员们多年来一直在争论将括号放在哪里,以及代码应该用制表符还是空格缩进,而Rust和Go通过使用标准的格式化工具(Go为gofmt,Rust为rustfmt)使用规范的风格自动重写你的代码,完全消除了这些问题。

这并不是说这种特殊的风格本身有多好:而是Rust和Go的程序员都喜欢这种标准化

gofmt的风格是没有人喜欢的,但gofmt却是所有人的最爱。 – Rob Pike

两种语言的另一个高分领域是构建管道(pipeline)。两种语言都有优秀的、内置的、高性能的标准构建和依赖管理工具;不再需要与复杂的第三方构建系统搏斗,也不再需要每隔几年就学习一个新的系统。

对于早期职业生涯以Java和Ruby为背景的我而言,构建Go和Rust代码感觉就像从我的肩上卸下了一个不可能的重担。当我在谷歌工作时,遇到用Go编写的服务是一种解脱,因为我知道它很容易构建和运行。Rust也是如此,尽管我只在较小规模的Rust项目上工作过。我希望可无限配置的构建系统的时代已经过去了,所有语言都会有自己专门的构建工具,开箱即可使用。- 山姆-罗斯

Rust还是Go?

综上可知,这两种语言都设计得很好、很强大,那么你可能会想知道那些关于两门语言的“圣战”究竟是怎么回事(我也是)。为什么人们对“Go vs.Rust”如此大惊小怪,在社交媒体上大打出手,并且写长篇博文说只有傻瓜才会使用Rust,或者Go不是真正的编程语言,或者其他什么。

这可能会让他们感觉好些,但这并不能完全帮助你,因为你正试图决定在你的项目中使用哪种语言,或者你应该学习哪种语言来推动你的编程生涯。一个明智的人不会根据谁喊得声最大来做出重要的选择。

现在让我们继续我们成熟的讨论,看看在某些领域,一个有理智的人可能更喜欢哪一种语言。

Go与Rust的性能对比

我们已经说过,Go和Rust都能生产出高性能的程序,因为它们被编译成了本地机器代码,而不必通过解释器或虚拟机。

然而,Rust的性能尤其突出。它可以与C和C++相媲美,这两种语言通常被认为是性能最高的编译语言,但与这些老语言不同的是,Rust还提供了内存安全和并发安全,并且基本上不会给执行速度上带去没有任何开销。Rust还允许你创建复杂的抽象,而不需要在运行时付出任何性能上的代价。

相比之下,尽管Go程序的性能也非常好,但Go主要是为开发速度(包括编译)而设计的,而不是执行速度。Go程序员更倾向于清晰的代码而不是快速的代码

Go编译器也不会花很多时间去尝试生成最有效的机器代码;它更关心的是快速编译大量代码。所以Rust通常会在运行时基准测试中击败Go。

Rust的运行时性能也是一致和可预测的,因为它不使用垃圾收集。Go的垃圾收集器非常高效,并且经过优化,使其“STW(停止世界)”的停顿时间尽可能短(每一个新的Go版本都会越来越短)。但是垃圾收集不可避免地在程序的行为方式中引入了一些不可预测的因素,这在某些应用中可能是一个严重的问题,例如嵌入式系统。

因为Rust旨在让程序员完全控制底层硬件,所以有可能将Rust程序优化到相当接近机器的最大理论性能。这使得Rust在执行速度胜过所有其他考虑因素的领域是一个很好的选择,比如游戏编程、操作系统内核、网络浏览器组件和实时控制系统。

简单性

如果没有人能够弄清楚如何使用一种编程语言,那么这种语言有多快也无所谓。Go语言是为了应对C++等语言不断增长的复杂性而特意设计的;它的语法非常少,关键字也非常少,事实上,功能特性也很少。

这意味着学习Go语言不需要很长时间,就可以用它来编写有用的程序。

Go是非常容易学习的。我知道这是一个经常被吹捧的好处,但我真的很惊讶于我能够如此迅速地提高工作效率。多亏了这个语言、文档和工具,我在两天后就写出了有趣的、可提交的代码。 – 一个Rust程序员对Go的早期印象

这里的关键词是简单性。当然,简单并不等同于容易,但是小而简单的语言比大而复杂的语言更容易学习。Go语言没有提供那么多不同的方法来做一件事情,所以所有写得好的Go代码往往看起来都一样。快速学习一个不熟悉的服务并理解它在做什么很容易。

fmt.Println("Gopher's Diner Breakfast Menu")
for dish, price := range menu {
    fmt.Println(dish, price)
}

在我的代码俱乐部视频系列中,我正是这样做的:从GitHub上半随机地挑选Go项目,并与一群Go初学者一起探索它们,看看我们能理解多少的代码。结果总是比我们预期的要多。

虽然核心语言很小,但Go的标准库却非常强大。这意味着你的学习曲线也需要包括你需要的标准库的部分,而不仅仅是Go语法。

另一方面,将功能从语言中转移到标准库中,意味着你可以只专注于学习与你现在相关的库。

Go也是为大规模的软件开发而设计的,支持有大型代码库的大型团队。在这种情况下,新的开发人员能够尽快上手是非常重要的。出于这个原因,Go社区十分看重:简单、明显、常规、直接的程序

使用Go,你可以快速完成工作。Go是我所使用过的生产力最高的语言之一。它的口号是:今天解决实际问题。 – 马蒂亚斯-恩德勒

特性

Rust比其他几种编程语言支持更多的复杂语法特性,因此,你可以用它实现更多。 – devathon

Rust是专门设计用来帮助程序员用最少的代码做最多的事情,它包括很多强大而有用的功能特性。例如,Rust的match功能可以让你以十分简洁地方式写出灵活的、富有表现力的逻辑:

fn is_prime(n: u64) -> bool {
    match n {
        0...1 => false,
        _ => !(2..n).any(|d| n % d == 0),
    }
}

因为Rust做了很多事情,这意味着有很多东西需要学习,特别是在开始的时候。但这没关系:在C++或Java中也有很多东西要学,而且你不会得到Rust的高级特性,比如内存安全。

批评Rust是一种复杂的语言忽略了一点:它被设计成具有表现力,这意味着有很多功能,而在许多情况下,这正是你想要的编程语言。

当然,Rust有一个学习曲线,但一旦你开始使用它,你就会好起来。

对于那些准备接受更复杂的语法和语义(以及可能更高的可读性成本)以换取最大可能的性能的程序员来说,Rust将与C++和D语言争夺思想份额。 – 戴夫-切尼

虽然Rust采用了Go的一些特性,而Go也在采用Rust的一些特性(尤其是泛型),但可以说Rust的特性很重,而Go的特性相对较轻。

并发

大多数语言都对并发编程(同时做多件事情)有某种形式的支持,但Go从一开始就是为这项工作而设计的。Go不使用操作系统的线程,而是提供了一个轻量级的替代方案:goroutine

每个goroutine是一个独立执行的Go函数,Go调度器会将其映射到其控制下的一个操作系统线程中。这意味着调度器可以非常有效地管理大量并发的goroutine,只使用有限的操作系统线程。

因此,你可以在一个程序中运行数百万个并发的goroutine,而不会产生严重的性能问题。这使得Go成为高规模并发应用程序的完美选择,如网络服务器和微服务。

Go还具有快速、安全、高效的功能特性,可以使用channel让goroutines进行通信和共享数据。Go的并发支持感觉设计得很好,使用起来也很愉快。

一般来说,对并发程序进行推断是很难的,而且在任何语言中建立可靠、正确的并发程序都是一个挑战。但由于它从一开始就内置于语言中,而不是事后才想到的,Go中的并发编程是最简单、最完整的。

Go语言可以很容易地建立一个很好的多因素的应用程序,充分利用并发性,同时作为一组微服务进行部署。Rust也可以做这些事情,但可以说它更难。 在某些方面,Rust对防止与内存有关的安全漏洞的痴迷意味着程序员必须不遗余力地执行那些在其他语言(包括Go)中会更简单的任务。 – Sonya Koptyev

相比之下,Rust中的并发故事是非常新的,而且还在稳定中,但它正处于非常积极的开发中,所以请关注这个领域。例如,Rust的rayon库提供了一种非常优雅和轻量级的方式来将顺序计算转化为并行计算。

拥有goroutines和使用channel的轻量级语法真的很好。这真的显示了语法的力量,这些小细节使并发编程比其他语言感觉好得多 – 一个Rust程序员对Go的早期印象

虽然在Rust中实现并发程序可能不那么简单,但还是有可能的,而且这些程序可以利用Rust的安全保证。

一个很好的例子是标准库的Mutex类:在Go中,你可以忘记在访问某些东西之前获得一个Mutex锁,但Rust不会让你这样做。

Go专注于将并发性作为一个一等公民的概念。这并不是说你不能在Rust中找到Go的面向actor的并发性,但这是留给程序员的一个练习。 – Dave Cheney

安全

我们在前面看到,Go和Rust都以不同的方式来防止一大类与内存管理有关的常见编程错误。但是Rust尤其努力确保你不会做一些你不想做的不安全的事情。

Rust的编译器非常严格和学究派,它检查你使用的每个变量和你引用的每个内存地址。它避免了可能的数据竞争条件,并告知你未定义的行为。并发和内存安全问题在Rust的安全子集中根本不可能发生。 – 为什么是Rust?

这将使Rust编程成为与几乎所有其他语言不同的体验,而且一开始可能是一种挑战。但对很多人来说,这种辛苦是值得的。

对我来说,Rust的关键优势是一种感觉,即编译器是我的后盾,不会让它可能检测到的任何错误通过(说真的,有时感觉就像魔法一样)。 – Grzegorz Nosek

包括Go在内的许多语言都有帮助程序员避免错误的设施,但Rust将这一点提高到了一个新的水平,因此可能不正确的程序甚至不会被编译。

有了Rust,库程序员有很多工具来防止他/她的用户犯错。Rust让我们有能力说,我们拥有一块特定的数据;其他东西不可能声称拥有,所以我们知道没有其他东西能够修改它。我想不出以前有什么时候我被赋予过这么多工具来防止意外的误用。这是一种奇妙的感觉。 – 山姆-罗斯

“与借用检查器(borrow checker)斗争”是Rust程序员新手的常见综合症,但在大多数情况下,它所发现的问题是你的代码中真正的bug(或至少是潜在的bug)。它可能会迫使你从根本上重构你的程序,以避免遇到这些问题;而当正确性和可靠性是你的首要任务时,这是件好事。

一个不改变你编程方式的语言有什么意义呢?当你用其他语言工作时,Rust所教授的关于安全的课程也是有用的。

如果你选择了Rust,通常你需要该语言提供的保证:针对空指针和数据竞争的安全,可预测的运行时行为,以及对硬件的完全控制。如果你不需要这些功能,Rust可能是你下一个项目的糟糕选择。这是因为这些保证是有代价的:入门时间。你需要戒掉坏习惯,学习新概念。有可能的是,当你开始的时候,你会经常和借用检查器斗争。 – Matthias Endler

你觉得Rust的编程模型有多大的挑战性,可能取决于你以前有哪些其他语言的经验。Python或Ruby程序员可能会发现它的限制性;其他人会很高兴。

如果你是一个花了几周的时间来追寻内存安全漏洞的C/C++程序员,你会非常欣赏Rust。”与借用检查器斗争”变成了”编译器可以检测到这个?酷!” -Grzegorz Nosek

规模化

今天的服务器程序由数千万行代码组成,由数百甚至数千名程序员进行构建,而且每天都在更新。Go的设计和开发是为了使在这种环境中工作更有成效。Go的设计考虑包括严格的依赖性管理,随着系统的发展,软件架构的适应性,以及组件之间的健壮性。 – Rob Pike

当你一个人或在小团队中处理问题时,选择简单的语言还是功能丰富的语言是一个偏好的问题。但是当软件越来越大,越来越复杂,团队越来越大时,差异就开始显现出来了。

对于大型应用程序和分布式系统来说,执行速度不如开发速度重要:像Go这样刻意简化的语言可以减少新开发人员的启动时间,并使他们更容易处理大型代码库的工作。

有了Go,作为初级开发者更容易提高工作效率,而作为中级开发者则更难引入会导致后续问题的脆弱抽象。由于这些原因,Rust在企业软件开发方面不如Go有说服力。 – Loris Cro

当涉及到大型的软件开发时,清晰的比聪明的好。Go的局限性实际上使它比Rust等更复杂和强大的语言更适合企业和大机构。

Rust和Go的不同点

虽然Rust和Go都是流行的、现代的、广泛使用的语言,但它们并不是真正的竞争对手,因为它们故意针对的是完全不同的使用情况。

Go的整个编程方法与Rust的完全不同,每一种语言都适合一些人,同时也会刺激另一些人。这完全没问题,如果Rust和Go都能以或多或少相同的方式做同样的事情,我们就不会真的需要两种不同的语言。

那么,我们是否可以通过发现Rust和Go所采取的截然不同的方法来了解它们各自的本性呢?让我们拭目以待。

垃圾回收

“要不要垃圾回收”是一个没有正确答案的问题。垃圾回收,以及一般的自动内存管理,使得开发可靠、高效的程序变得快速和容易,对于一些人来说,这至关重要。

但也有人说,垃圾回收及其性能开销和停顿,使程序在运行时表现得不可预测,并引入了不可接受的延迟。争论还在继续。

Go是一种与Rust非常不同的语言。虽然两者都可以被模糊地描述为系统语言或C语言的替代品,但它们有不同的目标和应用、语言设计的风格以及优先级。垃圾回收是一个真正巨大的区别。Go中的GC使语言更简单,更小,更容易推理。在Rust中没有GC会让它变得非常快(尤其是当你需要保证延迟,而不仅仅是高吞吐量的时候),并且可以实现Go中不可能实现的功能和编程模式(或者至少是在不牺牲性能的情况下)。 – PingCAP

接近机器

计算机编程的历史是一个越来越复杂的抽象的故事,它让程序员在解决问题时不用太担心底层机器的实际运作。

这使得程序更容易编写,也许更容易移植。但是对于许多程序来说,对硬件的访问以及对程序执行方式的精确控制更为重要。

Rust的目标是让程序员“更接近机器”,有更多的控制权,但Go抽象了架构细节,让程序员更接近问题。

两种语言都有不同的适用范围。Go在编写微服务和典型的”DevOps”任务方面表现出色,但它不是一种系统编程语言。Rust对于那些看重并发性、安全性和性能的任务中更强;但它的学习曲线比Go更陡峭。 – Matthias Endler

必须运行更快

许多人同意,对于大多数程序来说,性能不如可读性重要。但当性能确实重要时,它真的很重要。Rust做了一些设计上的权衡,以达到尽可能好的执行速度。

相比之下,Go更关注简单性,它愿意为此牺牲一些(运行时)性能。但是Go的构建速度是无可匹敌的,这对于大型代码库来说是非常重要的。

Rust比Go快。在基准测试中,Rust更快,在某些情况下,甚至是数量级的快。但在你选择用Rust写所有东西之前,考虑一下Go在许多基准测试中并不落后于它,而且它仍然比Java、C#、JavaScript、Python等快得多。如果你需要的是顶级的性能,那么选择这两种语言中的任何一种,你都会在游戏中领先。如果你正在构建一个处理高负载的网络服务,你希望能够在纵向和横向上进行扩展,那么这两种语言都会非常适合你。- 安德鲁-拉德

正确性

另一方面,如果一个程序不需要正常工作的话,它可以任意地快。大多数代码不是为长期而写的,但有些程序能在生产中运行多长时间往往是令人惊讶的:在某些情况下,可以保持几十年。

在这种情况下,值得在开发中多花一点时间,以确保程序的正确性、可靠性,并在未来不需要大量的维护。

Go和Rust都旨在帮助你编写正确的程序,但方式不同。例如,Go提供了一个极好的内置测试框架,而Rust则专注于使用其借用检查器消除运行时的错误。

我认为。Go适用于明天必须交付的代码,而Rust适用于必须在未来五年内保持运行不动的代码。 – Grzegorz Nosek

虽然Go和Rust对于任何严肃的项目来说都是很好的选择,但是让自己尽可能地了解每种语言及其特点是一个好主意。

归根结底,别人怎么想并不重要:只有你能决定哪种语言适合你和你的团队。

如果你想加快开发速度,也许是因为你有许多不同的服务需要编写,或者你有一个庞大的开发团队,那么Go是你的首选语言。Go把并发性作为第一等公民给你,并且不容忍不安全的内存访问(Rust也是如此),但不强迫你管理每一个细节。Go是快速和强大的,但它避免了使开发者陷入困境,而是专注于简单性和统一性。如果在另一方面,拧出每一盎司的性能是必要的,那么Rust应该是你的选择。 – 安德鲁-拉德

结论

我希望这篇文章能让你相信Rust和Go都值得你认真考虑。如果可能的话,你应该争取在这两种语言中至少获得一定程度的经验,因为它们对你的任何技术职业都会有极大的帮助,甚至如果你仅把编程作为一种业余爱好的话。

如果你只有时间投资学习一门语言,在你将Go和Rust用于各种不同类型的大小程序之前,不要做出最终决定。

而编程语言的知识实际上只是成为一名成功的软件工程师的一小部分。到目前为止,你需要的最重要的技能是设计、工程、架构、沟通和协作。如果你在这些方面表现出色,无论你选择哪种语言,你都会成为一名优秀的软件工程师。学习愉快!


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2023年,Gopher部落将进一步聚焦于如何编写雅、地道、可读、可测试的Go代码,关注代码质量并深入理解Go核心技术,并继续加强与星友的互动。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商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
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite

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

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 商务合作请联系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
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats