读取目录图像时如何避免读取正在复制的不完整图像？

Hey, this is such a common pain point when monitoring directories for media files—half-written images can ruin your processing pipeline. Let's break down practical solutions, from general strategies to C-specific implementations, plus how to verify if an image is actually intact:

The best defense is to stop the problem before it starts, or at least filter out incomplete files early:

• Leverage filesystem atomicity (the gold standard if you control the writer): Have the writing process save the image to a temporary location/filename first (e.g., temp_img.jpg.part), then use an atomic rename to move it into your monitored directory. Most filesystems (ext4, NTFS, etc.) make rename() atomic—so once the file appears in your target dir, it's 100% complete. No more guessing.
• Check file size + modification time: If you can't control the writer, add a delay. When you detect a new file, record its size and last modified timestamp. Wait a short window (1-3 seconds, adjust based on typical file sizes) and check again. If both values match, the file is likely done being written. Note: This isn't foolproof (a writer could pause and resume), but it works for most casual use cases.
• Open the file in exclusive mode: In C, use the open() function with O_RDONLY | O_EXCL flags (on POSIX systems; Windows uses similar exclusive access flags). If the open fails, that means another process has the file locked (probably writing to it), so skip it and try later. Example code:

#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>

int main() {
    const char* img_path = "/path/to/your/image.jpg";
    int fd = open(img_path, O_RDONLY | O_EXCL);
    if (fd == -1) {
        perror("Failed to open file (likely locked)");
        return 1;
    }
    // Safe to read the file here
    close(fd);
    return 0;
}

Even if you're sure the file is fully written, it could be corrupted. Here's how to check:

• Validate file headers and footers: Every image format has unique signatures. For example:
  • JPEG starts with 0xFFD8 and ends with 0xFFD9
  • PNG starts with 89 50 4E 47 0D 0A 1A 0A and ends with the IEND block (49 45 4E 44 AE 42 60 82)
    You can read the first few and last few bytes of the file to check these markers—it's a quick way to catch truncated files.
• Use image libraries to attempt decoding: Libraries like libjpeg or libpng will throw errors if the image is incomplete or corrupted. This is the most reliable way to confirm the image is usable. Here's a quick libjpeg example:

#include <stdio.h>
#include <jpeglib.h>

int is_jpeg_intact(const char* path) {
    struct jpeg_decompress_struct cinfo;
    struct jpeg_error_mgr jerr;
    FILE* infile = fopen(path, "rb");
    if (!infile) return 0;

    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_decompress(&cinfo);
    jpeg_stdio_src(&cinfo, infile);

    // Try reading the header; failure means invalid/corrupted JPEG
    int header_status = jpeg_read_header(&cinfo, TRUE);
    int is_valid = (header_status == JPEG_HEADER_OK);

    jpeg_destroy_decompress(&cinfo);
    fclose(infile);
    return is_valid;
}

• Hash verification (if possible): If the writer can provide a pre-computed hash (MD5, SHA256) for the image, you can calculate the hash of the file you read and compare. This is the most rigorous check, but it requires coordination with the writing side.

For bulletproof results:

1. If you control the writing process, use atomic renames to drop completed files into the monitored directory—this eliminates the "half-written" problem entirely.
2. For files detected in the directory, first try to open in exclusive mode; if that fails, skip and retry later.
3. For files you can open, check the file header/footer as a quick sanity check.
4. Finally, use an image library to attempt decoding—if that succeeds, the image is safe to process.

内容的提问来源于stack exchange，提问作者Hao Zhou