使用生产者-消费者范式跟踪字节切碎机程序中的 memory 泄漏

Question

我制作了一个程序，该程序应该将输入文件的内容和“切碎”，或以多线程的随机性写入一个 output 文件。

例如，如果 file1.txt 有 123456，而 file2.txt 有 abcdefg，则这些字节将被压缩成一个 output 文件，该文件可能有 1ab23c4d5e6fg。

我使用getopt来提供阅读所需的文件

/* iterate through input files and populate thread data */
    for (int index = optind; index < argc; index++) {
        threads[length].rb = rb;
        threads[length].file_name = argv[index];
        ++length;
    }
    if (!length) {
        usage();
        exit(1);
    }

    /* if -o flag is provided in cmd line */
    if (oflg) {
        pthread_t pt_ids[length], ct_id;
        struct thread_data output_thread;
        output_thread.rb = rb;
        output_thread.file_name = outputFile;

        /* creates threads by passing struct as params */
        for (int i = 0; i < length; i++) {
            pthread_create(&pt_ids[i], NULL, producer, (void*)&threads[i]);
        }

        /* creates thread for output file */
        pthread_create(&ct_id, NULL, consumer, (void*)&output_thread);

        /* waits for the other threads to terminate */
        pthread_join(ct_id, NULL);

        for (int i = 0; i < length; i++) {
            pthread_join(pt_ids[i], NULL);
        }
    }
    rb_finalize(rb);

作为参考，这是用于在pthread_create中传递多个参数的结构：

struct thread_data {
    struct ringbuf_t *rb;
    const char *file_name;
};

这是我的producer和consumer功能。 rb_insert和rb_remove都考虑了避免潜在竞争条件（在多个生产者和消费者之间）的情况。 所以我需要做的就是读入缓冲区并写入 output 文件，就像这样。

void *producer(void *arg) {

    /* breaking apart thread data into variables for use */
    struct thread_data *data = (struct thread_data *)arg;
    struct ringbuf_t *rb = (struct ringbuf_t *)data->rb;
    char *file_name = (char *)data->file_name;

    FILE *fp;
    int c;

    fp = fopen(file_name, "r");

    /* read each char from input file and insert into ring buffer */
    c = fgetc(fp);
    do {
        rb_insert(rb, c);
        printf("inserted %c into buffer\n", c);
        c = fgetc(fp);
    } while (c != EOF);
    rb_insert(rb, -1);

    fclose(fp);
    return 0;
}

void *consumer(void *arg) {

    /* breaking apart output thread data into variables for use */
    struct thread_data *data = (struct thread_data *)arg;
    struct ringbuf_t *rb = (struct ringbuf_t *)data->rb;
    char *output = (char *)data->file_name;

    FILE *fp;
    int c;

    fp = fopen(output, "w");

    /* collect last char of ring buffer and write to output file */
    c = rb_remove(rb);
    while (c != -1) {
        fputc(c, fp);
        printf("put %c into output file!\n", c);
        c = rb_remove(rb);
    }

    fclose(fp);
    return 0;
}

当我使用 valgrind 时，有时执行会陷入无限循环，我必须使用ctrl-c来停止它。 这就是它给我的：

==578076== Process terminating with default action of signal 2 (SIGINT)
==578076==    at 0x4E4F66D: __pthread_timedjoin_ex (in /usr/lib64/libpthread-2.28.so)
==578076==    by 0x400F38: main (bytemincer.c:82)
==578076==
==578076== HEAP SUMMARY:
==578076==     in use at exit: 925 bytes in 4 blocks
==578076==   total heap usage: 12 allocs, 8 frees, 28,045 bytes allocated
==578076==
==578076== 5 bytes in 1 blocks are still reachable in loss record 1 of 4
==578076==    at 0x4C360A5: malloc (vg_replace_malloc.c:380)
==578076==    by 0x4011A1: rb_init (ringbuf.c:23)
==578076==    by 0x400C57: main (bytemincer.c:32)
==578076==
==578076== 160 bytes in 1 blocks are still reachable in loss record 2 of 4
==578076==    at 0x4C360A5: malloc (vg_replace_malloc.c:380)
==578076==    by 0x40117F: rb_init (ringbuf.c:20)
==578076==    by 0x400C57: main (bytemincer.c:32)
==578076==
==578076== 272 bytes in 1 blocks are possibly lost in loss record 3 of 4
==578076==    at 0x4C3ADBB: calloc (vg_replace_malloc.c:1117)
==578076==    by 0x40129EB: _dl_allocate_tls (in /usr/lib64/ld-2.28.so)
==578076==    by 0x4E4EDD2: pthread_create@@GLIBC_2.2.5 (in /usr/lib64/libpthread-2.28.so)
==578076==    by 0x400ED1: main (bytemincer.c:72)
==578076==
==578076== 488 bytes in 1 blocks are still reachable in loss record 4 of 4
==578076==    at 0x4C360A5: malloc (vg_replace_malloc.c:380)
==578076==    by 0x50D700E: __fopen_internal (in /usr/lib64/libc-2.28.so)
==578076==    by 0x400FCF: producer (bytemincer.c:104)
==578076==    by 0x4E4E179: start_thread (in /usr/lib64/libpthread-2.28.so)
==578076==    by 0x5162DC2: clone (in /usr/lib64/libc-2.28.so)

在这种情况下，我怎么会丢失 memory？ 我没有释放一些东西吗？