遇到一个很奇怪的问题。 简化下需求：需要从大文件中读取数据，一次读取两行。

我写了两种解码方式：

1. decode_two_onetime 每次检索两个换行符
2. decode_two_stepbystep 每次检索一个换行符，第一次检索结果记录在decoder中。

第一种方式运行正常，可以顺利读取文件也符合需求。 第二种方式只能读取6行数据，然后就进入 decode_eof表示文件读到头了。

大家帮我看看哪里有问题？为什么第二种方式无法读完整个文件？

use std::time::Duration;

use anyhow::Result;
use tokio::fs::OpenOptions;
use tokio::io::BufReader;
use tokio_stream::StreamExt;
use tokio_util::bytes::BytesMut;
use tokio_util::codec::{Decoder, FramedRead};

#[tokio::main]
async fn main() -> Result<()> {
    let file = OpenOptions::new()
        .read(true)
        .open("e:/test_data.txt")
        .await?;
    let br = BufReader::new(file);
    let mut twoline_reader = FramedRead::new(br, TwoLineDecodec::default());

    loop {
        if let Some(two_line) = twoline_reader.next().await {
            match two_line {
                Ok(two_line) => {
                    println!("Line1:{}", two_line.line1);
                    println!("Line2:{}", two_line.line2);
                }
                Err(e) => println!("Error:{}", e),
            }
        } else {
            println!("Get None");            
            break;
        }
    }

    println!("读取完毕");
    Ok(())
}

pub struct TwoLine {
    pub line1: String,
    pub line2: String,
}

#[derive(Default)]
pub struct TwoLineDecodec {
    pub first_pos: Option<usize>,
}

impl TwoLineDecodec {
    pub fn reset(&mut self) {
        self.first_pos = None;
    }
}

impl Decoder for TwoLineDecodec {
    type Item = TwoLine;
    type Error = anyhow::Error;

    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
        self.decode_two_onetime(src)
        // self.decode_two_stepbystep(src)
    }
    fn decode_eof(&mut self, buf: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
        // 收到EOF，剩余的部分继续读取
        println!("File EOF");
        self.decode(buf)
    }
}

impl TwoLineDecodec {
    fn decode_two_onetime(&mut self, src: &mut BytesMut) -> Result<Option<TwoLine>, anyhow::Error> {
        if let Some(first) = src[..].iter().position(|b| *b == b'\n') {
            self.first_pos = Some(first);
            if let Some(second) = src[first + 1..].iter().position(|b| *b == b'\n') {
                println!("first:{} second:{}", first, second);
                let raw = src.split_to(first + second + 2);
                let twoline = std::str::from_utf8(&raw)?.trim();
                let (line1, line2) = twoline.split_at(first);

                let msg = TwoLine {
                    line1: line1.trim().to_owned(),
                    line2: line2.trim().to_owned(),
                };
                self.reset();
                return Ok(Some(msg));
            }
        }

        Ok(None)
    }
    fn decode_two_stepbystep(
        &mut self,
        src: &mut BytesMut,
    ) -> Result<Option<TwoLine>, anyhow::Error> {
        // println!("Data:{}", std::str::from_utf8(src)?);
        match self.first_pos {
            None => {
                self.first_pos = src[..].iter().position(|b| *b == b'\n');
            }
            Some(first) => {
                if let Some(second) = src[first + 1..].iter().position(|b| *b == b'\n') {
                    // println!("first:{} second:{}", first, second);
                    let raw = src.split_to(first + second + 2);
                    let twoline = std::str::from_utf8(&raw)?.trim();
                    let (line1, line2) = twoline.split_at(first);

                    let msg = TwoLine {
                        line1: line1.trim().to_owned(),
                        line2: line2.trim().to_owned(),
                    };
                    self.reset();
                    return Ok(Some(msg));
                }
            }
        }

        Ok(None)
    }
}