Go并发与网络编程实践

原创

于 2025-09-16 09:18:43 发布 · 372 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#Go # 并发 # 共享内存

43、尝试实现一个使用共享内存的并发版本的 wc(1) 工具。

下面是给定的【文本内容】：需编写 Go 代码实现并发版本的 `wc(1)` 工具，在代码里使用共享内存来完成任务。可定义一个共享变量存储计数结果，使用互斥锁保证对共享变量的并发安全访问。比如，为每个文件创建一个 goroutine 进行计数，在 goroutine 里加锁更新共享变量，完成后解锁。

示例代码框架如下：

```go
package main

import (
    "fmt"
    "os"
    "strings"
    "sync"
)

var (
    wordCount int
    mutex     sync.Mutex
)

func countWordsInFile(filePath string, wg *sync.WaitGroup) {
    defer wg.Done()
    file, err := os.ReadFile(filePath)
    if err != nil {
        fmt.Printf("Error reading file %s: %v\n", filePath, err)
        return
    }
    text := string(file)
    words := strings.Fields(text)
    mutex.Lock()
    wordCount += len(words)
    mutex.Unlock()
}

func main() {
    if len(os.Args) < 2 {
        fmt.Println("Please provide file paths as arguments.")
        return
    }
    var wg sync.WaitGroup
    for _, filePath := range os.Args[1:] {
        wg.Add(1)
        go countWordsInFile(filePath, &wg)
    }
    wg.Wait()
    fmt.Printf("Total word count: %d\n", wordCount)
}

此示例仅为框架，需根据实际需求完善代码。


##44、修改workerPool.go的Go代码，使客户端和数据缓冲通道的大小可以通过命令行参数定义。
要实现这个功能，可按以下步骤修改代码：

首先，在Go代码里使用 `flag` 包来解析命令行参数。接着，用解析出的参数值来初始化 `clients` 和 `data` 缓冲通道的大小。

以下是修改后的代码示例：

```go
package main

import (
    "flag"
    "fmt"
    "sync"
    "time"
)

// 定义Client和Data结构体
type Client struct {
    id      int
    integer int
}

type Data struct {
    job    Client
    square int
}

var (
    size   int
    clients chan Client
    data   chan Data
)

func worker(w *sync.WaitGroup) {
    for c := range clients {
        square := c.integer * c.integer
        output := Data{c, square}
        data <- output
        time.Sleep(time.Second)
    }
    w.Done()
}

func main() {
    // 解析命令行参数
    flag.IntVar(&size, "size", 10, "Size of the clients and data channels")
    flag.Parse()

    // 使用解析出的size值初始化通道
    clients = make(chan Client, size)
    data = make(chan Data, size)

    // 后续代码保持不变
    nJobs := 20
    nWorkers := 5
    var wg sync.WaitGroup
    wg.Add(nWorkers)

    for i := 0; i < nWorkers; i++ {
        go worker(&wg)
    }

    go func() {
        for i := 0; i < nJobs; i++ {
            clients <- Client{id: i, integer: i}
        }
        close(clients)
    }()

    finished := make(chan interface{})

    go func() {
        for d := range data {
            fmt.Printf("Client ID: %d\tint: %d\tsquare: %d\n", d.job.id, d.job.integer, d.square)
        }
        finished <- true
    }()

    wg.Wait()
    close(data)
    fmt.Printf("Finished: %v\n", <-finished)
}

在上述代码中，使用 flag.IntVar 函数来定义一个名为 size 的命令行参数，默认值为10。在 main 函数里解析命令行参数，并用解析出的 size 值来初始化 clients 和 data 缓冲通道的大小。