我正在用 Go 编写一个搜索引擎，其中我有一个单词的倒排索引到每个单词的相应结果。有一套单词字典，所以单词已经转换为 StemID，它是一个从 0 开始的整数。这允许我使用指针 slice (即 稀疏数组) 将每个 StemID 映射到包含该查询结果的结构。例如。 var StemID_to_Index []*resultStruct。如果 aardvark 为 0，则指向 aardvark 的 resultStruct 的指针位于 StemID_to_Index[0]，这将如果当前未加载该词的结果，则为 nil。

服务器上没有足够的内存来存储所有这些，因此每个 StemID 的结构将被保存为单独的文件，这些可以加载到 StemID_to_Index slice 。如果 StemID_to_Index 当前对于此 StemID 为 nil，则结果不会被缓存并需要加载，否则它已经被加载(缓存)等等可以直接使用。每次加载新结果时，都会检查内存使用情况，如果超过阈值，则丢弃 2/3 的加载结果(StemID_to_Index 设置为 nil这些 StemID 和垃圾回收是强制的。)

我的问题是并发性。什么是最快和最有效的方式，我可以让多个线程同时搜索，而不会出现不同线程试图同时读取和写入同一个地方的问题？我尽量避免对所有内容使用互斥体，因为这会减慢每次访问尝试的速度。

你认为我会在工作线程中从磁盘加载结果，然后使用 channel 将指向此结构的指针传递给“更新程序”线程，然后更新 nil 值吗？在 StemID_to_Index slice 中加载结果的指针？这意味着两个线程永远不会尝试同时写入，但是如果另一个线程试图从 StemID_to_Index 的确切索引读取，而“更新程序”线程正在更新指针，会发生什么情况？如果一个线程被赋予一个指向当前正在加载的结果的 nil 指针并不重要，因为它只会被加载两次，虽然这是一种资源浪费，但它仍然会提供相同的结果结果，因为这种情况不太可能经常发生，所以这是可以原谅的。

此外，将要更新的指针发送到“更新程序”线程的工作线程如何知道“更新程序”线程何时完成更新 slice 中的指针？它应该只是休眠并继续检查，还是有一种简单的方法让更新程序将消息发送回推送到 channel 的特定线程？

更新

我做了一个小测试脚本，看看如果在修改指针的同时尝试访问指针会发生什么……它似乎总是没问题。没有错误。我错过了什么吗？

package main

import (
    "fmt"
    "sync"
)

type tester struct {
 a uint
}

var things *tester

func updater() {
    var a uint
    for {
        what := new(tester)
        what.a = a
        things = what
        a++
    }
}

func test() {
    var t *tester
    for {
        t = things
        if t != nil {
            if t.a < 0 {
                fmt.Println(`Error1`)
            }
        } else {
            fmt.Println(`Error2`)
        }
    }
}

func main() {
    var wg sync.WaitGroup
    things = new(tester)
    go test()
    go test()
    go test()
    go test()
    go test()
    go test()
    go updater()
    go test()
    go test()
    go test()
    go test()
    go test()
    wg.Add(1)
    wg.Wait()
}

更新 2

更进一步，即使我同时从多个线程读取和写入同一个变量......这没有区别，仍然没有错误:

从上面看:

func test() {
    var a uint
    var t *tester
    for {
        t = things
        if t != nil {
            if t.a < 0 {
                fmt.Println(`Error1`)
            }
        } else {
            fmt.Println(`Error2`)
        }
        what := new(tester)
        what.a = a
        things = what
        a++
    }
}

这意味着我根本不必担心并发问题……再说一次:我在这里遗漏了什么吗？

最佳答案

这听起来像是 memory mapped file 的完美用例:

package main

import (
    "log"
    "os"
    "unsafe"

    "github.com/edsrzf/mmap-go"
)

func main() {
    // Open the backing file
    f, err := os.OpenFile("example.txt", os.O_RDWR|os.O_CREATE, 0644)
    if err != nil {
        log.Fatalln(err)
    }
    defer f.Close()

    // Set it's size
    f.Truncate(1024)

    // Memory map it
    m, err := mmap.Map(f, mmap.RDWR, 0)
    if err != nil {
        log.Fatalln(err)
    }
    defer m.Unmap()

    // m is a byte slice
    copy(m, "Hello World")
    m.Flush()

    // here's how to use it with a pointer
    type Coordinate struct{ X, Y int }
    // first get the memory address as a *byte pointer and convert it to an unsafe
    // pointer
    ptr := unsafe.Pointer(&m[20])
    // next convert it into a different pointer type
    coord := (*Coordinate)(ptr)
    // now you can use it directly
    *coord = Coordinate{1, 2}
    m.Flush()
    // and vice-versa
    log.Println(*(*Coordinate)(unsafe.Pointer(&m[20])))
}

内存映射可以比实际内存大，操作系统会为您处理所有杂乱的细节。

您仍然需要确保单独的 goroutines 永远不会同时读取/写入同一内​​存段。

关于multithreading - Go:稀疏数组读写的线程安全并发问题，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/29428546/