Unable to understand pthread_create() behaviour in the following program?

Question

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

void *thread_func(void *arg)
{
        printf("hello, world \n");
        return 0;
}

int main(void)
{
        pthread_t t1, t2;

        pthread_create(&t1, NULL, thread_func, NULL);
        pthread_create(&t2, NULL, thread_func, NULL);

        printf("t1 = %d\n",t1);
        printf("t2 = %d\n",t2);

        return 0;
}

The above program creates two threads, where each thread prints "Hello World".

So, as per my understanding, the "Hello world" should print a maximum 2 times.

However, while executing the same program multiple times(back to back), there are scenarios where "Hello world" is being printed more than 2 times. So I am unclear how it is getting printed an unexpected number of times?

Here are the sample outputs:

[rr@ar ~]$ ./a.out
t1 = 1290651392
t2 = 1282258688
hello, world
hello, world


[rr@ar ~]$ ./a.out
t1 = 1530119936
t2 = 1521727232
hello, world
hello, world
hello, world

As shown above, after executing the program for many times, "hello, world" is printed 3 times. Can anyone please advise how come it got printed 3 times?

The program code shown in the question is not the code of the program that produced the output you show in the question. That makes it impossible for us to answer your question. Get the code and output consistent before asking questions (or giving answers). Also note that the thread functions are supposed to return a void * value — add return 0;. You don't wait for the threads to complete; that may be a factor in the problem, though I reserve judgement on that. — Jonathan Leffler
Thanks Jonathan Leffler , i have corrected my Question. still i am getting the same output as posted earlier. — E V Ravi
Your program is probably terminating before the threads are done,Abnormal termination of program may lead to such behavior, you should call pthread_join for both threads prior to returning from main — Pras
Nope nos, I haven't run a code other than the one i posted. thanks! — E V Ravi
People need to read the specification of POSIX flockfile() and funlockfile(). That page says: All functions that reference (FILE *) objects, except those with names ending in _unlocked, shall behave as if they use flockfile() and funlockfile() internally to obtain ownership of these (FILE *) objects. Thus, if thread 1 is executing printf(), all other threads are locked out from accessing stdout until thread 1's call is effectively complete (it has called funlockfile(stdout)). — Jonathan Leffler

Jean-Baptiste Yunès Jean-Baptiste Yunès · Accepted Answer · 2017-05-31T07:42:12

You experienced a thread-safety problem. I ran your code several times in Linux 16.04 and it produces many different outputs, while the one with 3 hello world message being rare it exists. More frequently there is no output at all which means that main terminates faster than threads being able to finish their outputs. Sometime partial outputs are produced like:

t1=xxxx
t2=yyyy
he

That means that the main is exiting while only one thread was able to push some characters in the stdout buffer. Remember that a normal return from main is equivalent to a call to exit which flushes stdio buffers.

While I am unable to really understand what happens behind the scene when you observe 3 messages, I suspect that there exists a run race that let the main flushing a buffer that is currently being flush by one of the threads. Without examining very carefully the source code of printf it is very hard to say more. A possible (rough) scenario would looks like:

thread1 fills the buffers and enters the flushing but is preempted at the very beginning of it
main exits, so enters the flushing and terminates it and is preempted at the very end of it thus producing hello world
thread1 finishes its flushing producing hello world
thread2 produces hello world
main gets the CPU and terminates the process.

printf is not defined as thread-safe, which means that implementors may realize it as such or not (probably not in most cases). So you need, as with any function that uses some shared resource, some mutex to prevents buffer concurrency and such.

In your case, this should be roughly solved (3 outputs) by joining the threads in the main which will prevent main exiting/flushing before threads termination. But be aware that this will not solve other concurrency problems (two threads accessing the same buffer...).

Unable to understand pthread_create() behaviour in the following program?

3 Answers

NOTE