Golang读写同一*os.File时可能发生死锁的问题

在Golang中同时读写同一个*os.File确实容易导致死锁，特别是在使用同步原语时。让我分析你的代码并给出具体示例。

问题分析

从你的描述看，主要问题可能出现在以下几个方面：

1. 文件指针竞争

当多个goroutine同时操作同一个文件描述符时，文件指针的位置会相互干扰：

// 错误示例 - 会导致死锁
func readWriteSameFile() {
    file, _ := os.OpenFile("test.dat", os.O_RDWR, 0644)
    
    go func() {
        for {
            buf := make([]byte, 1024)
            n, err := file.Read(buf)  // 移动文件指针
            if err != nil {
                break
            }
            // 处理数据...
        }
    }()
    
    go func() {
        for {
            data := []byte("some data")
            _, err := file.Write(data)  // 也移动文件指针
            if err != nil {
                break
            }
        }
    }()
    
    time.Sleep(time.Second * 10)
    file.Close()
}

2. sync.Cond 使用不当

在你的代码中，sync.Cond可能没有正确等待和通知：

// 正确的sync.Cond使用模式
type Pipe struct {
    cond   *sync.Cond
    buffer []byte
    closed bool
}

func (p *Pipe) Write(data []byte) (int, error) {
    p.cond.L.Lock()
    defer p.cond.L.Unlock()
    
    if p.closed {
        return 0, io.ErrClosedPipe
    }
    
    p.buffer = append(p.buffer, data...)
    p.cond.Signal()  // 通知等待的读取者
    return len(data), nil
}

func (p *Pipe) Read(b []byte) (int, error) {
    p.cond.L.Lock()
    defer p.cond.L.Unlock()
    
    for len(p.buffer) == 0 && !p.closed {
        p.cond.Wait()  // 等待数据可用
    }
    
    if len(p.buffer) == 0 && p.closed {
        return 0, io.EOF
    }
    
    n := copy(b, p.buffer)
    p.buffer = p.buffer[n:]
    return n, nil
}

3. 文件读写分离方案

对于你的用例，建议使用不同的文件句柄：

type Standpipe struct {
    file     *os.File
    readFile *os.File  // 单独的读取句柄
    cond     *sync.Cond
    offsets  []int64
    closed   bool
}

func NewStandpipe(filename string) (*Standpipe, error) {
    file, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, 0644)
    if err != nil {
        return nil, err
    }
    
    // 打开同一个文件的第二个句柄用于读取
    readFile, err := os.Open(filename)
    if err != nil {
        file.Close()
        return nil, err
    }
    
    sp := &Standpipe{
        file:     file,
        readFile: readFile,
        cond:     sync.NewCond(&sync.Mutex{}),
    }
    
    return sp, nil
}

func (sp *Standpipe) Write(data []byte) (int, error) {
    sp.cond.L.Lock()
    defer sp.cond.L.Unlock()
    
    if sp.closed {
        return 0, io.ErrClosedPipe
    }
    
    offset, err := sp.file.Seek(0, io.SeekEnd)
    if err != nil {
        return 0, err
    }
    
    n, err := sp.file.Write(data)
    if err != nil {
        return n, err
    }
    
    sp.offsets = append(sp.offsets, offset)
    sp.cond.Signal()
    return n, nil
}

func (sp *Standpipe) Read(b []byte) (int, error) {
    sp.cond.L.Lock()
    defer sp.cond.L.Unlock()
    
    for len(sp.offsets) == 0 && !sp.closed {
        sp.cond.Wait()
    }
    
    if len(sp.offsets) == 0 && sp.closed {
        return 0, io.EOF
    }
    
    offset := sp.offsets[0]
    sp.offsets = sp.offsets[1:]
    
    // 使用读取句柄，避免干扰写入位置
    _, err := sp.readFile.Seek(offset, io.SeekStart)
    if err != nil {
        return 0, err
    }
    
    return sp.readFile.Read(b)
}

4. 使用管道替代文件

对于内存缓冲的场景，考虑使用io.Pipe：

func pipeExample() {
    pr, pw := io.Pipe()
    
    go func() {
        defer pw.Close()
        for i := 0; i < 10; i++ {
            data := []byte(fmt.Sprintf("Data chunk %d\n", i))
            if _, err := pw.Write(data); err != nil {
                break
            }
            time.Sleep(time.Millisecond * 100)
        }
    }()
    
    go func() {
        buf := make([]byte, 1024)
        for {
            n, err := pr.Read(buf)
            if err != nil {
                break
            }
            fmt.Printf("Read: %s", buf[:n])
        }
    }()
    
    time.Sleep(time.Second * 2)
}

关键修复点

1. 使用独立的文件句柄进行读写操作
2. 确保sync.Cond的等待和通知正确配对
3. 正确处理goroutine间的同步和关闭信号
4. 考虑使用更简单的并发原语如channel

检查你的代码中是否在等待条件变量时没有正确处理虚假唤醒，或者在关闭时没有正确通知所有等待的goroutine。