How do I use threading in Python?

Question

I would like a clear example showing tasks being divided across multiple threads.

Salinasalinas

A good general discussion around this topic can be found in Python's Hardest Problem by Jeff Knupp. In summary, it seems threading is not for beginners. – Adrianadriana

Remember to write your core logic in C and call it via ctypes to really take advantage of Python threading. – Sascha

I just wanted to add that PyPubSub is a great way to send and receive messages to control Thread flow – Shortening

If you really need threading for performance reasons (e.g. for numerical calculations) please just write the botleneck code on C++ and make it a pymodule with pybind11. I don't see why people say Python will die because of that. – Boater

Answer 1

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 summarize below - it ends up being just a few lines of code:

from multiprocessing.dummy import Pool as ThreadPool
pool = ThreadPool(4)
results = pool.map(my_function, my_array)

Which is the multithreaded version of:

results = []
for item in my_array:
    results.append(my_function(item))

---

Description

Map is a cool little function, and the key to easily injecting parallelism into your Python code. For those unfamiliar, map is something lifted from functional languages like Lisp. It is a function which maps another function over a sequence.

Map handles the iteration over the sequence for us, applies the function, and stores all of the results in a handy list at the end.

---

Implementation

Parallel versions of the map function are provided by two libraries:multiprocessing, and also its little known, but equally fantastic step child:multiprocessing.dummy.

multiprocessing.dummy is exactly the same as multiprocessing module, but uses threads instead (an important distinction - use multiple processes for CPU-intensive tasks; threads for (and during) I/O):

multiprocessing.dummy replicates the API of multiprocessing, but is no more than a wrapper around the threading module.

import urllib2
from multiprocessing.dummy import Pool as ThreadPool

urls = [
  'http://www.python.org',
  'http://www.python.org/about/',
  'http://www.onlamp.com/pub/a/python/2003/04/17/metaclasses.html',
  'http://www.python.org/doc/',
  'http://www.python.org/download/',
  'http://www.python.org/getit/',
  'http://www.python.org/community/',
  'https://wiki.python.org/moin/',
]

# Make the Pool of workers
pool = ThreadPool(4)

# Open the URLs in their own threads
# and return the results
results = pool.map(urllib2.urlopen, urls)

# Close the pool and wait for the work to finish
pool.close()
pool.join()

And the timing results:

Single thread:   14.4 seconds
       4 Pool:   3.1 seconds
       8 Pool:   1.4 seconds
      13 Pool:   1.3 seconds

---

Passing multiple arguments (works like this only in Python 3.3 and later):

To pass multiple arrays:

results = pool.starmap(function, zip(list_a, list_b))

Or to pass a constant and an array:

results = pool.starmap(function, zip(itertools.repeat(constant), list_a))

If you are using an earlier version of Python, you can pass multiple arguments via this workaround).

(Thanks to user136036 for the helpful comment.)

Greig

This is only lacking votes because it is so freshly posted. This answer works beautifully and demonstrates the 'map' functionality which gives a much easier to understand syntax than the other answers here. – Silda

In case you want to pass multiple arguments read this: #5443410 – Macrobiotic

Or the earlier reply directly above yours (@user136036) that says the same thing: https://mcmap.net/q/46149/-how-to-use-multiprocessing-pool-map-with-multiple-arguments – Gerthagerti

Is this really using multiple cores at the same time? These docs.python.org/dev/library/multiprocessing.html and chriskiehl.com/article/parallelism-in-one-line seem to suggest multiprocessing.dummy doesn't actually use multiple cores at once, but interleaves using different cores. At least that's what it seems like to me at this point. – Destruction

Is this even threads and not processes? It seems like it attempts to multiprocess != multithread – Rhea

By the way, guys, you can write with Pool(8) as p: p.map( *whatever* ) and get rid of bookkeeping lines too. – Poncho

@BarafuAlbino: Useful as that is, it's probably worth noting that this only works in Python 3.3+. – Ornas

Actually the downside of this method is that is not working inside a class based function – Hamamelidaceous

Don't forget to close then terminate pool, otherwise threads may be kept alive pool.map(any_function, iterable) pool.close() pool.terminate(). – Commissar

Will the order of urls be preserved in results, or will results be ordered by the threads that returned first? – Scornful

How can you leave this answer and not mention that this is only useful for I/O operations? This only runs on a single thread which is useless for most cases, and is actually slower than just doing it the normal way – Neolith

@Neolith - not only for I/O. urls = [ numpy.random.random((5000000, 1)), numpy.random.random((5000000, 1)), numpy.random.random((5000000, 1)), numpy.random.random((5000000, 1)) ]; result = pool.map(sum, urls) (needs to be wrapped in def_main), and remove .dummy – Greig

Doesnt work unless i run it outside of __main__. Maybe it can work inside a function, did not test – Stew

what if function raises an exception, how manage a non-blocking behavior? – Ib

@M.Ionut you can run pool = ThreadPool() without any input parameter – Greig

@aberger, the order would NOT be preserved because we essentially threw a pool of threads at the interpreter and it is up to the interpreter on how to schedule the threads. – Waldrup

@enneppi, if the function raises an error, the respective thread will terminate and opens up another spot in the pool for another thread to be executed. – Waldrup

Answer 2

Here's a simple example: you need to try a few alternative URLs and return the contents of the first one to respond.

import Queue
import threading
import urllib2

# Called by each thread
def get_url(q, url):
    q.put(urllib2.urlopen(url).read())

theurls = ["http://google.com", "http://yahoo.com"]

q = Queue.Queue()

for u in theurls:
    t = threading.Thread(target=get_url, args = (q,u))
    t.daemon = True
    t.start()

s = q.get()
print s

This is a case where threading is used as a simple optimization: each subthread is waiting for a URL to resolve and respond, to put its contents on the queue; each thread is a daemon (won't keep the process up if the main thread ends -- that's more common than not); the main thread starts all subthreads, does a get on the queue to wait until one of them has done a put, then emits the results and terminates (which takes down any subthreads that might still be running, since they're daemon threads).

Proper use of threads in Python is invariably connected to I/O operations (since CPython doesn't use multiple cores to run CPU-bound tasks anyway, the only reason for threading is not blocking the process while there's a wait for some I/O). Queues are almost invariably the best way to farm out work to threads and/or collect the work's results, by the way, and they're intrinsically threadsafe, so they save you from worrying about locks, conditions, events, semaphores, and other inter-thread coordination/communication concepts.

Parochialism

Thanks again, MartelliBot. I've updated the example to wait for all to urls to respond: import Queue, threading, urllib2 q = Queue.Queue() urls = '''a.com b.com c.com'''.split() urls_received = 0 def get_url(q, url): req = urllib2.Request(url) resp = urllib2.urlopen(req) q.put(resp.read()) global urls_received urls_received +=1 print urls_received for u in urls: t = threading.Thread(target=get_url, args = (q,u)) t.daemon = True t.start() while q.empty() and urls_received < len(urls): s = q.get() print s – Vorster

@JRM: if you look at the next answer below, I think that a better way to wait until the threads are finished would be to use the join() method, since that would make the main thread wait until they're done without consuming processor by constantly checking the value. @Alex: thanks, this is exactly what I needed to understand how to use threads. – Naker

For python3, replace 'import urllib2' with 'import urllib.request as urllib2'. and put parentheses in the print statement. – Causation

Good link here – Frater

For python 3 replace Queue module name with queue. Method name is the same. – Outstare

I note that solution will only print out one of the pages. To print both pages from the queue simply run the command again: s = q.get() print s @Naker You don't need the join because Queue.get() is blocking. – Islaen

@TomAnderson Queue.get() is not blocking by default, you must provide an argument Queue.get([block[, timeout]]). So it should be Queue.get(True) in order to be blocking. Source – Economic

@tofs: Wrong, because block is True by default, so Queue.get() is blocking. Source: the very one you cited ;) – Cerulean

@philshem, to get the first to respond, the modern alternative is actually concurrent.futures.as_completed (stdlib in Py3.2 and better, pypi backport for earlier Python versions). – Parochialism

Jython (yes, a flavour of Python) gives you true multithreading with no GIL! No idea about times, benchmarks, etc. – Haldan

@Vorster , thanks for your code but the " urls_received +=1" is not thread-safe – Damiano

using this example, if say theurls has a size of 100 million URLs, will it still work without any problem ? – Literal

@Alex Martelli can you please clarify to me how many threads will be running in your code example? – Tifanie

Thank you. Why Queue is the best option to use with threads please? – Rhotacism

@Avv, to put it simply, it's because Queue gives structure to interactions among threads and avoids fiddling with low-level issues such as locking. – Parochialism

@AlexMartelli. Thank you very much. How did you conclude that? Is it based on how threads work in C language since Python is built based on C? Can you recommend a book about such styles to structure interactions between threads, please? Finally, so Queue is the best mechanism to structure interactions between threads (goal is for low latency application)? – Rhotacism

@Avv, there is no Queue in the C standard library, and, AFAIK, no book that's fully or mostly about architectures for low-latency threading (whether in Python or in C). The modern fashion seems to be for asyncio and its ecosystem -- understandably, given the performance boost it allows for very I/O-bound systems (the GIL still means that pure-Python programs get no pluses for threading on CPU-bound systems anyway, sigh... only extensions such as numpy, which can drop the GIL and thus allow actual concurrency during long CPU-heavy use, can be of any help there). – Parochialism

Answer 3

NOTE: For actual parallelization in Python, you should use the multiprocessing module to fork multiple processes that execute in parallel (due to the global interpreter lock, Python threads provide interleaving, but they are in fact executed serially, not in parallel, and are only useful when interleaving I/O operations).

However, if you are merely looking for interleaving (or are doing I/O operations that can be parallelized despite the global interpreter lock), then the threading module is the place to start. As a really simple example, let's consider the problem of summing a large range by summing subranges in parallel:

import threading

class SummingThread(threading.Thread):
     def __init__(self,low,high):
         super(SummingThread, self).__init__()
         self.low=low
         self.high=high
         self.total=0

     def run(self):
         for i in range(self.low,self.high):
             self.total+=i


thread1 = SummingThread(0,500000)
thread2 = SummingThread(500000,1000000)
thread1.start() # This actually causes the thread to run
thread2.start()
thread1.join()  # This waits until the thread has completed
thread2.join()
# At this point, both threads have completed
result = thread1.total + thread2.total
print result

Note that the above is a very stupid example, as it does absolutely no I/O and will be executed serially albeit interleaved (with the added overhead of context switching) in CPython due to the global interpreter lock.

Dermatology

@Alex, I didn't say it was practical, but it does demonstrate how to define and spawn threads, which I think is what the OP wants. – Dermatology

While this does show how to define and spawn threads, it actually does not sum the subranges in parallel. thread1 runs until it's completed while the main thread blocks, then the same thing happens with thread2, then the main thread resumes and prints out the values they accumulated. – Solitta

Shouldn't that be super(SummingThread, self).__init__()? As in https://mcmap.net/q/46151/-why-doesn-39-t-super-thread-self-__init__-work-for-a-threading-thread-subclass – Gauntry

@JamesAndres, assuming that no one inherits from "SummingThread", then either one works fine; in such a case super(SummingThread, self) is just a fancy way to look up the next class in the method resolution order (MRO), which is threading.Thread (and then subsequently calling init on that in both cases). You are right, though, in that using super() is better style for current Python. Super was relatively recent at the time that I provided this answer, hence calling directly to the super class rather than using super(). I'll update this to use super, though. – Dermatology

WARNING: Don't use multithreading in tasks like this! As was shown by Dave Beazley: dabeaz.com/python/NewGIL.pdf, 2 python threads on 2 CPUs carry out a CPU-heavy task 2 times SLOWER than 1 thread on 1 CPU and 1.5 times SLOWER than 2 threads on 1 CPU. This bizarre behavior is due to mis-coordination of efforts between OS and Python. A real-life use case for threads is an I/O heavy task. E.g. when you perform read/writes over network, it makes sense to put a thread, waiting for data to be read/written, to background and switch CPU to another thread, which needs to process data. – Emolument

Thanks, everyone, for pointing out the inherent issues with the global interpreter lock. I've updated this post to reflect that. – Dermatology

How about super(self.__class__, self).__init__() instead of super(SummingThread, self).__init__()? It allows the code to be reused in another thread class without the risk of referring to the wrong class. – Bellbottoms

@Bob furthermore, this task is RAM memory bound, throwing more non-NUMA CPUs at it does nothing: RAM IO is the bottleneck. – Buroker

As of 2019, I think it's much more readable to have thread1 = threading.Thread(target=function_name, args=(arg1, arg2, ...)) and the work function defined beforehand. It makes threads one-liner definitions instead of having to create an entire class. – Albarran

Answer 4

Like others mentioned, CPython can use threads only for I/O waits due to GIL.

If you want to benefit from multiple cores for CPU-bound tasks, use multiprocessing:

from multiprocessing import Process

def f(name):
    print 'hello', name

if __name__ == '__main__':
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

Nootka

could you explain a little what this does? – Conformance

@pandita: the code creates a process, then starts it. So now there's two things happening at once: the main line of the program, and the process that's starting with the target, f function. In parallel, the main program now just waits for the process to exit, joining up with it. If the main part just exited, the subprocess might or might not run to completion, so doing a join is always recommended. – Helga

An expanded answer that includes the map function is here: https://mcmap.net/q/45218/-how-do-i-use-threading-in-python – Greig

@Greig Be careful b/c the link you posted is using a pool of threads (not processes) as mentioned here #26432911. However, this answer is using a process. I'm new to this stuff, but seems like (due to GIL) you will only get performance gains in specific situations when using multithreading in Python. However, using a pool of processes can take advantage of a multicore processor by have more than 1 core work on a process. – Destruction

It isn't necessarily so. There are many libraries written in the C language, such as numpy, that release the GIL and could do intensive numerical operations in a thread without blocking other threads from running. – Stieglitz

Answer 5

Just a note: A queue is not required for threading.

This is the simplest example I could imagine that shows 10 processes running concurrently.

import threading
from random import randint
from time import sleep


def print_number(number):

    # Sleeps a random 1 to 10 seconds
    rand_int_var = randint(1, 10)
    sleep(rand_int_var)
    print "Thread " + str(number) + " slept for " + str(rand_int_var) + " seconds"

thread_list = []

for i in range(1, 10):

    # Instantiates the thread
    # (i) does not make a sequence, so (i,)
    t = threading.Thread(target=print_number, args=(i,))
    # Sticks the thread in a list so that it remains accessible
    thread_list.append(t)

# Starts threads
for thread in thread_list:
    thread.start()

# This blocks the calling thread until the thread whose join() method is called is terminated.
# From http://docs.python.org/2/library/threading.html#thread-objects
for thread in thread_list:
    thread.join()

# Demonstrates that the main process waited for threads to complete
print "Done"

Coulter

Add the last quote to "Done to make it print "Done" – Megalocardia

I like this example better than Martelli's, it's easier to play with. However, I would recommend that printNumber do the following, to make it a little bit clearer what's going on: it should save the randint to a variable before sleeping on it, and then the print should be changed to say "Thread" + str(number) + " slept for " + theRandintVariable + " seconds" – Nolita

Is there a way to know when each thread has finished, as it finishes? – Jeanninejeans

@Jeanninejeans There are a few ways to do something like that, but it would depend on your needs. One way would be to update a singleton or some other publicly accessible variable that's being watched in a while loop and updated at the end of the thread. – Coulter

No need for second for loop, you can call thread.start() in first loop. – Gravitt

Thank you. So, for thread in thread_list: thread.join() will also allows the threads to run simultaneously or not please? – Rhotacism

Answer 6

The answer from Alex Martelli helped me. However, here is a modified version that I thought was more useful (at least to me).

Updated: works in both Python 2 and Python 3

try:
    # For Python 3
    import queue
    from urllib.request import urlopen
except:
    # For Python 2 
    import Queue as queue
    from urllib2 import urlopen

import threading

worker_data = ['http://google.com', 'http://yahoo.com', 'http://bing.com']

# Load up a queue with your data. This will handle locking
q = queue.Queue()
for url in worker_data:
    q.put(url)

# Define a worker function
def worker(url_queue):
    queue_full = True
    while queue_full:
        try:
            # Get your data off the queue, and do some work
            url = url_queue.get(False)
            data = urlopen(url).read()
            print(len(data))

        except queue.Empty:
            queue_full = False

# Create as many threads as you want
thread_count = 5
for i in range(thread_count):
    t = threading.Thread(target=worker, args = (q,))
    t.start()

Meathead

Why not just break on the exception? – Flocculent

you could, just personal preference – Meathead

I haven't run the code, but don't you need to daemonize the threads? I think that after that last for-loop, your program might exit - at least it should because that's how threads should work. I think a better approach is not put the worker data in the queue, but put the output into a queue because then you could have a mainloop that not only handles information coming into the queue from the workers, but now it is also not threading, and you know it won't exit prematurely. – Seismism

@dylnmc, that's outside my use case (my input queue is predefined). If you want to go your route, I would suggest looking at celery – Meathead

Answer 7

Given a function, f, thread it like this:

import threading
threading.Thread(target=f).start()

To pass arguments to f

threading.Thread(target=f, args=(a,b,c)).start()

Pieter

This is very straightforward. How do you ensure that the threads close when you are done with them? – Undershot

As far as I understand it, when the function exits the Thread object cleans up. See the docs. There is an is_alive() method you can use to check a thread if you need to. – Pieter

I saw the is_alive method, but I couldn't figure out how to apply it to the thread. I tried assigning thread1=threading.Thread(target=f).start() and then checking it with thread1.is_alive(), but thread1 is populated with None, so no luck there. Do you know if there is any other way to access the thread? – Undershot

You need to assign the thread object to a variable and then start it using that varaible: thread1=threading.Thread(target=f) followed by thread1.start(). Then you can do thread1.is_alive(). – Pieter

That worked. And yes, testing with thread1.is_alive() returns False as soon as the function exits. – Undershot

Answer 8

I found this very useful: create as many threads as cores and let them execute a (large) number of tasks (in this case, calling a shell program):

import Queue
import threading
import multiprocessing
import subprocess

q = Queue.Queue()
for i in range(30): # Put 30 tasks in the queue
    q.put(i)

def worker():
    while True:
        item = q.get()
        # Execute a task: call a shell program and wait until it completes
        subprocess.call("echo " + str(item), shell=True)
        q.task_done()

cpus = multiprocessing.cpu_count() # Detect number of cores
print("Creating %d threads" % cpus)
for i in range(cpus):
     t = threading.Thread(target=worker)
     t.daemon = True
     t.start()

q.join() # Block until all tasks are done

Doable

@shavenwarthog sure one can adjust the "cpus" variable depending on one's needs. Anyway, the subprocess call will spawn subprocesses and these will be allocated cpus by the OS (python's "parent process" does not mean "same CPU" for the subprocesses). – Doable

maybe worth noting that unlike multithreading which uses the same memory space, multiprocessing can not share variables / data as easily. +1 though. – Undernourished

Answer 9

Python 3 has the facility of launching parallel tasks. This makes our work easier.

It has thread pooling and process pooling.

The following gives an insight:

ThreadPoolExecutor Example (source)

import concurrent.futures
import urllib.request

URLS = ['http://www.foxnews.com/',
        'http://www.cnn.com/',
        'http://europe.wsj.com/',
        'http://www.bbc.co.uk/',
        'http://some-made-up-domain.com/']

# Retrieve a single page and report the URL and contents
def load_url(url, timeout):
    with urllib.request.urlopen(url, timeout=timeout) as conn:
        return conn.read()

# We can use a with statement to ensure threads are cleaned up promptly
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
    # Start the load operations and mark each future with its URL
    future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}
    for future in concurrent.futures.as_completed(future_to_url):
        url = future_to_url[future]
        try:
            data = future.result()
        except Exception as exc:
            print('%r generated an exception: %s' % (url, exc))
        else:
            print('%r page is %d bytes' % (url, len(data)))

ProcessPoolExecutor (source)

import concurrent.futures
import math

PRIMES = [
    112272535095293,
    112582705942171,
    112272535095293,
    115280095190773,
    115797848077099,
    1099726899285419]

def is_prime(n):
    if n % 2 == 0:
        return False

    sqrt_n = int(math.floor(math.sqrt(n)))
    for i in range(3, sqrt_n + 1, 2):
        if n % i == 0:
            return False
    return True

def main():
    with concurrent.futures.ProcessPoolExecutor() as executor:
        for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):
            print('%d is prime: %s' % (number, prime))

if __name__ == '__main__':
    main()

Noxious

Answer 10

I saw a lot of examples here where no real work was being performed, and they were mostly CPU-bound. Here is an example of a CPU-bound task that computes all prime numbers between 10 million and 10.05 million. I have used all four methods here:

import math
import timeit
import threading
import multiprocessing
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor


def time_stuff(fn):
    """
    Measure time of execution of a function
    """
    def wrapper(*args, **kwargs):
        t0 = timeit.default_timer()
        fn(*args, **kwargs)
        t1 = timeit.default_timer()
        print("{} seconds".format(t1 - t0))
    return wrapper

def find_primes_in(nmin, nmax):
    """
    Compute a list of prime numbers between the given minimum and maximum arguments
    """
    primes = []

    # Loop from minimum to maximum
    for current in range(nmin, nmax + 1):

        # Take the square root of the current number
        sqrt_n = int(math.sqrt(current))
        found = False

        # Check if the any number from 2 to the square root + 1 divides the current numnber under consideration
        for number in range(2, sqrt_n + 1):

            # If divisible we have found a factor, hence this is not a prime number, lets move to the next one
            if current % number == 0:
                found = True
                break

        # If not divisible, add this number to the list of primes that we have found so far
        if not found:
            primes.append(current)

    # I am merely printing the length of the array containing all the primes, but feel free to do what you want
    print(len(primes))

@time_stuff
def sequential_prime_finder(nmin, nmax):
    """
    Use the main process and main thread to compute everything in this case
    """
    find_primes_in(nmin, nmax)

@time_stuff
def threading_prime_finder(nmin, nmax):
    """
    If the minimum is 1000 and the maximum is 2000 and we have four workers,
    1000 - 1250 to worker 1
    1250 - 1500 to worker 2
    1500 - 1750 to worker 3
    1750 - 2000 to worker 4
    so let’s split the minimum and maximum values according to the number of workers
    """
    nrange = nmax - nmin
    threads = []
    for i in range(8):
        start = int(nmin + i * nrange/8)
        end = int(nmin + (i + 1) * nrange/8)

        # Start the thread with the minimum and maximum split up to compute
        # Parallel computation will not work here due to the GIL since this is a CPU-bound task
        t = threading.Thread(target = find_primes_in, args = (start, end))
        threads.append(t)
        t.start()

    # Don’t forget to wait for the threads to finish
    for t in threads:
        t.join()

@time_stuff
def processing_prime_finder(nmin, nmax):
    """
    Split the minimum, maximum interval similar to the threading method above, but use processes this time
    """
    nrange = nmax - nmin
    processes = []
    for i in range(8):
        start = int(nmin + i * nrange/8)
        end = int(nmin + (i + 1) * nrange/8)
        p = multiprocessing.Process(target = find_primes_in, args = (start, end))
        processes.append(p)
        p.start()

    for p in processes:
        p.join()

@time_stuff
def thread_executor_prime_finder(nmin, nmax):
    """
    Split the min max interval similar to the threading method, but use a thread pool executor this time.
    This method is slightly faster than using pure threading as the pools manage threads more efficiently.
    This method is still slow due to the GIL limitations since we are doing a CPU-bound task.
    """
    nrange = nmax - nmin
    with ThreadPoolExecutor(max_workers = 8) as e:
        for i in range(8):
            start = int(nmin + i * nrange/8)
            end = int(nmin + (i + 1) * nrange/8)
            e.submit(find_primes_in, start, end)

@time_stuff
def process_executor_prime_finder(nmin, nmax):
    """
    Split the min max interval similar to the threading method, but use the process pool executor.
    This is the fastest method recorded so far as it manages process efficiently + overcomes GIL limitations.
    RECOMMENDED METHOD FOR CPU-BOUND TASKS
    """
    nrange = nmax - nmin
    with ProcessPoolExecutor(max_workers = 8) as e:
        for i in range(8):
            start = int(nmin + i * nrange/8)
            end = int(nmin + (i + 1) * nrange/8)
            e.submit(find_primes_in, start, end)

def main():
    nmin = int(1e7)
    nmax = int(1.05e7)
    print("Sequential Prime Finder Starting")
    sequential_prime_finder(nmin, nmax)
    print("Threading Prime Finder Starting")
    threading_prime_finder(nmin, nmax)
    print("Processing Prime Finder Starting")
    processing_prime_finder(nmin, nmax)
    print("Thread Executor Prime Finder Starting")
    thread_executor_prime_finder(nmin, nmax)
    print("Process Executor Finder Starting")
    process_executor_prime_finder(nmin, nmax)
if __name__ == "__main__":
    main()

Here are the results on my Mac OS X four-core machine

Sequential Prime Finder Starting
9.708213827005238 seconds
Threading Prime Finder Starting
9.81836523200036 seconds
Processing Prime Finder Starting
3.2467174359990167 seconds
Thread Executor Prime Finder Starting
10.228896902000997 seconds
Process Executor Finder Starting
2.656402041000547 seconds

Enzymology

@TheUnfunCat no process executor s far better than threading for cpu bound tasks – Enzymology

Great answer dude. I can confirm that in Python 3.6 on Windows (at least) ThreadPoolExecutor does nothing good for CPU-heavy tasks. It's not utilizing cores for computation. Whereas ProcessPoolExecutor copies data into EVERY process it spawns, it's deadly for large matrices. – Twowheeler

Very useful example, but I don't understand how it ever worked. We need a if __name__ == '__main__': before the main call, otherwise the measurement spawns itself and prints An attempt has been made to start a new process before.... – Sholem

@Sholem I believe that is only an issue on Windows, though. – Cot

Answer 11

Using the blazing new concurrent.futures module

def sqr(val):
    import time
    time.sleep(0.1)
    return val * val

def process_result(result):
    print(result)

def process_these_asap(tasks):
    import concurrent.futures

    with concurrent.futures.ProcessPoolExecutor() as executor:
        futures = []
        for task in tasks:
            futures.append(executor.submit(sqr, task))

        for future in concurrent.futures.as_completed(futures):
            process_result(future.result())
        # Or instead of all this just do:
        # results = executor.map(sqr, tasks)
        # list(map(process_result, results))

def main():
    tasks = list(range(10))
    print('Processing {} tasks'.format(len(tasks)))
    process_these_asap(tasks)
    print('Done')
    return 0

if __name__ == '__main__':
    import sys
    sys.exit(main())

The executor approach might seem familiar to all those who have gotten their hands dirty with Java before.

Also on a side note: To keep the universe sane, don't forget to close your pools/executors if you don't use with context (which is so awesome that it does it for you)

Graeco

Answer 12

For me, the perfect example for threading is monitoring asynchronous events. Look at this code.

# thread_test.py
import threading
import time

class Monitor(threading.Thread):
    def __init__(self, mon):
        threading.Thread.__init__(self)
        self.mon = mon

    def run(self):
        while True:
            if self.mon[0] == 2:
                print "Mon = 2"
                self.mon[0] = 3;

You can play with this code by opening an IPython session and doing something like:

>>> from thread_test import Monitor
>>> a = [0]
>>> mon = Monitor(a)
>>> mon.start()
>>> a[0] = 2
Mon = 2
>>>a[0] = 2
Mon = 2

Wait a few minutes

>>> a[0] = 2
Mon = 2

Remittee

AttributeError: 'Monitor' object has no attribute 'stop' ? – Conformance

Aren't you blasting away CPU cycles while waiting for your event to happen? Not always a very practical thing to do. – Kuhns

Like mogul says, this will be constantly executing. At a minimum you could add in a short sleep, say sleep(0.1), which would probably significantly reduce cpu usage on a simple example like this. – Undernourished

This is a horrible example, wasting one core. Add a sleep at the very least but the proper solution is to use some signaling-mechanism. – Hemispheroid

I've read about GIL lately, i wonder how it is possible to input a[0] = 2 while the started thread is running which is a python CPU-bound task. Doesn't GIL prevent you from being able to run any other python code since it is once acquired by the Monitor thread? Or does python constantly switch between threads and GIL just prevents that no threads are executed at the same time but can be executed concurrently (but not parallely)? – Handcraft

I have found some answers to my former comment on the following links which I suggest to people curios about the switchs interpreter does and how GIL works pymotw.com/2/sys/threads.html and web.archive.org/web/20130320214138/http://effbot.org/pyfaq/… – Handcraft

Answer 13

Most documentation and tutorials use Python's Threading and Queue module, and they could seem overwhelming for beginners.

Perhaps consider the concurrent.futures.ThreadPoolExecutor module of Python 3.

Combined with with clause and list comprehension it could be a real charm.

from concurrent.futures import ThreadPoolExecutor, as_completed

def get_url(url):
    # Your actual program here. Using threading.Lock() if necessary
    return ""

# List of URLs to fetch
urls = ["url1", "url2"]

with ThreadPoolExecutor(max_workers = 5) as executor:

    # Create threads
    futures = {executor.submit(get_url, url) for url in urls}

    # as_completed() gives you the threads once finished
    for f in as_completed(futures):
        # Get the results
        rs = f.result()

Karleenkarlen

Answer 14

With borrowing from this post we know about choosing between the multithreading, multiprocessing, and async/asyncio and their usage.

Python 3 has a new built-in library in order to make concurrency and parallelism — concurrent.futures

So I'll demonstrate through an experiment to run four tasks (i.e. .sleep() method) by Threading-Pool:

from concurrent.futures import ThreadPoolExecutor, as_completed
from time import sleep, time

def concurrent(max_worker):
    futures = []
    tic = time()
    with ThreadPoolExecutor(max_workers=max_worker) as executor:
        futures.append(executor.submit(sleep, 2))  # Two seconds sleep
        futures.append(executor.submit(sleep, 1))
        futures.append(executor.submit(sleep, 7))
        futures.append(executor.submit(sleep, 3))
        for future in as_completed(futures):
            if future.result() is not None:
                print(future.result())
    print(f'Total elapsed time by {max_worker} workers:', time()-tic)

concurrent(5)
concurrent(4)
concurrent(3)
concurrent(2)
concurrent(1)

Output:

Total elapsed time by 5 workers: 7.007831811904907
Total elapsed time by 4 workers: 7.007944107055664
Total elapsed time by 3 workers: 7.003149509429932
Total elapsed time by 2 workers: 8.004627466201782
Total elapsed time by 1 workers: 13.013478994369507

---

[NOTE]:

• As you can see in the above results, the best case was 3 workers for those four tasks.
• If you have a process task instead of I/O bound or blocking (multiprocessing instead of threading) you can change the ThreadPoolExecutor to ProcessPoolExecutor.

Daffie

Thank you for the answer. So in case, I have multiple threads running in the same process, I used an Event object with them to synchronize their operations. Do you think your approach is faster, please? – Rhotacism

@Rhotacism This is also multithreading, there is no difference. But the point about this approach is using a thread pool as it's not always efficient to create threads equal to your tasks, and it depends on the tasks and you can test it btw. – Daffie

I want to spawn threads to process video frames (size at most 200 kb). So I spawn threads to process them and then add results to the queue. Do you still think the Thread/Process pool is more efficient, please? Also, can you share a book where I can study these things in depth? – Rhotacism

@Rhotacism Firstly, you should select threading or processing. For example, if you have CPU-intensive tasks multiprocessing would be a better choice. Next, it's worth noting that spawning threads or processes have their own overhead. That's why we recommend a thread/process pool instead (e.g. 10 threads per 30frames). Nevertheless, the best approach is to test them easily and select the best one. Btw, unfortunately, I usually don't go through the books and I find content that I need by surfing the internet. – Daffie

Answer 15

I would like to contribute with a simple example and the explanations I've found useful when I had to tackle this problem myself.

In this answer you will find some information about Python's GIL (global interpreter lock) and a simple day-to-day example written using multiprocessing.dummy plus some simple benchmarks.

Global Interpreter Lock (GIL)

Python doesn't allow multi-threading in the truest sense of the word. It has a multi-threading package, but if you want to multi-thread to speed your code up, then it's usually not a good idea to use it.

Python has a construct called the global interpreter lock (GIL). The GIL makes sure that only one of your 'threads' can execute at any one time. A thread acquires the GIL, does a little work, then passes the GIL onto the next thread.

This happens very quickly so to the human eye it may seem like your threads are executing in parallel, but they are really just taking turns using the same CPU core.

All this GIL passing adds overhead to execution. This means that if you want to make your code run faster then using the threading package often isn't a good idea.

There are reasons to use Python's threading package. If you want to run some things simultaneously, and efficiency is not a concern, then it's totally fine and convenient. Or if you are running code that needs to wait for something (like some I/O) then it could make a lot of sense. But the threading library won't let you use extra CPU cores.

Multi-threading can be outsourced to the operating system (by doing multi-processing), and some external application that calls your Python code (for example, Spark or Hadoop), or some code that your Python code calls (for example: you could have your Python code call a C function that does the expensive multi-threaded stuff).

Why This Matters

Because lots of people spend a lot of time trying to find bottlenecks in their fancy Python multi-threaded code before they learn what the GIL is.

Once this information is clear, here's my code:

#!/bin/python
from multiprocessing.dummy import Pool
from subprocess import PIPE,Popen
import time
import os

# In the variable pool_size we define the "parallelness".
# For CPU-bound tasks, it doesn't make sense to create more Pool processes
# than you have cores to run them on.
#
# On the other hand, if you are using I/O-bound tasks, it may make sense
# to create a quite a few more Pool processes than cores, since the processes
# will probably spend most their time blocked (waiting for I/O to complete).
pool_size = 8

def do_ping(ip):
    if os.name == 'nt':
        print ("Using Windows Ping to " + ip)
        proc = Popen(['ping', ip], stdout=PIPE)
        return proc.communicate()[0]
    else:
        print ("Using Linux / Unix Ping to " + ip)
        proc = Popen(['ping', ip, '-c', '4'], stdout=PIPE)
        return proc.communicate()[0]


os.system('cls' if os.name=='nt' else 'clear')
print ("Running using threads\n")
start_time = time.time()
pool = Pool(pool_size)
website_names = ["www.google.com","www.facebook.com","www.pinterest.com","www.microsoft.com"]
result = {}
for website_name in website_names:
    result[website_name] = pool.apply_async(do_ping, args=(website_name,))
pool.close()
pool.join()
print ("\n--- Execution took {} seconds ---".format((time.time() - start_time)))

# Now we do the same without threading, just to compare time
print ("\nRunning NOT using threads\n")
start_time = time.time()
for website_name in website_names:
    do_ping(website_name)
print ("\n--- Execution took {} seconds ---".format((time.time() - start_time)))

# Here's one way to print the final output from the threads
output = {}
for key, value in result.items():
    output[key] = value.get()
print ("\nOutput aggregated in a Dictionary:")
print (output)
print ("\n")

print ("\nPretty printed output: ")
for key, value in output.items():
    print (key + "\n")
    print (value)

Apogee

Also I see that without threads, it took around 79 seconds while with threading it took around 17 seconds. – Rhotacism

Answer 16

Here is the very simple example of CSV import using threading. (Library inclusion may differ for different purpose.)

Helper Functions:

from threading import Thread
from project import app
import csv


def import_handler(csv_file_name):
    thr = Thread(target=dump_async_csv_data, args=[csv_file_name])
    thr.start()

def dump_async_csv_data(csv_file_name):
    with app.app_context():
        with open(csv_file_name) as File:
            reader = csv.DictReader(File)
            for row in reader:
                # DB operation/query

Driver Function:

import_handler(csv_file_name)

Urena

Answer 17

Here is multi threading with a simple example which will be helpful. You can run it and understand easily how multi threading is working in Python. I used a lock for preventing access to other threads until the previous threads finished their work. By the use of this line of code,

tLock = threading.BoundedSemaphore(value=4)

you can allow a number of processes at a time and keep hold to the rest of the threads which will run later or after finished previous processes.

import threading
import time

#tLock = threading.Lock()
tLock = threading.BoundedSemaphore(value=4)
def timer(name, delay, repeat):
    print  "\r\nTimer: ", name, " Started"
    tLock.acquire()
    print "\r\n", name, " has the acquired the lock"
    while repeat > 0:
        time.sleep(delay)
        print "\r\n", name, ": ", str(time.ctime(time.time()))
        repeat -= 1

    print "\r\n", name, " is releaseing the lock"
    tLock.release()
    print "\r\nTimer: ", name, " Completed"

def Main():
    t1 = threading.Thread(target=timer, args=("Timer1", 2, 5))
    t2 = threading.Thread(target=timer, args=("Timer2", 3, 5))
    t3 = threading.Thread(target=timer, args=("Timer3", 4, 5))
    t4 = threading.Thread(target=timer, args=("Timer4", 5, 5))
    t5 = threading.Thread(target=timer, args=("Timer5", 0.1, 5))

    t1.start()
    t2.start()
    t3.start()
    t4.start()
    t5.start()

    print "\r\nMain Complete"

if __name__ == "__main__":
    Main()

Uund

Answer 18

None of the previous solutions actually used multiple cores on my GNU/Linux server (where I don't have administrator rights). They just ran on a single core.

I used the lower level os.fork interface to spawn multiple processes. This is the code that worked for me:

from os import fork

values = ['different', 'values', 'for', 'threads']

for i in range(len(values)):
    p = fork()
    if p == 0:
        my_function(values[i])
        break

Metabolism

Thank you. What you are trying to do with if p == 0: please? – Rhotacism

@Rhotacism This is the way to figure out you are in a child process in a UNIX-like operating systems. When a process spawns a child (forks), the "fork" function returns twice: in a parent and a child process. If PID (process id, it's called "p" in the code above) is zero, then we are in a child process. If not, then PID contains the id of the child process. – Rooney

Answer 19

As a python3 version of Alex Martelli's answer:

import queue as Queue
import threading
import urllib.request

# Called by each thread
def get_url(q, url):
    q.put(urllib.request.urlopen(url).read())

theurls = ["http://google.com", "http://yahoo.com", "http://www.python.org","https://wiki.python.org/moin/"]

q = Queue.Queue()
def thread_func():
    for u in theurls:
        t = threading.Thread(target=get_url, args = (q,u))
        t.daemon = True
        t.start()

    s = q.get()
    
def non_thread_func():
    for u in theurls:
        get_url(q,u)
        

    s = q.get()
   

And you can test it:

start = time.time()
thread_func()
end = time.time()
print(end - start)

start = time.time()
non_thread_func()
end = time.time()
print(end - start)

non_thread_func() should cost 4 times the time spent than thread_func()

Stoneman

Answer 20

import threading
import requests

def send():

  r = requests.get('https://www.stackoverlow.com')

thread = []
t = threading.Thread(target=send())
thread.append(t)
t.start()

Backed

t = threading.Thread(target=send()) should be t = threading.Thread(target=send) – Lilas

I'm downvoting this answer because it doesn't provide an explanation of how it improves upon existing answers, in addition to containing a serious inaccuracy. – Mancuso

Answer 21

It's very easy to understand. Here are the two simple ways to do threading.

import time
from concurrent.futures import ThreadPoolExecutor, as_completed
import threading

def a(a=1, b=2):
    print(a)
    time.sleep(5)
    print(b)
    return a+b

def b(**kwargs):
    if "a" in kwargs:
        print("am b")
    else:
        print("nothing")
        
to_do=[]
executor = ThreadPoolExecutor(max_workers=4)
ex1=executor.submit(a)
to_do.append(ex1)
ex2=executor.submit(b, **{"a":1})
to_do.append(ex2)

for future in as_completed(to_do):
    print("Future {} and Future Return is {}\n".format(future, future.result()))

print("threading")

to_do=[]
to_do.append(threading.Thread(target=a))
to_do.append(threading.Thread(target=b, kwargs={"a":1}))

for threads in to_do:
    threads.start()
    
for threads in to_do:
    threads.join()

Harrison

Answer 22

This code below can run 10 threads concurrently printing the numbers from 0 to 99:

from threading import Thread

def test():
    for i in range(0, 100):
        print(i)

thread_list = []

for _ in range(0, 10):
    thread = Thread(target=test)
    thread_list.append(thread)

for thread in thread_list:
    thread.start()

for thread in thread_list:
    thread.join()

And, this code below is the shorthand for loop version of the above code running 10 threads concurrently printing the numbers from 0 to 99:

from threading import Thread

def test():
    [print(i) for i in range(0, 100)]

thread_list = [Thread(target=test) for _ in range(0, 10)]

[thread.start() for thread in thread_list]

[thread.join() for thread in thread_list]

This is the result below:

...
99
83
97
84
98
99
85
86
87
88
...

Mccarthy

Answer 23

The easiest way of using threading/multiprocessing is to use more high level libraries like autothread.

import autothread
from time import sleep as heavyworkload

@autothread.multithreaded() # <-- This is all you need to add
def example(x: int, y: int):
    heavyworkload(1)
    return x*y

Now, you can feed your functions lists of ints. Autothread will handle everything for you and just give you the results computed in parallel.

result = example([1, 2, 3, 4, 5], 10)

Minsk

Answer 24

Example of multiple threading. Here Threads are running concurrently:

from threading import Thread

def fun_square(x):
    x_square = x**2
    print('x_square: ', x_square)

def x_pow_y(x,y):
    x_pow_y = x**y
    print('x_pow_y: ', x_pow_y)
    
def fun_qube(z):
    z_qube = z*z*z
    print('z_qube: ', z_qube)
    
def normal_fun():
    print("Normal fun is working at same time...")

Thread(target = fun_square, args=(5,)).start() #args=(x,)
Thread(target = x_pow_y, args=(2,4,)).start() #args=(x,y,)
Thread(target = fun_qube(4)).start() #fun_qube(z)
Thread(target = normal_fun).start()

Anjanette