不能使用log4j@umartahir提供的代码。
正如您在 FixedWindowRollingPolicy 类，在实际处理 rollover ，他们首先指示 RollingFileAppender 要同步重命名文件，然后根据需要异步压缩文件，请执行以下操作：

public RolloverDescription rollover(final String currentFileName) {
  if (maxIndex >= 0) {
    int purgeStart = minIndex;
    if (!explicitActiveFile) {
      purgeStart++;
    }
    if (!purge(purgeStart, maxIndex)) {
      return null;
    }
    StringBuffer buf = new StringBuffer();
    formatFileName(new Integer(purgeStart), buf);
    String renameTo = buf.toString();
    String compressedName = renameTo;
    Action compressAction = null;
    if (renameTo.endsWith(".gz")) {
      renameTo = renameTo.substring(0, renameTo.length() - 3);
      compressAction =
        new GZCompressAction(
          new File(renameTo), new File(compressedName), true);
    } else if (renameTo.endsWith(".zip")) {
      renameTo = renameTo.substring(0, renameTo.length() - 4);
      compressAction =
        new ZipCompressAction(
          new File(renameTo), new File(compressedName), true);
    }
    FileRenameAction renameAction =
      new FileRenameAction(
        new File(currentFileName), new File(renameTo), false);
    return new RolloverDescriptionImpl(
      currentFileName, false, renameAction, compressAction);
  }
  return null;
}

他回来了 RolloverDescription 将用于
RollingFileAppender rollover 处理实际滚动过程的方法：

public boolean rollover() {
  //
  //   can't roll without a policy
  //
  if (rollingPolicy != null) {
    Exception exception = null;
    synchronized (this) {
      //
      //   if a previous async task is still running
      //}
      if (lastRolloverAsyncAction != null) {
        //
        //  block until complete
        //
        lastRolloverAsyncAction.close();
        //
        //    or don't block and return to rollover later
        //
        //if (!lastRolloverAsyncAction.isComplete()) return false;
      }
      try {
        RolloverDescription rollover = rollingPolicy.rollover(getFile());
        if (rollover != null) {
          if (rollover.getActiveFileName().equals(getFile())) {
            closeWriter();
            boolean success = true;
            if (rollover.getSynchronous() != null) {
              success = false;
              try {
                success = rollover.getSynchronous().execute();
              } catch (Exception ex) {
                exception = ex;
              }
            }
            if (success) {
              if (rollover.getAppend()) {
                fileLength = new File(rollover.getActiveFileName()).length();
              } else {
                fileLength = 0;
              }
              if (rollover.getAsynchronous() != null) {
                lastRolloverAsyncAction = rollover.getAsynchronous();
                new Thread(lastRolloverAsyncAction).start();
              }
              setFile(
                rollover.getActiveFileName(), rollover.getAppend(),
                bufferedIO, bufferSize);
            } else {
              setFile(
                rollover.getActiveFileName(), true, bufferedIO, bufferSize);
              if (exception == null) {
                LogLog.warn("Failure in post-close rollover action");
              } else {
                LogLog.warn(
                  "Exception in post-close rollover action", exception);
              }
            }
          } else {
            Writer newWriter =
              createWriter(
                  createFileOutputStream(
                      rollover.getActiveFileName(), rollover.getAppend()));
            closeWriter();
            setFile(rollover.getActiveFileName());
            this.qw = createQuietWriter(newWriter);
            boolean success = true;
            if (rollover.getSynchronous() != null) {
              success = false;
              try {
                success = rollover.getSynchronous().execute();
              } catch (Exception ex) {
                exception = ex;
              }
            }
            if (success) {
              if (rollover.getAppend()) {
                fileLength = new File(rollover.getActiveFileName()).length();
              } else {
                fileLength = 0;
              }
              if (rollover.getAsynchronous() != null) {
                lastRolloverAsyncAction = rollover.getAsynchronous();
                new Thread(lastRolloverAsyncAction).start();
              }
            }
            writeHeader();
          }
          return true;
        }
      } catch (Exception ex) {
        exception = ex;
      }
    }
    if (exception != null) {
      LogLog.warn(
        "Exception during rollover, rollover deferred.", exception);
    }
  }
  return false;
}

如果您需要这种特殊的行为，也许您可以创建自己的滚动策略，并尝试实现类似于中所做的事情 FixedWindowRollingPolicy ，并将log4j配置为使用这个新的滚动策略。
也就是说，要知道gzip只意味着压缩数据，没有实际的文件名或文件条目，只是压缩数据。如果你使用 gzip 工具，它采用归档文件的名称来压缩、压缩数据，并将结果存储在一个带有后缀的新文件中，通常是 .gz . 这就是log4j试图在代码中模仿的行为。