Threading Problem

[Norbert]

Hello *,
i am experimenting with threads and get puzzling results.
Consider the following example:
#--------------------
import threading, time

def threadfunction():
.....print "threadfunction: entered"
.....x = 10
.....while x < 40:
.........time.sleep(1) # time unit is seconds
.........print "threadfunction x=%d" % x
.........x += 10



print "start"
th = threading.Thread(target = threadfunction())
th.start()
print "start completed"
#--------------------
(the dots are inserted becaus Google mangles the lines otherwise)

This program gives the following result :
----
start
threadfunction: entered
threadfunction x=10
threadfunction x=20
threadfunction x=30
start completed
----
My aim was that the main program should continue to run while
threadfunction runs in parallel. That's the point of threads after all,
isn't it ?

I awaited something like the following :
start
threadfunction: entered
start completed <-------------------
threadfunction x=10
threadfunction x=20
threadfunction x=30

Does anyone know what's going on here ?

Thanks for listening !

Norbert

 

[Steve Holden]

Hello *,
i am experimenting with threads and get puzzling results.
Consider the following example:
#--------------------
import threading, time

def threadfunction():
.....print "threadfunction: entered"
.....x = 10
.....while x < 40:
.........time.sleep(1) # time unit is seconds
.........print "threadfunction x=%d" % x
.........x += 10



print "start"
th = threading.Thread(target = threadfunction())
th.start()
print "start completed"
#--------------------
(the dots are inserted becaus Google mangles the lines otherwise)

This program gives the following result :
----
start
threadfunction: entered
threadfunction x=10
threadfunction x=20
threadfunction x=30
start completed
----
My aim was that the main program should continue to run while
threadfunction runs in parallel. That's the point of threads after all,
isn't it ?

I awaited something like the following :
start
threadfunction: entered
start completed <-------------------
threadfunction x=10
threadfunction x=20
threadfunction x=30

Does anyone know what's going on here ?

Well, I don't believe there's any guarantee that a thread will get run
preference over its starter - they're both threads, after all. Try
putting a sleep after th.start() and before the print statement and you
should see that the "worker" thread runs while the main thread sleeps.

The same would be true if each were making OS calls and so on. When
everything is more or les continuous computation, and so short it can be
over in microseconds, there's no motivation for the scheduler to stop
one thread and start another.

regards
Steve

 

[Alan Kennedy]

[Norbert]

> i am experimenting with threads and get puzzling results.
> Consider the following example:
> #--------------------
> import threading, time
>
> def threadfunction():
> ....print "threadfunction: entered"
> ....x = 10
> ....while x < 40:
> ........time.sleep(1) # time unit is seconds
> ........print "threadfunction x=%d" % x
> ........x += 10
>
>
>
> print "start"
> th = threading.Thread(target = threadfunction())

The problem is here ^^

You are *invoking* threadfunction, and passing its return value as the
target, rather than passing the function itself as the target. That's
why threadfunction's output appears in the output stream before the
thread has even started.

Try this instead

#-----------------------------------------------

import threading, time

def threadfunction():
print "threadfunction: entered"
x = 10
while x < 40:
time.sleep(1) # time unit is seconds
print "threadfunction x=%d" % x
x += 10

print "start"
th = threading.Thread(target = threadfunction)
th.start()
print "start completed"

#------------------------------------------------

Which should output the expected

>

start
threadfunction: entered
start completed
threadfunction x=10
threadfunction x=20
threadfunction x=30

regards,

 

[Norbert]

Thanks a lot, Steve, for your fast reply.
But the behaviour is the same if 'threadfunction' sleeps longer than
just 1 second. 'threadfunction' is of course a dummy to show the
problem, imagine a longrunning background-task.

If you are right, the question remains 'How can I assure that the
starting function finishes, while the other thread still runs ?' . As
I said, this is the purpose of threading.

Thanks again
Norbert

 

[Norbert]

Thanks Alan,
i hoped it would be something trivial

Norbert

 

[Fredrik Lundh]

Well, I don't believe there's any guarantee that a thread will get run preference over its
starter - they're both threads, after all. Try putting a sleep after th.start() and before the
print statement and you should see that the "worker" thread runs while the main thread sleeps.

that's correct, but the "threading" module does a 0.000001-second sleep
to get around this, no matter what thread scheduler you're using.

if you're building threads on top of the lower-level "thread" api, you have
to do that yourself.

</F>

 

[Ishwor]

[Norbert]

i am experimenting with threads and get puzzling results.
Consider the following example:
#--------------------
import threading, time

def threadfunction():
....print "threadfunction: entered"
....x = 10
....while x < 40:
........time.sleep(1) # time unit is seconds
........print "threadfunction x=%d" % x
........x += 10



print "start"
th = threading.Thread(target = threadfunction())

The problem is here ^^

You are *invoking* threadfunction, and passing its return value as the
target, rather than passing the function itself as the target. That's
why threadfunction's output appears in the output stream before the
thread has even started.

Try this instead

#-----------------------------------------------

import threading, time

def threadfunction():
print "threadfunction: entered"
x = 10
while x < 40:
time.sleep(1) # time unit is seconds
print "threadfunction x=%d" % x
x += 10

print "start"
th = threading.Thread(target = threadfunction)
th.start()
print "start completed"

#------------------------------------------------

Which should output the expected
start
threadfunction: entered
start completed
threadfunction x=10
threadfunction x=20
threadfunction x=30

regards,

nice chum liked the way you explained. Clear and easy to
understand.. why doesn't the keyboardInterrupt seem to work? I am
working in IDLE and it doesn't seem to stop the thread ???!!??
output of above code in IDLE shell:----

threadfunction x=75

KeyboardInterruptthreadfunction x=80

 

[Ishwor]

[Norbert]

i am experimenting with threads and get puzzling results.
Consider the following example:
#--------------------
import threading, time

def threadfunction():
....print "threadfunction: entered"
....x = 10
....while x < 40:
........time.sleep(1) # time unit is seconds
........print "threadfunction x=%d" % x
........x += 10



print "start"
th = threading.Thread(target = threadfunction())

The problem is here ^^

You are *invoking* threadfunction, and passing its return value as the
target, rather than passing the function itself as the target. That's
why threadfunction's output appears in the output stream before the
thread has even started.

Try this instead

#-----------------------------------------------

import threading, time

def threadfunction():
print "threadfunction: entered"
x = 10
while x < 40:
time.sleep(1) # time unit is seconds
print "threadfunction x=%d" % x
x += 10

print "start"
th = threading.Thread(target = threadfunction)
th.start()
print "start completed"

#------------------------------------------------

Which should output the expected
start
threadfunction: entered
start completed
threadfunction x=10
threadfunction x=20
threadfunction x=30

regards,

nice chum liked the way you explained. Clear and easy to
understand.. why doesn't the keyboardInterrupt seem to work? I am
working in IDLE and it doesn't seem to stop the thread ???!!??
output of above code in IDLE shell:----

threadfunction x=75

KeyboardInterruptthreadfunction x=80