Linux环境下Go语言并发编程指南

在Linux环境下使用Go语言进行并发编程，主要依赖于Go的轻量级线程——goroutines和通道（channels）。以下是一些基本的并发编程概念和实践：

1. Goroutines

Goroutines是Go语言中实现并发的主要方式。它们比传统的操作系统线程更轻量级，启动更快，且可以轻松创建成千上万个。

func printNumbers() {
    
    for i := 1;
     i <
    = 5;
 i++ {

        fmt.Println(i)
    }

}


func main() {

    go printNumbers() // 创建一个新的goroutine
    time.Sleep(time.Second) // 等待goroutine完成
}

2. Channels

Channels是用于在goroutines之间通信的管道。它们可以用来传递数据，同步goroutines的执行，或者作为信号通知其他goroutines。

func sum(s []int, c chan int) {

    sum := 0
    for _, v := range s {

        sum += v
    }
    
    c <
- sum // 将结果发送到channel
    close(c)
}


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)
}

3. 同步

Go提供了多种同步机制，包括sync.WaitGroup、sync.Mutex等。

sync.WaitGroup

sync.WaitGroup用于等待一组goroutines完成。

var wg sync.WaitGroup

func worker(id int) {

    defer wg.Done() // 在函数结束时调用Done()
    fmt.Printf("Worker %d starting\n", id)
    // 执行工作...
    fmt.Printf("Worker %d done\n", id)
}


func main() {
    
    for i := 1;
     i <
    = 5;
 i++ {

        wg.Add(1) // 增加WaitGroup的计数器
        go worker(i)
    }

    wg.Wait() // 等待所有goroutines完成
}

sync.Mutex

sync.Mutex用于保护共享资源，防止多个goroutines同时访问。

var mu sync.Mutex
var sharedResource int

func increment() {

    mu.Lock()         // 加锁
    sharedResource++
    mu.Unlock()       // 解锁
}


func main() {
    
    for i := 0;
     i <
     1000;
 i++ {

        go increment()
    }

    time.Sleep(time.Second)
    fmt.Println(sharedResource)
}

4. Select语句

select语句用于在多个通道操作中进行选择，类似于switch语句，但每个case都是一个通道操作。

func main() {

    c1 := make(chan string)
    c2 := make(chan string)

    go func() {
    
        time.Sleep(1 * time.Second)
        c1 <
- "one"
    }
()
    go func() {
    
        time.Sleep(2 * time.Second)
        c2 <
- "two"
    }
    ()

    for i := 0;
     i <
     2;
 i++ {

        select {
    
        case msg1 := <
    -c1:
            fmt.Println("Received", msg1)
        case msg2 := <
-c2:
            fmt.Println("Received", msg2)
        }

    }

}
    

5. 并发模式

Go语言中有一些常见的并发模式，如生产者-消费者、工作池等。

生产者-消费者

func producer(c chan<
- int) {
    
    for i := 0;
     ;
 i++ {
    
        c <
- i // 发送数据到channel
    }

}
    

func consumer(c <
    -chan int, done chan<
- bool) {

    for n := range c {

        fmt.Println(n)
    }
    
    done <
- true
}


func main() {
    
    c := make(chan int)
    done := make(chan bool)

    go producer(c)
    go consumer(c, done)

    <
-done // 等待consumer完成
}
    

工作池

func worker(id int, jobs <
    -chan int, results chan<
- int) {

    for j := range jobs {
    
        fmt.Printf("Worker %d started job %d\n", id, j)
        time.Sleep(time.Second)
        fmt.Printf("Worker %d finished job %d\n", id, j)
        results <
- j * 2
    }

}


func main() {
    
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    for w := 1;
     w <
    = 3;
 w++ {

        go worker(w, jobs, results)
    }
    

    for j := 1;
     j <
    = 9;
 j++ {
    
        jobs <
- j
    }
    
    close(jobs)

    for a := 1;
     a <
    = 9;
 a++ {
    
        <
-results
    }

}
    

总结

Go语言的并发编程模型简单而强大，通过goroutines和channels可以轻松实现高效的并发处理。合理使用同步机制和并发模式，可以编写出高性能的并发程序。

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！