1. 并发编程

goroutine基础

Go版本:

func say(s string) {
    for i := 0; i < 3; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("world") // 启动goroutine
    say("hello")
}

对比Python线程：

import threading

def say(s):
    for i in range(3):
        time.sleep(0.1)
        print(s)

threading.Thread(target=say, args=("world",)).start()
say("hello")

对比JavaScript异步：

async function say(s) {
    for (let i = 0; i < 3; i++) {
        await new Promise(resolve => setTimeout(resolve, 100));
        console.log(s);
    }
}

say("world");
say("hello");

关键区别：

1. goroutine比线程更轻量（初始仅2KB栈）
2. Go运行时自动调度goroutine到OS线程
3. 语法简单，只需go关键字

channel通信

Go版本:

func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // 发送结果到channel
}

func main() {
    s := []int{7, 2, 8, -9, 4, 0}
    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    x, y := <-c, <-c // 从channel接收
    fmt.Println(x, y, x+y)
}

对比Python多进程：

from multiprocessing import Pipe

def sum(s, conn):
    conn.send(sum(s))
    conn.close()

parent_conn, child_conn = Pipe()
p1 = Process(target=sum, args=(s[:len(s)//2], child_conn))
p2 = Process(target=sum, args=(s[len(s)//2:], child_conn))
p1.start(); p2.start()
print(parent_conn.recv(), parent_conn.recv())

关键区别：

1. channel是Go内置的线程安全通信机制
2. 可以带缓冲（make(chan int, 100)）
3. 支持关闭channel和range遍历

select多路复用

Go版本:

func fibonacci(c, quit chan int) {
    x, y := 0, 1
    for {
        select {
        case c <- x:
            x, y = y, x+y
        case <-quit:
            fmt.Println("quit")
            return
        }
    }
}

func main() {
    c := make(chan int)
    quit := make(chan int)
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println(<-c)
        }
        quit <- 0
    }()
    fibonacci(c, quit)
}

对比JavaScript Promise.race:

async function fibonacci(callback, quitSignal) {
    let x = 0, y = 1;
    while (true) {
        const result = await Promise.race([
            new Promise(res => callback(res, x)),
            quitSignal
        ]);
        if (result === 'quit') return;
        [x, y] = [y, x + y];
    }
}

关键区别：

1. select可以同时监控多个channel
2. 常用于超时控制：

   select {
   case res := <-c:
       fmt.Println(res)
   case <-time.After(1 * time.Second):
       fmt.Println("timeout")
   }

2. 文件操作与IO

文件读写

Go版本:

// 读取文件
data, err := os.ReadFile("test.txt")
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(data))

// 写入文件
err = os.WriteFile("output.txt", []byte("Hello"), 0644)
if err != nil {
    log.Fatal(err)
}

对比Python：

with open('test.txt') as f:
    data = f.read()

with open('output.txt', 'w') as f:
    f.write("Hello")

对比JavaScript：

const fs = require('fs');
fs.readFile('test.txt', (err, data) => {
    console.log(data.toString());
});

fs.writeFile('output.txt', 'Hello', err => {});

JSON处理

Go版本:

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

// 编码
p := Person{"Alice", 25}
jsonData, _ := json.Marshal(p)

// 解码
var p2 Person
json.Unmarshal(jsonData, &p2)

对比Python：

import json

data = json.dumps({"name": "Alice", "age": 25})
p = json.loads(data)

对比JavaScript：

const data = JSON.stringify({name: "Alice", age: 25});
const p = JSON.parse(data);

关键区别：

1. Go需要定义结构体对应JSON结构
2. 字段标签控制JSON属性名
3. 编解码可能返回错误需要处理

3. 测试与性能

单元测试

Go版本:

// math.go
func Add(a, b int) int {
    return a + b
}

// math_test.go
func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Expected 5, got %d", result)
    }
}

运行测试：

go test

对比Python unittest：

import unittest

def add(a, b):
    return a + b

class TestMath(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)

基准测试

Go版本:

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(1, 2)
    }
}

运行基准测试：

go test -bench=.

4. 项目实践

简单HTTP服务

Go版本:

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
}

func main() {
    http.HandleFunc("/", helloHandler)
    http.ListenAndServe(":8080", nil)
}

对比Python Flask：

from flask import Flask
app = Flask(__name__)

@app.route('/<name>')
def hello(name):
    return f"Hello, {name}!"

app.run(port=8080)

对比JavaScript Express：

const express = require('express');
const app = express();

app.get('/:name', (req, res) => {
    res.send(`Hello, ${req.params.name}!`);
});

app.listen(8080);

项目结构建议

典型Go项目布局：

myapp/
├── cmd/
│   └── myapp/
│       └── main.go
├── internal/
│   ├── handler/
│   ├── service/
│   └── repository/
├── pkg/
│   └── utils/
├── go.mod
├── go.sum
└── README.md

进一步学习资源

1. 官方文档：https://golang.org/doc/
2. 标准库参考：https://pkg.go.dev/std
3. 经典书籍：《Go程序设计语言》《Go语言实战》
4. 开源项目：Docker, Kubernetes, Etcd等Go项目源码

下篇介绍了Go最强大的并发特性和实际项目开发中的关键技能。Go通过goroutine和channel提供了独特的并发编程模型，相比其他语言的线程/异步方案更加简单高效。建议通过实际项目练习来巩固这些概念，逐步掌握Go语言的精髓。