大多数文档和教程都使用Python的“线程和队列”模块，对于初学者来说，它们可能会让人不知所措。

也许可以考虑Python 3的concurrent.futures.ThreadPoolExecutor模块。

结合子句和列表理解，这可能是一个真正的魅力。

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()

这里是使用线程导入CSV的一个非常简单的示例。（图书馆的收录可能因不同的目的而有所不同。）

助手函数：

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

驾驶员功能：

import_handler(csv_file_name)

注意：对于Python中的实际并行化，您应该使用多处理模块来分叉并行执行的多个进程（由于全局解释器锁，Python线程提供了交织，但实际上它们是串行执行的，而不是并行执行的，并且仅在交织I/O操作时有用）。

然而，如果您只是在寻找交错（或者正在执行可以并行化的I/O操作，尽管存在全局解释器锁），那么线程模块就是开始的地方。作为一个非常简单的例子，让我们考虑通过并行对子范围求和来对大范围求和的问题：

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

请注意，以上是一个非常愚蠢的示例，因为它绝对没有I/O，并且由于全局解释器锁，虽然在CPython中交错执行（增加了上下文切换的开销），但仍将串行执行。

使用线程/多处理的最简单方法是使用更多高级库，如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

现在，您可以为函数提供int列表。Autothread将为您处理所有事务，并只提供并行计算的结果。

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

这里有一个简单的示例：您需要尝试一些替代URL，并返回第一个URL的内容以进行响应。

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

在这种情况下，线程被用作一种简单的优化：每个子线程都在等待URL解析和响应，以将其内容放入队列；每个线程都是一个守护进程（如果主线程结束，则不会保持进程运行——这比不结束更常见）；主线程启动所有子线程，在队列中执行get以等待其中一个线程完成put，然后发出结果并终止（这将删除所有可能仍在运行的子线程，因为它们是守护进程线程）。

Python中线程的正确使用总是与I/O操作相关（因为CPython无论如何都不使用多个内核来运行CPU绑定的任务，线程的唯一原因是在等待一些I/O时不会阻塞进程）。顺便说一句，队列几乎总是将工作分配给线程和/或收集工作结果的最佳方式，而且它们本质上是线程安全的，因此它们使您不用担心锁、条件、事件、信号量和其他线程间协调/通信概念。

借用本文，我们了解了如何在多线程、多处理和异步/异步之间进行选择及其用法。

Python 3有一个新的内置库，以实现并发和并行-concurrent.futures

因此，我将通过一个实验演示如何通过线程池运行四个任务（即.sleep（）方法）：

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)

输出：

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

[注]：

正如您在上面的结果中看到的，最好的情况是这四项任务有3名员工。如果有进程任务而不是I/O绑定或阻塞（多处理而不是线程），则可以将ThreadPoolExecutor更改为ProcessPoolExecutoor。