Question

Possible Duplicate:
Asynchronous HTTP calls in Python

I have a Django view which needs to retrieve search results from multiple web services, blend the results together, and render them. I’ve never done any multithreading in Django before. What is a modern, efficient, safe way of doing this?

I don’t know anything about it yet, but gevent seems like a reasonable option. Should I use that? Does it play well with Django? Should I look elsewhere?

Answer 1

Not sure about gevent. The simplest way is to use threads[*]. Here’s a simple example of how to use threads in Python:

# std lib modules. "Batteries included" FTW.
import threading
import time

thread_result = -1

def ThreadWork():
  global thread_result
  thread_result = 1 + 1
  time.sleep(5)  # phew, I'm tiered after all that addition!

my_thread = threading.Thread(target=ThreadWork)
my_thread.start()  # This will call ThreadWork in the background.
                   # In the mean time, you can do other stuff
y = 2 * 5  # Completely independent calculation.
my_thread.join()  # Wait for the thread to finish doing it's thing.
                  # This should take about 5 seconds,
                  # due to time.sleep being called
print "thread_result * y =", thread_result * y

You can start multiple threads, have each make different web service calls, and join on all of those threads. Once all those join calls have returned, the results are in, and you’ll be able to blend them.

more advanced tips: You should call join with a timeout; otherwise, your users might be waiting indefinitely for your app to send them a response. Even better would be for you to make those web service calls before the request arrives at your app; otherwise, the responsiveness of your app is at the mercy of the services that you rely on.

caveat about threading in general: Be careful with data that can be accessed by two (or more) different threads. Access to the same data needs to be “synchronized”. The most popular synchronization device is a lock, but there is a plethora of others. threading.Lock implements a lock. If you’re not careful about synchronization, you’re likely to write a “race condition” into your app. Such bugs are notoriously difficult to debug, because they cannot be reliably reproduced.

In my simple example, thread_result was shared between my_thread and the main thread. I didn’t need any locks, because the main thread did not access thread_result until my_thread terminated. If I hadn’t called my_thread.join, the result would some times be -10 instead of 20. Go ahead and try it yourself.

[*] Python doesn’t have true threading in the sense that concurrent threads do not execute simulatneously, even if you have idle cores. However, you still get concurrent execution; when one thread is blocked, other threads can execute.