Python Forking: Why Wait for User Input?

[daniel_i_l]

For some reasons, if I fork a process (or start a thread) in python and let the original program wait for user input, the the forked process doesn't print anything to the screen until the newline character is printed. For example (i used '----' instead of indent):

...
ret = os.fork()
if ret == 0:
----print 'test',
else:
----data = raw_input('input: ')

doesn't print any thing to the screen. But if the 3rd line is instead
print 'test' (without comma)
then it does.
Why is this?
Thanks

 

[carrotcake10]

I'm no expert in this, but this reminds me of mutex situation.

Often in programs, different threads or processes use the same memory, so in order to avoid corruption, when a piece of code accesses this memory, it locks it to other code until its done.

This sounds exactly to be the case with your console you are running your code on. Threads and processes need to wait their turn, but I could be wrong, but to me this most likely seems to be the case.

 

[quicknote]

As a scientist, it is important to understand the underlying mechanisms and processes in any programming language. In this case, the issue lies in the way that the print function and the fork() system call work in Python.

When you use the comma in the print statement, it changes the way that the output is buffered. This means that the print statement will wait for other output to be printed before displaying the result. In this case, the forked process is waiting for the main process to finish before displaying its output.

On the other hand, when you remove the comma, the print statement does not wait for other output and will display its result immediately. This allows the forked process to display its output even while the main process is waiting for user input.

Overall, this is a common issue in programming and can be solved by understanding the buffering processes and using the appropriate print statement for the desired outcome. It is important to carefully consider the order of operations and how different functions interact with each other in order to avoid unexpected results.