bart_nessux wrote:
I need a script to call several functions at the same time. How does one
call more than one function simultaneously?
i just added my first thread to a wxpython program today. simple. in
fact my first threaded program of any kind.
as indicated, threads might help you. you didn't mention your platform
but probably it has real thread support. nevertheless, this might not
be for you if you are running in a Unix environment with a
multiprocessing (forking) program.
you launch your threads:
import thread
# create a lock you can use to block the threads until you are ready
mymutex = thread.allocate _lock()
def MyConcurrentFun ction():
# important concurrent stuff
pass
def ThreadThing():
# thread will hang on 'acquire' until mutex is released
mymutex.acquire ()
# release lock for the next thread
mymutex.release ()
# now do your stuff
MyConcurrentFun ction()
mymutex.acquire ()
# launch your threads
thread.start_ne w_thread(Thread Thing, ())
thread.start_ne w_thread(Thread Thing, ())
thread.start_ne w_thread(Thread Thing, ())...
# your threads are all hung on the 'acquire' statement
# release the lock, unblocking the threads
mymutex.release ()
# now all your threads are grabbing and releasing the mutex
# all done
I just made that whole thing up. But i think that's more or less how
you launch threads.
you have to consider that the thread may run as soon as you launch it.
each thread could complete your special function before the rest of the
threads get launched.
i think you address that problem by creating a mutex or semaphore that
each thread must acquire before it can proceed. That is, the thread
will block (hang) waiting for the mutex to become available. (think of
a mutex as an abstract lock resource). when all your threads are
launched, the main program can release the mutex(es), unblocking the
threads. The threads will unhang, and do your concurrent thing, more or
less concurrently.
Understand that concurrency is not guaranteed (as i understand it). the
OS controls which thread runs when, and it is not deterministic.
you could use an list of mutexes, to get an iota more concurrency.
all this i learned this very day from Programming Python, pg 104. so
take my advice with a shovel of salt.
but it sounds like the way to go to me.
