如何实现对共享数据结构的并发操作

为了在并发环境中查找共享数据结构中的字符串匹配项，开发者需要考虑并发方法的性能和效率。一种常见的方法是启动 goroutine 来处理特定输入组合，并通过通道传递结果。然而，复制数据结构的开销可能会影响性能。

我正在解决 go 中的一个难题，该难题通过旋转 ascii 字节值以按行（left->right）或按列（top->bottom）匹配字符串来查找 2d 字节数组中的字符串。我能够按顺序解决它，当要同时解决它时，我尝试启动一个 go 例程来处理特定的输入组合，看看是否有任何可能的 25 次旋转可以找到匹配项。代码摘要如下

findbyconcurrentrot 是一种采用 2d 字符数组输入并尝试在各种可能的输入组合中查找字符串匹配项的方法。

问题是 - 下面使用的并发方法性能好吗？如何改进？将顺序例程“按原样”转换为并发程序的方法是否错误？即是否应该重写整个程序以充分利用并发功能？

// searchresult defines the information needed to pass to identify if a match has been identified during concurrent search
type searchresult struct {
    row   int
    col   int
    rot   int
    found bool
}

// processsearchresults runs the gorotuine to perform the search for a particular rotation of input
func processsearchresults(wg *sync.waitgroup, iter int, resultchan chan searchresult, table [][]byte, word string) {
    // call goroutine end when the function returns
    defer wg.done()
    if iter >= 1 {
        rotate(table, iter)
    }
    x, y, match := present(table, word)
    if match {
        resultchan <- searchresult{row: x, col: y, rot: iter, found: true}
        return
    }
    resultchan <- searchresult{found: false}
}

// docopy creates a copy of the original table to passed for each iteration of the concurrent search
// this is an expensive operation on a goroutine, because of memory copy operations
// the copy is needed for the goroutines to have their own control of data and not run into data
// races by passing the original data to each of them
func docopy(table [][]byte) [][]byte {
    copytable := make([][]byte, len(table))
    for i := range table {
        copytable[i] = make([]byte, len(table[i]))
        copy(copytable[i], table[i])
    }
    return copytable
}

// findbyconcurrentrot searches for the string in the ascii character array by using concurrency primitives
// the function spawns goroutines by rotating all combinations of the input table possible and passing them
// their own copy of original table and processes the results back in a channel
func findbyconcurrentrot(table [][]byte, word string) (int, int, int, bool) {
    iter := 0
    resultchan := make(chan searchresult, maxiteration)
    var wg sync.waitgroup

    for iter <= maxiteration {
        wg.add(1)
        go processsearchresults(&wg, iter, resultchan, docopy(table), word)
        iter++
    }

    // stop the range channel, when we finish waiting for all the goroutines
    go func() {
        wg.wait()
        close(resultchan)
    }()

    resultcount := 0
    // process result from each goroutine on the channel
    for result := range resultchan {
        resultcount++
        if result.found {
            return result.row, result.col, result.rot, result.found
        }
    }

    return 0, 0, 0, false
}

完整的 mvce 位于此 go 演示链接 - https://go.dev/play/p/7yfasalfruw

注意：基准测试结果表明顺序版本的性能远远优于并发版本

go test -bench=.
goos: darwin
goarch: amd64
pkg: github.com/inianv/go-wordsearchpuzzle/wordsearch
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
BenchmarkTestSequentialSearch-12        11003130           106.4 ns/op
BenchmarkTestConcurrentSearch-12           38865         32031 ns/op
PASS
ok      github.com/inianv/go-wordsearchpuzzle/wordsearch    3.339s

正确答案

这种方法可能会因为复制表所花费的周期过多而受到影响。由于每个 goroutine 都在修改表，因此每个 goroutine 都必须获得单独的副本。

另一种方法是在只读表之上添加一个层，为每个 goroutine 提供修改后的视图。这并不能保证更好的性能，但它可能比使用多个 goroutine 进行复制的性能更好。

该方法是有一个表格视图：

type tableView struct {
   inc int
   table [][]byte
}

func (t tableView) get(row,col int) byte {
   v:=t.table[row][col]
   v+=t.inc
   if v>'z' {...}
   return v
}

然后，初始化并传递一个 tableview 实例。

再次强调：这可能不会像您期望的那样快，但它的性能可能比表的多个副本更好。您必须测试并查看。

今天关于《如何实现对共享数据结构的并发操作》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！