title: Memory not freed but still reachable, is it leaking?
body: <p>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?</p>
  
  <p>And how it happens?</p>
  
  <pre><code>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)
  </code></pre>
  
  <hr>
  
  <p>Below is my code, what can I do to free those 5 blocks if I intend to?</p>
  
  <pre><code>#include &lt;pthread.h&gt;
  #include &lt;stdio.h&gt;
  #include &lt;stdlib.h&gt;
  
  pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
  
  void* myfunction(void *ptr)
  {
      static int n_call = 0;
      int *retval = malloc(sizeof(int));
  
      pthread_mutex_lock( &amp;mutex1 );
      n_call++;
      *retval = n_call;
      pthread_mutex_unlock( &amp;mutex1 );
  
      if(n_call &lt; 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(&amp;t1, NULL, myfunction, (void *)msg);
      pthread_create(&amp;t2, NULL, myfunction, (void *)msg);
      pthread_create(&amp;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;
  }
  </code></pre>