使用Go和Goroutines实现高并发的数据流处理

func main() {
    go myFunction() // 创建一个Goroutine并运行myFunction()
}

func myFunction() {
    // 在这里编写需要并发执行的代码
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    dataChan := make(chan int) // 创建一个传递整数的通道
    resultChan := make(chan int) // 创建一个传递计算结果的通道
    done := make(chan bool) // 创建一个用于通知结束的通道

    go produceData(dataChan) // 创建一个Goroutine来生成数据
    go processData(dataChan, resultChan) // 创建一个Goroutine来处理数据
    go consumeResult(resultChan, done) // 创建一个Goroutine来消费结果

    <-done // 阻塞主Goroutine直到所有计算完成
    fmt.Println("All calculations are done!")
}

func produceData(out chan<- int) {
    for i := 0; i < 100; i++ {
        out <- i // 将数据发送到通道
    }
    close(out) // 关闭通道
}

func processData(in <-chan int, out chan<- int) {
    for num := range in {
        // 在这里进行数据处理
        result := num * num
        out <- result // 将处理结果发送到通道
    }
    close(out) // 关闭通道
}

func consumeResult(in <-chan int, done chan<- bool) {
    var wg sync.WaitGroup

    for result := range in {
        wg.Add(1)
        go func(r int) {
            // 在这里进行结果消费
            fmt.Println("Result:", r)
            wg.Done()
        }(result)
    }

    wg.Wait()
    done <- true // 通知主Goroutine结束
}