On 25May2017 11:52, Michael C <mysecretrobotfact...@gmail.com> wrote:
Right now all i need is to grab 3 values from 3 variables before killing a
thread, like this:
def stuff():
do stuff,
get values, (x,y,d)
# main code
startthread(stuff(), blah)
# if else need to sleep or kill the thread, and because I'll restart the
thread later, I'd like to get the values from the thread, say x,y,d in
order to restart the thread.
loop.
Therefore, how do I get a few values from a few variables from the thread
and then close it?
Threading is very new to me, so I have to be very diligent.
You always need to be diligent with threads :-)
Can you explain why you need to use a thread for this? The first cut of your
program looks like you could do it with a ordinary function:
def stuff():
... compute x, y, z ...
return x, y, z
def main():
x, y, z = stuff()
OTOH, your later description suggests that you want to kick off a thread to
work on something, and have your main program let it run, or pause it. The
implication is that x, y, z represent the thread state allowing you to restart
it from scratch at the same point where you paused/stopped things.
There are a few different ways to manage that scenario. But first, write
yourself a small Thread based program to familiarise yourself with threads. For
example (untested):
from __future__ import print_function
from time import sleep
from threading import Thread
def thread_main_body():
print("thread started")
for n in range(20):
print("thread", n)
sleep(0.3)
print("thread done")
def main():
print("main")
T = Thread(target=thread_main_body)
print("main: Thread created but _not_ started")
sleep(1)
T.start()
print("thread started")
for n in range(10):
print("main", n)
sleep(0.4)
print("main program waiting for thread")
T.join()
print("main program done")
You should see the main thread and your subthread outputs interleaved. The
sleeps are just to ensure some interleaving and to give good interactive feel.
It should run for about 8 seconds overall. Make sure you're happy you
understand what is happening, why, and when.
There are a few things you need to keep in mind with threads (in Python, and to
a degree in other languages):
1: You can't kill/stop a Thread. Instead, the usual approach to to share some
state with some kind of "running" flag, a boolean saying that the Thread's
function should continue. Then the thread polls that regularly. Eg, if the
thread function runs a main loop it might look like this:
def fn():
global run_me
while run_me:
... do some work ...
and then elsewhere you go:
global run_me
run_me = True
... create and start the Thread ...
... later ...
run_me = False
T.join()
so effectively you ask the Thread to stop, and it obeys when it notices the
change to "run_me". Using a global for this is pretty crube, and not the
general approach, BTW.
2: Like any other function, the local varaibles to the thread function are not
available outside. Thus the "global" hack above. So to share state you would
usually make some kind of object with the state, and pass it in to the Thread
when you create and start it:
def fn(state):
while state.run_me:
... do stuff, keep important things like results in "state" ...
state.x = 1
state.y = whatever
class State(object):
pass
def main():
state = State()
state.run_me = True
T = Thread(target=fn, args=(state,))
T.start()
for n in range(10):
print("main", n, "x =", state.x, "y =", state.y)
sleep(0.3)
state.run_me = False
T.join()
As I remarked, there are a few ways to approach your scenario. The above should
get you started on one approach. Pausing can be done in a few ways, either by
starting and stopping individual threads, one after another, or by starting one
thread and using a mutex of some kind to cause it to suspend activity when
needed. Yet another approach is corroutines, but I'd recommend getting
threading understood first to avoid confusion.
Come back woith some functioning code and more questions.
Cheers,
Cameron Simpson <c...@zip.com.au>
_______________________________________________
Tutor maillist - Tutor@python.org
To unsubscribe or change subscription options:
https://mail.python.org/mailman/listinfo/tutor
