正文

掌握Golang高并发编程，轻松应对复杂场景：50个实战示例解析

/0 浏览量
1016

Golang，也称为Go语言，因其高效的并发处理能力在互联网行业备受欢迎。本文将深入探讨Golang的高并发编程技巧，通过50个实战示例，帮助读者轻松应对复杂场景。

1. Go语言的并发模型

1.1 Goroutine

Goroutine是Go语言并发编程的核心。它是轻量级的线程，由Go运行时管理。通过使用关键字go，可以轻松启动一个新的Goroutine。

package main

import (
    "fmt"
)

func main() {
    go say("hello")
    say("world")
}

func say(s string) {
    fmt.Println(s)
}

1.2 Channel

Channel是Goroutine之间通信的桥梁。通过Channel，可以实现线程安全的共享数据。

package main

import (
    "fmt"
)

func main() {
    ch := make(chan string)
    go func() {
        ch <- "hello"
    }()
    fmt.Println(<-ch)
}

2. 高并发编程实战示例

2.1 并发下载

使用Goroutine和Channel实现文件并发下载。

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "sync"
)

func download(url string, wg *sync.WaitGroup, ch chan<- string) {
    defer wg.Done()
    resp, err := http.Get(url)
    if err != nil {
        ch <- err.Error()
        return
    }
    defer resp.Body.Close()
    data, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        ch <- err.Error()
        return
    }
    ch <- string(data)
}

func main() {
    urls := []string{
        "https://www.google.com",
        "https://www.bing.com",
        "https://www.alibaba.com",
    }
    var wg sync.WaitGroup
    ch := make(chan string, len(urls))
    for _, url := range urls {
        wg.Add(1)
        go download(url, &wg, ch)
    }
    wg.Wait()
    close(ch)
    for data := range ch {
        fmt.Println(data)
    }
}

2.2 并发排序

使用Goroutine和Channel实现并发排序。

package main

import (
    "fmt"
    "sync"
)

func sort(arr []int, ch chan<- []int) {
    sortArr := make([]int, len(arr))
    copy(sortArr, arr)
    sort.Ints(sortArr)
    ch <- sortArr
}

func main() {
    arr := []int{5, 3, 8, 4, 1, 9, 2, 7, 6}
    var wg sync.WaitGroup
    ch := make(chan []int, 4)
    for i := 0; i < 4; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            sort(arr, ch)
        }()
    }
    wg.Wait()
    close(ch)
    for data := range ch {
        fmt.Println(data)
    }
}

2.3 并发缓存

使用Goroutine和Channel实现并发缓存。

package main

import (
    "fmt"
    "sync"
)

type Cache struct {
    data map[string]string
    mu   sync.Mutex
}

func (c *Cache) Get(key string) string {
    c.mu.Lock()
    defer c.mu.Unlock()
    if val, ok := c.data[key]; ok {
        return val
    }
    return ""
}

func (c *Cache) Set(key, value string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.data[key] = value
}

func main() {
    c := &Cache{data: make(map[string]string)}
    c.Set("key1", "value1")
    c.Set("key2", "value2")
    fmt.Println(c.Get("key1")) // 输出: value1
    fmt.Println(c.Get("key3")) // 输出: 
}

3. 总结

通过以上实战示例，相信读者已经对Golang高并发编程有了更深入的了解。在实际项目中，灵活运用这些技巧，将有助于提升应用性能和稳定性。祝大家在学习过程中取得进步！

-- 展开阅读全文 --