Golang并发编程实践指南

Golang并发编程实践指南 Go语言的主要特点是什么？我对Go语言的并发机制不太了解，如果有人知道答案，请帮帮我。谢谢。

3 回复

Go 主页对“Golang 的主要特点”是这样描述的：

Go 是一种开源编程语言，它使得构建简单、可靠且高效的软件变得容易。

更多关于Golang并发编程实践指南的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


长话短说，与传统的线程不同，Go语言实现了一种名为goroutine的轻量级例程，它们由运行时进行软件管理，可以并发运行，使你能够近乎同时地执行许多任务。并发性与其他语言类似，但在这里它更加轻量（如果不是最轻量的话），你可以非常轻松地同时运行成千上万个任务。

Go语言的主要特点包括：

  1. 内置并发支持：通过goroutine和channel实现轻量级并发
  2. 简洁的语法：类似C的语法但更加简洁
  3. 垃圾回收：自动内存管理
  4. 静态类型：编译时类型检查
  5. 快速编译：编译速度快
  6. 跨平台：支持多平台编译

关于Go的并发机制，核心是goroutine和channel：

goroutine示例：

package main

import (
    "fmt"
    "time"
)

func printNumbers(name string) {
    for i := 1; i <= 3; i++ {
        fmt.Printf("%s: %d\n", name, i)
        time.Sleep(time.Millisecond * 100)
    }
}

func main() {
    // 启动两个goroutine
    go printNumbers("goroutine1")
    go printNumbers("goroutine2")
    
    // 等待goroutine执行
    time.Sleep(time.Second)
}

channel示例：

package main

import "fmt"

func sum(numbers []int, ch chan int) {
    total := 0
    for _, num := range numbers {
        total += num
    }
    ch <- total // 发送结果到channel
}

func main() {
    numbers := []int{1, 2, 3, 4, 5, 6}
    ch := make(chan int)
    
    // 将数组分成两部分并发计算
    go sum(numbers[:len(numbers)/2], ch)
    go sum(numbers[len(numbers)/2:], ch)
    
    // 从channel接收结果
    part1, part2 := <-ch, <-ch
    fmt.Printf("Sum: %d + %d = %d\n", part1, part2, part1+part2)
}

带缓冲的channel：

package main

import "fmt"

func main() {
    // 创建缓冲大小为2的channel
    ch := make(chan string, 2)
    
    ch <- "message1"
    ch <- "message2"
    
    fmt.Println(<-ch) // message1
    fmt.Println(<-ch) // message2
}

select多路复用：

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)
    
    go func() {
        time.Sleep(time.Second)
        ch1 <- "from ch1"
    }()
    
    go func() {
        time.Sleep(2 * time.Second)
        ch2 <- "from ch2"
    }()
    
    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-ch1:
            fmt.Println(msg1)
        case msg2 := <-ch2:
            fmt.Println(msg2)
        }
    }
}

sync.WaitGroup等待goroutine完成：

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d starting\n", id)
    // 模拟工作
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup
    
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }
    
    wg.Wait()
    fmt.Println("All workers completed")
}

这些示例展示了Go并发编程的基本模式。goroutine是轻量级线程，channel用于goroutine间通信，select处理多个channel操作，sync包提供同步原语。

回到顶部