Go 语言基础教程：从语法到并发编程

前言

Go 语言以简洁的语法、出色的并发模型和编译速度著称，在云原生和服务端开发领域占据重要地位。本文将系统介绍 Go 的核心语法和并发编程。

一、环境与项目

1.1 安装

go version  # go1.22.x

# 设置国内代理
go env -w GOPROXY=https://goproxy.cn,direct
go env -w GO111MODULE=on

1.2 创建项目

mkdir myapp && cd myapp
go mod init github.com/yourname/myapp

二、基础语法

2.1 变量与类型

package main

import "fmt"

func main() {
    var name string = "Go"
    var age int = 18
    var score = 95.5
    isReady := true
    x, y := 10, 20

    fmt.Println(name, age, score, isReady, x, y)
}

2.2 结构体与方法

type User struct {
    ID   int
    Name string
    Age  int
}

func (u User) Greet() string {
    return fmt.Sprintf("Hi, I am %s", u.Name)
}

func (u *User) SetAge(age int) {
    u.Age = age
}

func main() {
    u := User{ID: 1, Name: "张三", Age: 25}
    fmt.Println(u.Greet())

    u.SetAge(26)
    fmt.Println(u.Age)
}

2.3 接口

type Animal interface {
    Speak() string
}

type Dog struct{ Name string }
type Cat struct{ Name string }

func (d Dog) Speak() string { return d.Name + ": 汪汪!" }
func (c Cat) Speak() string { return c.Name + ": 喵喵!" }

func makeSpeak(a Animal) {
    fmt.Println(a.Speak())
}

func main() {
    makeSpeak(Dog{"旺财"})
    makeSpeak(Cat{"咪咪"})
}

2.4 错误处理

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Result:", result)
}

三、并发编程

3.1 Goroutine

func sayHello(name string) {
    fmt.Printf("Hello, %s!\n", name)
}

func main() {
    go sayHello("张三")
    go sayHello("李四")
    time.Sleep(time.Second)
}

3.2 Channel

func main() {
    ch := make(chan string)

    go func() {
        ch <- "来自 goroutine 的消息"
    }()

    msg := <-ch
    fmt.Println(msg)
}

3.3 带缓冲的 Channel

ch := make(chan int, 3)

ch <- 1
ch <- 2
ch <- 3
// ch <- 4 // 阻塞！缓冲区已满

fmt.Println(<-ch) // 1

3.4 select 多路复用

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    go func() {
        time.Sleep(1 * time.Second)
        ch1 <- "来自 ch1"
    }()

    go func() {
        time.Sleep(2 * time.Second)
        ch2 <- "来自 ch2"
    }()

    select {
    case msg := <-ch1:
        fmt.Println(msg)
    case msg := <-ch2:
        fmt.Println(msg)
    }
}

3.5 WaitGroup 等待多个 goroutine

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d started\n", id)
    time.Sleep(time.Second)
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }

    wg.Wait()
    fmt.Println("All workers done")
}

3.6 并发安全：Mutex

type Counter struct {
    mu    sync.Mutex
    count int
}

func (c *Counter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}

func (c *Counter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}

func main() {
    c := &Counter{}
    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            c.Increment()
        }()
    }

    wg.Wait()
    fmt.Println("Final count:", c.Value())
}

四、HTTP 服务

func main() {
    http.HandleFunc("/api/hello", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(map[string]string{
            "msg": "Hello from Go!",
        })
    })

    fmt.Println("Server running on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

五、总结

Go 的核心优势在于：语法简洁上手快、goroutine 轻量级并发、编译速度快、标准库强大。掌握 struct/interface/goroutine/channel 这四个核心概念，就能写出高质量的 Go 程序。建议在实际项目中配合 Gin/Echo 等 Web 框架和 GORM 等 ORM 框架，进一步提升开发效率。