Очистка BufferedWriter на основе тайм-аута

Как насчет чего-то подобного? Это не настоящий BufferedWriter, а Writer. Он работает, периодически проверяя последний модуль записи на базовом, надеюсь, небуферизованном модуле записи, а затем сбрасывая BufferedWriter, если время ожидания превышает время ожидания.

public class PeriodicFlushingBufferedWriter extends Writer {

  protected final MonitoredWriter monitoredWriter;
  protected final BufferedWriter writer;

  protected final long timeout;
  protected final Thread thread;

  public PeriodicFlushingBufferedWriter(Writer out, long timeout) {
    this(out, 8192, timeout);
  }

  public PeriodicFlushingBufferedWriter(Writer out, int sz, final long timeout) {
    monitoredWriter = new MonitoredWriter(out);
    writer = new BufferedWriter(monitoredWriter, sz);

    this.timeout = timeout;

    thread = new Thread(new Runnable() {
      @Override
      public void run() {
        long deadline = System.currentTimeMillis() + timeout;
        while (!Thread.interrupted()) {
          try {
            Thread.sleep(Math.max(deadline - System.currentTimeMillis(), 0));
          } catch (InterruptedException e) {
            return;
          }

          synchronized (PeriodicFlushingBufferedWriter.this) {
            if (Thread.interrupted()) {
              return;
            }

            long lastWrite = monitoredWriter.getLastWrite();

            if (System.currentTimeMillis() - lastWrite >= timeout) {
              try {
                writer.flush();
              } catch (IOException e) {
              }
            }

            deadline = lastWrite + timeout;
          }
        }
      }
    });

    thread.start();
  }

  @Override
  public synchronized void write(char[] cbuf, int off, int len) throws IOException {
    this.writer.write(cbuf, off, len);
  }

  @Override
  public synchronized void flush() throws IOException {
    this.writer.flush();
  }

  @Override
  public synchronized void close() throws IOException {
    try {
      thread.interrupt();
    } finally {
      this.writer.close();
    }
  }

  private static class MonitoredWriter extends FilterWriter {

    protected final AtomicLong lastWrite = new AtomicLong();

    protected MonitoredWriter(Writer out) {
      super(out);
    }

    @Override
    public void write(int c) throws IOException {
      lastWrite.set(System.currentTimeMillis());
      super.write(c);
    }

    @Override
    public void write(char[] cbuf, int off, int len) throws IOException {
      lastWrite.set(System.currentTimeMillis());
      super.write(cbuf, off, len);
    }

    @Override
    public void write(String str, int off, int len) throws IOException {
      lastWrite.set(System.currentTimeMillis());
      super.write(str, off, len);
    }

    @Override
    public void flush() throws IOException {
      lastWrite.set(System.currentTimeMillis());
      super.flush();
    }

    public long getLastWrite() {
      return this.lastWrite.get();
    }
  }
}

@copeg прав - сбрасывать его после каждой строки. Его легко сбросить во времени, но какой смысл иметь только половину записи и не иметь возможности ее продолжить?

Здесь вы можете применить шаблоны Observer, Manager и Factory, а центральный BufferedWriterManager будет создавать ваши BufferedWriters и поддерживать список активных экземпляров. Внутренний поток может периодически просыпаться и очищать активные экземпляры. Это также может быть возможностью для слабых ссылок, поэтому вашим потребителям не требуется явно освобождать объект. Вместо этого всю работу выполнит сборщик мусора, а вашему менеджеру просто нужно обработать случай, когда его внутренняя ссылка станет нулевой (т. е. когда все сильные ссылки будут удалены).

Не пытайтесь использовать эту сложную схему, это слишком сложно. Просто уменьшите размер буфера, указав его при построении BufferedWriter. Уменьшите его, пока не найдете баланс между производительностью и задержкой, который вам нужен.