如何使用 golang 实现分布式并发，跨越多个机器？

package main

import (
    "fmt"
    "runtime"
)

func main() {
    // 创建一个通道，用于 goroutine 之间通信
    ch := make(chan int)

    // 创建并启动 goroutine
    go func() {
        for i := 0; i < 100; i++ {
            ch <- i
        }
        close(ch) // 关闭通道，表示没有更多数据发送
    }()

    // 从通道中读取数据并打印
    for v := range ch {
        fmt.Println(v)
    }

    fmt.Println("Number of goroutines:", runtime.NumGoroutine())
}

package main

import (
    "fmt"
    "time"
)

func main() {
    // 创建一个通道，用于传递数据
    ch := make(chan int)

    // 创建并启动 goroutine，将数据发送到通道中
    go func() {
        for i := 0; i < 10; i++ {
            ch <- i
            time.Sleep(100 * time.Millisecond) // 模拟延迟
        }
        close(ch) // 关闭通道，表示没有更多数据发送
    }()

    // 从通道中读取数据并打印
    for v := range ch {
        fmt.Println(v)
    }
}

package main

import (
    "bufio"
    "context"
    "fmt"
    "io"
    "io/ioutil"
    "log"
    "net/http"
    "os"
    "strconv"
    "sync"
)

// 用于处理请求的 goroutine 数量
var numOfWorkers int = 5

// 用于同步 goroutine
var wg sync.WaitGroup

func main() {
    // 从命令行读取文件名
    if len(os.Args) != 2 {
        log.Fatal("Usage: go run worker_pool.go <filename>")
    }
    filename := os.Args[1]

    // 为每个请求创建一个 goroutine 池
    ctx := context.Background()
    pool := make(chan context.Context, numOfWorkers)
    for i := 0; i < numOfWorkers; i++ {
        go worker(ctx, pool, filename)
    }

    // 读取文件并分配每行到 goroutine 池中
    file, err := ioutil.ReadFile(filename)
    if err != nil {
        log.Fatal(err)
    }
    scanner := bufio.NewScanner(bytes.NewReader(file))
    count := 0
    for scanner.Scan() {
        pool <- ctx
        wg.Add(1)
        go handleLine(scanner.Text(), &wg)
        count++
    }
    if err := scanner.Err(); err != nil {
        log.Fatal(err)
    }
    
    wg.Wait()
    fmt.Println("Total lines processed:", count)
}

// 处理一行数据的 goroutine
func handleLine(line string, wg *sync.WaitGroup) {
    defer wg.Done()
    defer func() { <-pool }()
    
    // 处理行的数据
    num, err := strconv.Atoi(line)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(num * num)
}

// 分配请求的 goroutine
func worker(ctx context.Context, pool chan context.Context, filename string) {
    for {
        // 从池中获取请求
        select {
        case <-pool:
        case <-ctx.Done():
            return
        }
        
        // 打开文件并读取下一行
        file, err := os.Open(filename)
        if err != nil {
            log.Fatal(err)
        }
        var line string
        _, err = file.ReadString('\n')
        if err != nil && err != io.EOF {
            log.Fatal(err)
        }
        if err == io.EOF {
            file.Close()
            continue
        }
        line = strings.TrimRight(line, "\n")
        
        // 处理行的数据
        num, err := strconv.Atoi(line)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println(num * num)
        file.Close()
    }
}