Question

每次请求进来时，我都会不时地向一个文件写入一些数据。我还想解析这个文件并有时读取它。如果不断写入文件，我该怎么读？模式是什么？

Answer 1

您可以使用sync.RWMutex。然后：

当您需要阅读文件时，请致电<test name="Order" preserve-order="true" enabled="true"> <classes> <class name="com.sw.testcases.EcommCreate1" /> <class name="com.sw.testcases.BoCreate1" /> </classes> </test>，阅读，然后致电RLock()。
当您需要写入文件时，请致电RUnlock()，写信，然后拨打Lock()。

只要您这样做，就可以确保：

任何时候只有一个goroutine会写入该文件。
如果您在修改文件时尝试读取该文件，则锁定将等到您完成写入后再开始读取文件。
如果您在读取文件时尝试写入该文件，则锁定将等到您完成阅读后再开始写入。

这是一个很小的例子：

Unlock()

Answer 2

所以你想要阅读＆amp;写文件而不锁定，
Stateful Goroutines和渠道是解决方案：
一个Stateful Goroutine管理读写请求工作示例代码：

package main

import "os"
import "fmt"
import "sync"

type Buffer struct {
    buf []byte
    off int64
}

var wg sync.WaitGroup

func main() {
    wr := make(chan *Buffer)
    rq := make(chan *Buffer)
    rd := make(chan *Buffer)
    wg.Add(1)
    go manage("file.bin", wr, rq, rd)

    wr <- &Buffer{buf: []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, off: 0}            //write
    wr <- &Buffer{buf: []byte{10, 11, 12, 13, 14, 15, 16, 17, 18, 19}, off: 10} //write

    rq <- &Buffer{buf: make([]byte, 20), off: 0} //request to read
    b := <-rd                                    //read
    fmt.Println("read:", b)
    //read: &{[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19] 0}

    rq <- &Buffer{buf: nil, off: -1} // exit
    wg.Wait()
    fmt.Println("Bye") //Bye
}

func manage(filename string, wr, rq, rd chan *Buffer) {
    f, e := os.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
    if e != nil {
        panic(e.Error())
    }
    defer f.Close()
    for {
        select {
        case b := <-wr:
            f.WriteAt(b.buf, b.off)
        default:
        }
        select {
        case b := <-rq:
            if b.off == -1 {
                wg.Done()
                return
            }
            n, _ := f.ReadAt(b.buf, b.off)
            rd <- &Buffer{b.buf[1:n], b.off}
        default:
        }
    }
}

从文件中读取而不锁定它

2 个答案: