By checking with valgrind, I see that 5 blocks of memory were not freed after terminating my program, but they are still reachable. Do I need to be bothered by it?
And how it happens?
zhanwu@gelata:~/sandbox$ valgrind ./a.out
==2430== Memcheck, a memory error detector
==2430== Copyright (C) 2002-2010, and GNU GPL'd, by Julian Seward et al.
==2430== Using Valgrind-3.6.1 and LibVEX; rerun with -h for copyright info
==2430== Command: ./a.out
==2430==
Hello world!
Thread1 returns 1
Thread2 returns 10
Thread3 returns 10
==2430==
==2430== HEAP SUMMARY:
==2430== in use at exit: 1,590 bytes in 5 blocks
==2430== total heap usage: 14 allocs, 9 frees, 2,442 bytes allocated
==2430==
==2430== LEAK SUMMARY:
==2430== definitely lost: 0 bytes in 0 blocks
==2430== indirectly lost: 0 bytes in 0 blocks
==2430== possibly lost: 0 bytes in 0 blocks
==2430== still reachable: 1,590 bytes in 5 blocks
==2430== suppressed: 0 bytes in 0 blocks
==2430== Rerun with --leak-check=full to see details of leaked memory
==2430==
==2430== For counts of detected and suppressed errors, rerun with: -v
==2430== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 4 from 4)
Below is my code, what can I do to free those 5 blocks if I intend to?
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
void* myfunction(void *ptr)
{
static int n_call = 0;
int *retval = malloc(sizeof(int));
pthread_mutex_lock( &mutex1 );
n_call++;
*retval = n_call;
pthread_mutex_unlock( &mutex1 );
if(n_call < 2)
{
char *msg;
msg = (char *)ptr;
printf("%s\n", msg);
return retval;
}
else
{
*retval = 10;
pthread_exit(retval);
}
}
int main(int argc, char *argv[])
{
pthread_t t1, t2, t3;
char *msg = "Hello world!";
pthread_create(&t1, NULL, myfunction, (void *)msg);
pthread_create(&t2, NULL, myfunction, (void *)msg);
pthread_create(&t3, NULL, myfunction, (void *)msg);
int **s1 = malloc(sizeof(int*));
int **s2 = malloc(sizeof(int*));
int **s3 = malloc(sizeof(int*));
pthread_join(t1, (void **)s1);
pthread_join(t2, (void **)s2);
pthread_join(t3, (void **)s3);
printf("Thread1 returns %d\n", **s1);
printf("Thread2 returns %d\n", **s2);
printf("Thread3 returns %d\n", **s3);
free(*s1);
free(*s2);
free(*s3);
free(s1);
free(s2);
free(s3);
return 0;
}
