Java、Go 和 Rust 的比较

当涉及到Java、Go和Rust的比较时，主要考虑的是它们在性能、安全性、开发效率等方面的差异。下面将为你提供一个简单的例子，比较它们在并发编程方面的不同。

Java

Java是一种面向对象的编程语言，广泛用于企业级应用和大型系统开发。它具有强大的并发编程支持，其中最著名的特性是Java的线程和并发包（java.util.concurrent包）。

下面是一个简单的Java并发示例，使用线程来计算斐波那契数列：

java 复制代码

public class Fibonacci {
    // 计算斐波那契数列
    public static int fib(int n) {
        if (n <= 1) {
            return n;
        }
        return fib(n-1) + fib(n-2);
    }

    public static void main(String[] args) {
        int n = 10;
        // 创建多个线程并行计算斐波那契数列
        for (int i = 0; i < n; i++) {
            final int num = i;
            new Thread(() -> {
                System.out.println("Fibonacci(" + num + "): " + fib(num));
            }).start();
        }
    }
}

Go是一种静态类型、编译型的编程语言，由Google开发。它专注于简洁、高效的并发编程，通过goroutines和channels来实现并发。

下面是一个简单的Go并发示例，计算斐波那契数列：

go 复制代码

package main

import "fmt"

// 计算斐波那契数列
func fib(n int) int {
    if n <= 1 {
        return n
    }
    return fib(n-1) + fib(n-2)
}

func main() {
    n := 10
    // 使用goroutines并行计算斐波那契数列
    for i := 0; i < n; i++ {
        go func(num int) {
            fmt.Printf("Fibonacci(%d): %d\n", num, fib(num))
        }(i)
    }
    // 防止程序提前退出
    var input string
    fmt.Scanln(&input)
}

Rust

Rust是一种系统级编程语言，注重安全性和并发性。它使用Ownership和Borrowing机制来管理内存，避免了常见的内存安全问题。Rust的并发编程通过std::thread模块和std::sync模块来实现。

下面是一个简单的Rust并发示例，计算斐波那契数列：

rust 复制代码

use std::thread;

// 计算斐波那契数列
fn fib(n: u64) -> u64 {
    if n <= 1 {
        return n;
    }
    fib(n-1) + fib(n-2)
}

fn main() {
    let n = 10;
    // 创建多个线程并行计算斐波那契数列
    for i in 0..n {
        thread::spawn(move || {
            println!("Fibonacci({}): {}", i, fib(i));
        });
    }
    // 防止程序提前退出
    let _ = std::io::stdin().read_line(&mut String::new());
}

这个例子展示了如何使用Java、Go和Rust来进行并发编程，计算斐波那契数列。你可以看到，虽然它们的语法和特性有所不同，但都提供了强大的并发支持。