One way I’ve seen is to pass a mutable object, such as a list or a dictionary, to the thread’s constructor, along with a an index or other identifier of some sort. The thread can then store its results in its dedicated slot in that object. For example: def foo(bar, result, index): print ‘hello {0}’.format(bar) … Read more
Since this question was asked in 2010, there has been real simplification in how to do simple multithreading with Python with map and pool. The code below comes from an article/blog post that you should definitely check out (no affiliation) – Parallelism in one line: A Better Model for Day to Day Threading Tasks. I’ll … Read more
You would call the cancel method after you start the timer: import time import threading def hello(): print “hello, world” time.sleep(2) t = threading.Timer(3.0, hello) t.start() var=”something” if var == ‘something’: t.cancel() You might consider using a while-loop on a Thread, instead of using a Timer. Here is an example appropriated from Nikolaus Gradwohl’s answer … Read more
I’ve continued using this implementation at scale and in production with no issues. Decorator definition: def start_new_thread(function): def decorator(*args, **kwargs): t = Thread(target = function, args=args, kwargs=kwargs) t.daemon = True t.start() return decorator Example usage: @start_new_thread def foo(): #do stuff Over time, the stack has updated and transitioned without fail. Originally Python 2.4.7, Django 1.4, … Read more
If you’re willing to use concurrent.futures.ProcessPoolExecutor instead of multiprocessing, this is actually very simple. Tornado’s ioloop already supports concurrent.futures.Future, so they’ll play nicely together out of the box. concurrent.futures is included in Python 3.2+, and has been backported to Python 2.x. Here’s an example: import time from concurrent.futures import ProcessPoolExecutor from tornado.ioloop import IOLoop from … Read more
It is working fine, its just that its printing too fast for you to see . Try putting a time.sleep() in both functions (a small amount) to sleep the thread for that much amount of time, to actually be able to see both 1 as well as 2. Example – import threading import time sem … Read more
Because someone else will set it. You generally start a thread in one part of your application and continue to do whatever you do: thread = TimerClass() thread.start() # Do your stuff The thread does it’s stuff, while you do your stuff. If you want to terminate the thread you just call: thread.event.set() And the … Read more
In some cases an application may not utilize even one core fully and using threads (or processes) may help to do that. Think of a typical web application. It receives requests from clients, does some queries to the database and returns data back to the client. Given that IO operation is order of magnitude slower … Read more
Simplifying your original version as far as possible: import threading import urllib2 import time start = time.time() urls = [“http://www.google.com”, “http://www.apple.com”, “http://www.microsoft.com”, “http://www.amazon.com”, “http://www.facebook.com”] def fetch_url(url): urlHandler = urllib2.urlopen(url) html = urlHandler.read() print “‘%s\’ fetched in %ss” % (url, (time.time() – start)) threads = [threading.Thread(target=fetch_url, args=(url,)) for url in urls] for thread in threads: thread.start() … Read more
I suggest you instantiate a Queue.Queue before starting the thread, and pass it as one of the thread’s args: before the thread finishes, it .puts the result on the queue it received as an argument. The parent can .get or .get_nowait it at will. Queues are generally the best way to arrange thread synchronization and … Read more