Apache POI Temporary Files Not Automatically Cleaned Up When Exporting XLSX Files with Many Images, Leading to Disk Exhaustion

[Programmer-yyds]

Environment:

• Java 21
• Apache POI 5.4.0

Description:
When using Apache POI to export an XLSX file containing a large number of images, the program encounters an OOM error.
To mitigate the memory issue, I added the following configuration:

static {
    ZipPackage.setUseTempFilePackageParts(true);
}

This configuration successfully resolved the OOM problem, but introduced a new issue:

• A large number of temporary files are created during the XLSX file generation process
• These temporary files are not automatically deleted after the program finishes
• Frequent exports cause temporary files to accumulate, eventually exhausting container disk space

Expected Result:

• Provide an automatic cleanup mechanism for temporary files, or release the related temporary file resources when the Workbook is closed
• If cleanup cannot be done on close, in multi-threaded scenarios, generate separate temporary file directories for each file to distinguish them and safely clean up

Steps to Reproduce:

1. Create an export logic for an XLSX file containing many images
2. Enable ZipPackage.setUseTempFilePackageParts(true)
3. Repeatedly perform the export operation and observe the temporary file directory (e.g., /tmp)

Impact:

• A large number of temporary files occupy disk space, potentially exhausting container storage

Temporary Workaround & Limitations:

• Manually clean up temporary files, but with the following issues:
  • In a multi-threaded environment, all threads write temporary files to the same directory
  • Cannot distinguish between temporary files from completed exports and those still being generated
  • Deleting files blindly may corrupt files that are still being created

[centic9]

Thanks for the report, can you provide a minimal reproducer or at least sample-file and code-snippet which can be used to reproduce the issue?

[Programmer-yyds]

Apache POI Temporary Files Not Deleted in Multi-Threaded Environment

Steps to Reproduce

Run the following code example:

import org.apache.poi.openxml4j.opc.ZipPackage;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.util.IOUtils;
import org.apache.poi.xssf.usermodel.*;

import java.io.*;
import java.util.concurrent.atomic.AtomicInteger;

public class ExcelImageWriter {

    private final XSSFWorkbook workbook;
    private final XSSFSheet sheet;
    private final AtomicInteger rowIndex = new AtomicInteger(0);
    private final String outputPath;
    private final XSSFDrawing drawing;

    static {
        // Enable temporary file mode
        ZipPackage.setUseTempFilePackageParts(true);
        // Specifies the temporary file directory (default is /tmp on Linux)
        System.setProperty("java.io.tmpdir", "/Users/shanjiacong/Desktop/temp");
    }

    public ExcelImageWriter(String outputPath) {
        this.workbook = new XSSFWorkbook();
        this.sheet = workbook.createSheet("Images");
        this.outputPath = outputPath;
        this.drawing = sheet.createDrawingPatriarch();
        sheet.setColumnWidth(0, 30 * 256);
    }

    public void addImage(byte[] bytes) throws IOException {
        int pictureIndex = workbook.addPicture(bytes, Workbook.PICTURE_TYPE_PNG);
        CreationHelper helper = workbook.getCreationHelper();

        int rowNum = rowIndex.getAndIncrement();
        XSSFClientAnchor anchor = (XSSFClientAnchor) helper.createClientAnchor();
        anchor.setCol1(0);
        anchor.setRow1(rowNum);
        anchor.setCol2(1);
        anchor.setRow2(rowNum + 1);

        drawing.createPicture(anchor, pictureIndex);
        Row row = sheet.getRow(rowNum);
        if (row == null) {
            row = sheet.createRow(rowNum);
        }
        row.setHeightInPoints(100);
    }

    public void save() throws IOException {
        try (FileOutputStream fos = new FileOutputStream(outputPath)) {
            workbook.write(fos);
        }
        workbook.close();
    }

    public static void main(String[] args) throws Exception {
        ExcelImageWriter writer = new ExcelImageWriter("/Users/shanjiacong/Desktop/temp/output.xlsx");
        byte [] bytes;
        try {
            // Read local image as byte[]
            bytes = readImageBytes("/Users/shanjiacong/Downloads/wps-excel-embed-image-main/test02.jpg");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        // Simulate adding multiple images
        for (int i = 0; i < 5; i++) {
            writer.addImage(bytes);
        }

        writer.save();
        System.out.println("writeCompleted！");
    }

    private static byte[] readImageBytes(String path) throws IOException {
        try (InputStream is = new FileInputStream(path)) {
            return IOUtils.toByteArray(is);
        }
    }
}

1. Prepare an image file (e.g., test02.jpg) and update the path in the code.
2. Run the program.
3. Observe the temporary file directory (e.g., /tmp or the custom path set by java.io.tmpdir).
4. Repeat execution several times — the number of temporary files will keep growing and are not deleted after the process ends.

Impact

• A large number of temporary files occupy disk space, potentially exhausting container storage.
• With repeated runs, temporary files keep accumulating, increasing disk usage over time.

Temporary Workaround & Limitations

• Manually clean up temporary files, but with the following issues:
  • In a multi-threaded environment, all threads write temporary files to the same directory.
  • Cannot distinguish between files from completed exports and those still being generated.
  • Deleting files blindly may corrupt files still in creation.

Expected Behavior

• Temporary files should be automatically deleted after the program ends.
• Multi-threaded runs should not interfere with each other's temporary files.

Actual Behavior

• Temporary files remain in the directory even after the program finishes.
• Repeated executions cause the temporary file count to grow continuously.

Screenshots

The program will create POI files in the temporary directory as shown below:

Temporary files generated by running the program for the first time:

Temporary files generated by running the program for the second time:

Observation: Temporary files are not deleted after the whole program stops.

[pjfanning]

The temp file deletes happen when you call 'close' on the class that manages the file. TempFilePackagePart class closes the temp file in its close. So it looks like XSSFWorkbook close method may not be closing the package parts associated with the workbook.

One observation: can't you write a job that deletes temp files that were created more than 24 hours ago? Or some number of hours that represents a safe number where you know that the creation of the workbook can't take that long. Even 1 hour should be safe enough but a middle ground like 3 or 6 hours might be safer. We hope to fix the temp file delete issue eventually but this might do as a workaround.

[pjfanning]

#880 seems to help in my testing

[pjfanning]

It will be a while before we do a release with the #880 change.
You can workaround this issue in code using:

            XSSFWorkbook workbook = ...
            // need to get the packageParts before closing the workbook
            List<PackagePart> packageParts = workbook.getPackage().getParts();
            workbook.close();
            // workaround for https://github.com/apache/poi/issues/879 (needs to happen after workbook close)
            for (PackagePart part : packageParts) {
                part.close();
            }

[Programmer-yyds]

Ok, thank you very much for your answer!

[centic9]

Seems to be fixed, so closing.