from_reader 读文件很慢

use std::fs::File;
use std::io::{self, BufReader, Read};
use std::time::Instant;

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct Post {
  id: u32,
  title: String,
  tags: Vec<String>,
}

// Same shape, but borrows the title from the input buffer.
#[derive(Deserialize)]
struct PostRef<'a> {
  #[allow(dead_code)]
  id: u32,
  title: &'a str,
  #[allow(dead_code)]
  tags: Vec<&'a str>,
}

// Counts how many times read() is called and how many bytes it returns.
struct Counting<R> {
  inner: R,
  calls: usize,
  bytes: usize,
}

impl<R: Read> Read for Counting<R> {
  fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
    self.calls += 1;
    let n = self.inner.read(buf)?;
    self.bytes += n;
    Ok(n)
  }
}

fn counting(path: &str) -> Counting<File> {
  Counting { inner: File::open(path).unwrap(), calls: 0, bytes: 0 }
}

fn main() {
  let path = std::env::args().nth(1).unwrap();
  let posts: Vec<Post> = (0..20_000)
    .map(|id| Post { id, title: format!("post number {id}"), tags: vec!["rust".into(), "serde".into()] })
    .collect();
  std::fs::write(&path, serde_json::to_vec(&posts).unwrap()).unwrap();

  let t = Instant::now();
  let mut r = counting(&path);
  let v: Vec<Post> = serde_json::from_reader(&mut r).unwrap();
  println!("from_reader(File):            {:>4} ms, read calls = {:>7}, bytes = {}, posts = {}", t.elapsed().as_millis(), r.calls, r.bytes, v.len());

  let t = Instant::now();
  let mut r = counting(&path);
  let v: Vec<Post> = serde_json::from_reader(BufReader::new(&mut r)).unwrap();
  println!("from_reader(BufReader<File>): {:>4} ms, read calls = {:>7}, bytes = {}, posts = {}", t.elapsed().as_millis(), r.calls, r.bytes, v.len());

  let t = Instant::now();
  let mut r = counting(&path);
  let mut buf = Vec::new();
  r.read_to_end(&mut buf).unwrap();
  let v: Vec<Post> = serde_json::from_slice(&buf).unwrap();
  println!("read_to_end + from_slice:     {:>4} ms, read calls = {:>7}, bytes = {}, posts = {}", t.elapsed().as_millis(), r.calls, r.bytes, v.len());

  let t = Instant::now();
  let v: Vec<PostRef> = serde_json::from_slice(&buf).unwrap();
  println!("from_slice, borrowed &str:    {:>4} ms, posts = {}, last title = {:?}", t.elapsed().as_millis(), v.len(), v[v.len() - 1].title);
}

from_reader(File):             483 ms, read calls = 1277782, bytes = 1277781, posts = 20000
from_reader(BufReader<File>):    4 ms, read calls =     157, bytes = 1277781, posts = 20000
read_to_end + from_slice:        3 ms, read calls =      18, bytes = 1277781, posts = 20000
from_slice, borrowed &str:       2 ms, posts = 20000, last title = "post number 19999"

    pub fn new(reader: R) -> Self {
        IoRead {
            iter: LineColIterator::new(reader.bytes()),
            ch: None,
            // ...
        }
    }