Go 构建速度优于 Rust 的原因是什么？

积累知识，胜过积蓄金银！毕竟在Golang开发的过程中，会遇到各种各样的问题，往往都是一些细节知识点还没有掌握好而导致的，因此基础知识点的积累是很重要的。下面本文《Go 构建速度优于 Rust 的原因是什么？》，就带大家讲解一下知识点，若是你对本文感兴趣，或者是想搞懂其中某个知识点，就请你继续往下看吧~

我正在 leedcode 练习用 golang 和 rust 编写解决方案。 我在 golang 和 rust 中为这个问题编写了一个解决方案 https://leetcode.com/problems/letter-combinations-of-a-phone-number/

package main

func lettercombinations(digits string) []string {
    if len(digits) == 0 {
        return []string{}
    }

    letters := [][]string{
        {},
        {},
        {"a", "b", "c"},
        {"d", "e", "f"},
        {"g", "h", "i"},
        {"j", "k", "l"},
        {"m", "n", "o"},
        {"p", "q", "r", "s"},
        {"t", "u", "v"},
        {"w", "x", "y", "z"},
    }

    var gen func(index int, digits string) []string
    gen = func(index int, digits string) []string {
        result := make([]string, 0)
        row := letters[int(digits[index]-'0')]
        index++
        for _, letter := range row {
            if index < len(digits) {
                for _, res := range gen(index, digits) {
                    result = append(result, letter+res)
                }
            } else {
                result = append(result, letter)
            }
        }

        return result
    }

    return gen(0, digits)
}

func main() {
    for i := 0; i < 10000; i++ {
        lettercombinations("23456789")
    }
}

这是生锈的

struct Solution;

impl Solution {
    pub fn letter_combinations(digits: String) -> Vec<String> {
        if digits.len() == 0 {
            return vec![];
        }

        let letters: [[char; 5]; 10] = [
            [0 as char, '0', '0', '0', '0'],
            [0 as char, '0', '0', '0', '0'],
            [3 as char, 'a', 'b', 'c', '0'], // 2
            [3 as char, 'd', 'e', 'f', '0'], // 3
            [3 as char, 'g', 'h', 'i', '0'], // 4
            [3 as char, 'j', 'k', 'l', '0'], // 5
            [3 as char, 'm', 'n', 'o', '0'], // 6
            [4 as char, 'p', 'q', 'r', 's'], // 7
            [3 as char, 't', 'u', 'v', '0'], // 8
            [4 as char, 'w', 'x', 'y', 'z'], // 9
        ];

        fn gen(index: usize, digits: &str, letters: [[char; 5]; 10]) -> Vec<String> {
            let result_capacity = (4 as usize).pow(digits.len() as u32);
            let mut result: Vec<String> = Vec::with_capacity(result_capacity);
            let iletters = digits.chars().nth(index).unwrap().to_digit(10).unwrap() as usize;
            let row = letters[iletters];
            let index = index + 1;
            for i in 1..= row[0] as usize {
                if index < digits.len() {
                    let res = gen(index, digits, letters);
                    for j in 0..res.len() {
                        let mut line = String::with_capacity(res[j].len() + 1);
                        line.push(row[i]);
                        line.push_str(&res[j]);
                        result.push(line);
                    }
                } else {
                    result.push(row[i].to_string());
                }
            }
            return result;
        }

        return gen(0, &digits, letters);
    }
}

fn main() {
    for _i in 0..10000 {
        Solution::letter_combinations(String::from("23456789"));
    }
}

我将每个解决方案运行 10,000 次迭代。 golang 解决方案在我的笔记本电脑上需要 60 秒。 rust 解决方案需要 556 秒，大约慢了 10 倍。 我猜是因为 golang 垃圾收集器在程序期间不会将堆内存返回给操作系统，并为每次迭代使用预先分配的内存。 但是rust每次调用函数 lettercombinations() 都会从操作系统分配内存并将其释放回来。所以生锈速度较慢。 我说得对吗？

正确答案

如其他地方所述（例如 Why is my Rust program slower than the equivalent Java program?），如果您在调试模式下编译 Rust 代码，它往往会很慢。如果您打开优化，速度往往会快得多。

这里值得一提的是，Rust 编译器将进行大量优化如果你允许的话（或者告诉他们）。 The cargo build system will do this when run in release mode。这个优化会让调试变得非常困难！因此，如果您试图让代码工作，您可能还不想这样做。

Go 编译器传统上只进行相对简单的优化。¹因此 go build 目前没有优化级别或标志，除了 -N to disable optimization and -l to disable inlining 之外。

¹这种优化并非毫无用处，但它并不是 rustc 在高优化级别上所做的那种超级花哨的使调试器中无法跟踪代码的优化。

终于介绍完啦！小伙伴们，这篇关于《Go 构建速度优于 Rust 的原因是什么？》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！