Go、Rust、Kotlin、Python 与 Java 从性能到生态，全面解读五大主流编程语言

// Go: 编译为原生代码，速度快
func fib(n int) int {
    if n <= 1 { return n }
    return fib(n-1) + fib(n-2)
}

// Rust: 同样编译为原生代码，且可做更多优化
fn fib(n: u32) -> u32 {
    match n {
        0 | 1 => n,
        _ => fib(n - 1) + fib(n - 2),
    }
}

// Kotlin: 在 JVM 上运行，需 JIT 优化才能达到最佳性能
fun fib(n: Int): Int = when (n) {
    0, 1 -> n
    else -> fib(n - 1) + fib(n - 2)
}

# Python: 解释执行，递归调用开销大，极易栈溢出
def fib(n):
    return n if n <= 1 else fib(n-1) + fib(n-2)

// Java: 类似 Kotlin，但语法更冗长
public static int fib(int n) {
    return (n <= 1) ? n : fib(n - 1) + fib(n - 2);
}

go func() { fmt.Println("Hello from goroutine") }()
ch := make(chan string)
go func() { ch <- "data" }()
msg := <-ch
```|

| **Rust** | Async/Await + Tokio 或 async-std | 基于 Future 的异步运行时，结合所有权系统确保线程安全，无数据竞争 | 
```rust
tokio::spawn(async {
    println!("Hello from async task");
});
let data = fetch_data().await;
```|

| **Kotlin** | 协程（Coroutines）+ kotlinx.coroutines | 基于 JVM 线程池的轻量级协程，语法优雅，支持挂起函数 | 
```kotlin
launch {
    println("Hello from coroutine")
}
val data = async { fetchData() }.await()
```|

| **Python** | asyncio + async/await（单线程事件循环） | GIL 锁导致多线程无法并行 CPU 计算，适合 I/O 密集型任务 | 
```python
async def main():
    print("Hello from async")
    data = await fetch_data()
asyncio.run(main())
```|

| **Java** | Thread + ExecutorService + CompletableFuture | 成熟但重量级，线程创建成本高，易引发上下文切换开销 | 
```java
new Thread(() -> System.out.println("Hello")).start();
CompletableFuture.supplyAsync(this::fetchData);
```|

###  并发能力评分（满分5分）

| 语言 | 易用性 | 性能 | 安全性 | 适用场景 |
|------|--------|--------|--------|----------|
| Go | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐☆ | 高并发微服务 |
| Rust | ⭐⭐⭐☆☆ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | 安全关键型系统 |
| Kotlin | ⭐⭐⭐⭐☆ | ⭐⭐⭐☆☆ | ⭐⭐⭐☆☆ | Android、Web 后端 |
| Python | ⭐⭐☆☆☆ | ⭐⭐☆☆☆ | ⭐⭐☆☆☆ | I/O 密集型脚本 |
| Java | ⭐⭐☆☆☆ | ⭐⭐⭐☆☆ | ⭐⭐⭐☆☆ | 传统企业系统 |

>  **Go 的优势在于“原生支持”**：只需 `go` 关键字即可启动协程，配合 channel 实现 CSP（Communicating Sequential Processes）模式，极大简化并发编程。
>
>  **Python 的 GIL 是硬伤**：尽管有 `multiprocessing` 模块绕过，但进程间通信成本高，不适合高频交互场景。

// Go: 显式返回 error
content, err := ioutil.ReadFile("file.txt")
if err != nil {
    log.Fatal(err)
}

// Rust: Result 必须处理
let content = std::fs::read_to_string("file.txt")
    .expect("无法读取文件"); // 或使用 match / ?

// Kotlin: 空安全 + try-catch
val content: String? = try {
    File("file.txt").readText()
} catch (e: IOException) {
    null
}
println(content ?: "默认内容")

# Python: try-except
try:
    with open('file.txt') as f:
        content = f.read()
except FileNotFoundError:
    content = "默认内容"

// Java: 受检异常必须处理
try {
    String content = Files.readString(Paths.get("file.txt"));
} catch (IOException e) {
    e.printStackTrace();
}

// Kotlin: 编译器阻止空指针
val name: String = getName() // 编译报错：可能为空！
val name: String? = getName() // OK，但访问需判空
println(name?.length) // 安全调用

// Rust: 使用 Option 避免空值
fn get_name() -> Option<String> { ... }

let name = get_name();
match name {
    Some(n) => println!("{}", n.len()),
    None => println!("No name"),
}

// Java: 运行时才抛出 NullPointerException
String name = getName(); // 可能为 null
System.out.println(name.length()); // 可能崩溃

{
    let s = String::from("hello"); // s 是字符串的所有者
} // s 离开作用域，内存自动释放（RAII）

let s1 = String::from("hello");
let s2 = s1; // s1 被“移动”（move），不再有效
// println!("{}", s1); // 编译错误！s1 已失效