Why is a thread executing twice sometimes, even if pthread_create is only called once?

Question

I am trying to execute a function in a separate thread and I have noticed that sometimes the thread is executing twice.

If i also call pthread_join, the the code is executing only once every time I run the program.

I do not understand why this is happening.

I am attaching the code:

#include <stdio.h>
#include <pthread.h>
int func(){
  printf("Printing from a thread\n");
  return 0;
}
int main(void) {
  pthread_t ptid;
  pthread_create(&ptid,NULL,&func,NULL);
  //pthread_join(ptid,NULL);
  printf("Hello World\n");
  return 0;
}

EDIT: I have modified the code so the function has the correct header. I have attached the new code. The issue is still present.

#include <stdio.h>
#include <pthread.h>
void* func(void* arg){
  printf("Printing from a thread\n");
  return 0;
}
int main(void) {
  pthread_t ptid;
  pthread_create(&ptid,NULL,&func,NULL);
  //pthread_join(ptid,NULL);
  printf("Hello World\n");
  return 0;
}

Answer 1

I have noticed that sometimes the thread is executing twice.

You've observed a symptom and misattributed it to a particular ("runs twice") explanation. That explanation is incorrect.

I do not understand why this is happening.

It appears to be a bug in GLIBC. In particular, when one thread keeps calling printf, while another is calling exit, the output may appear twice, as the following program shows:

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

void *func(void *p)
{
  size_t count = 0;
  while (1)
    printf("%zu\n", ++count);

  return NULL;
}

int main(void)
{
  pthread_t ptid;
  pthread_create(&ptid, NULL, func, NULL);
  usleep(1000);
  return 0;
}

This program should never print the same number twice, and yet running it produces:

1
2
3
...
290
291
292
293
294
294  <<<-- bug
295
296
296  <<<-- bug
297

The bug is "deliberate":

git show 64f01020838
commit 64f01020838a382d833254297f650d4a55933bde
Author: Ulrich Drepper <drepper@redhat.com>
Date:   Mon Feb 9 20:08:44 2004 +0000

    (_IO_cleanup): Do not use locking when flushing the buffers.  Some thread might be using a stream.

diff --git a/libio/genops.c b/libio/genops.c
index 58dac005d8..5b65e76bea 100644
--- a/libio/genops.c
+++ b/libio/genops.c
@@ -942,7 +942,9 @@ _IO_unbuffer_write ()
 int
 _IO_cleanup ()
 {
-  int result = INTUSE(_IO_flush_all) ();
+  /* We do *not* want locking.  Some threads might use streams but
+     that is there problem, we flush them underneath them.  */
+  int result = _IO_flush_all_lockp (0);

   /* We currently don't have a reliable mechanism for making sure that
      C++ static destructors are executed in the correct order.

That is, drepper@redhat.com believed that exit should just flush the stream regardless of what other threads may be doing and without locking. I have no idea what motivated that patch.

Answer 2

The first mistake is that in the main function, when you use pthread_create, you are passing in a function with an int return value for the third argument when the return value should be a void pointer as stated on the man page for pthread_create. You should compile with warnings enabled to avoid this mistake in the future. Secondly, by commenting out pthread_join. You are telling the program that it does not need to wait for you thread to return a value or finish through pthread_exit. Therefore, your func function might not run for the duration of the program. Lastly, pthread_join causing the code to execute once is the correct action of the function as stated on the man page for the function. Here is sample code that further elaborates on what I mean:

#include <stdio.h>
#include <pthread.h>
void *code() // Declares the function correctly as a void pointer
{
    printf("Executing thread code\n");
    pthread_exit(NULL); // Correctly exits the code using pthread_exit
}
int main()
{
    pthread_t ptid;
    pthread_create(&ptid, NULL, &code, NULL); // Creates the thread and runs the code inside of it
    pthread_join(ptid, NULL);                 // Tells the program to wait for the thread to finish (if it has not already)
    printf("This will always print second.");
    return 0;
}