我正在努力理解Python中的线程。我看过文档和示例，但坦率地说，许多示例过于复杂，我很难理解它们。
如何清楚地显示为多线程划分的任务？
当前回答
自2010年提出这个问题以来，如何使用带有映射和池的Python进行简单的多线程处理已经得到了真正的简化。
下面的代码来自一篇文章/博客文章，您应该明确查看（没有从属关系）-一行中的并行性：一个更好的日常线程任务模型。我将在下面总结一下——它最终只是几行代码：
from multiprocessing.dummy import Pool as ThreadPool
pool = ThreadPool(4)
results = pool.map(my_function, my_array)
以下是多线程版本：
results = []
for item in my_array:
results.append(my_function(item))
描述
Map是一个很酷的小函数，是将并行性轻松注入Python代码的关键。对于那些不熟悉的人来说，map是从Lisp这样的函数语言中提取出来的。它是一个将另一个函数映射到序列上的函数。Map为我们处理序列上的迭代，应用函数，并在最后将所有结果存储在一个方便的列表中。
实施
map函数的并行版本由两个库提供：multiprocessing，以及它鲜为人知但同样神奇的stepchild：multiprocessing.dummy。
multiprocessing.dummy与多处理模块完全相同，但使用线程（一个重要的区别-对CPU密集型任务使用多个进程；对I/O（和在I/O期间）使用线程）：
multiprocessing.dummy复制了多处理的API，但它不过是线程模块的包装器。
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()
计时结果：
Single thread: 14.4 seconds
4 Pool: 3.1 seconds
8 Pool: 1.4 seconds
13 Pool: 1.3 seconds
传递多个参数（仅在Python 3.3及更高版本中如此）：
要传递多个数组，请执行以下操作：
results = pool.starmap(function, zip(list_a, list_b))
或者传递常量和数组：
results = pool.starmap(function, zip(itertools.repeat(constant), list_a))
如果您使用的是早期版本的Python，可以通过此解决方法传递多个参数）。
（感谢user136036提供的有用评论。）
其他回答
对我来说，线程的最佳示例是监视异步事件。看看这个代码。
# 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;
您可以通过打开IPython会话并执行以下操作来使用此代码：
>>> from thread_test import Monitor
>>> a = [0]
>>> mon = Monitor(a)
>>> mon.start()
>>> a[0] = 2
Mon = 2
>>>a[0] = 2
Mon = 2
等几分钟
>>> a[0] = 2
Mon = 2
自2010年提出这个问题以来，如何使用带有映射和池的Python进行简单的多线程处理已经得到了真正的简化。
下面的代码来自一篇文章/博客文章，您应该明确查看（没有从属关系）-一行中的并行性：一个更好的日常线程任务模型。我将在下面总结一下——它最终只是几行代码：
from multiprocessing.dummy import Pool as ThreadPool
pool = ThreadPool(4)
results = pool.map(my_function, my_array)
以下是多线程版本：
results = []
for item in my_array:
results.append(my_function(item))
描述
Map是一个很酷的小函数，是将并行性轻松注入Python代码的关键。对于那些不熟悉的人来说，map是从Lisp这样的函数语言中提取出来的。它是一个将另一个函数映射到序列上的函数。Map为我们处理序列上的迭代，应用函数，并在最后将所有结果存储在一个方便的列表中。
实施
map函数的并行版本由两个库提供：multiprocessing，以及它鲜为人知但同样神奇的stepchild：multiprocessing.dummy。
multiprocessing.dummy与多处理模块完全相同，但使用线程（一个重要的区别-对CPU密集型任务使用多个进程；对I/O（和在I/O期间）使用线程）：
multiprocessing.dummy复制了多处理的API，但它不过是线程模块的包装器。
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()
计时结果：
Single thread: 14.4 seconds
4 Pool: 3.1 seconds
8 Pool: 1.4 seconds
13 Pool: 1.3 seconds
传递多个参数（仅在Python 3.3及更高版本中如此）：
要传递多个数组，请执行以下操作：
results = pool.starmap(function, zip(list_a, list_b))
或者传递常量和数组：
results = pool.starmap(function, zip(itertools.repeat(constant), list_a))
如果您使用的是早期版本的Python，可以通过此解决方法传递多个参数）。
（感谢user136036提供的有用评论。）
大多数文档和教程都使用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()
使用全新的concurrent.futures模块
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())
执行器方法对于所有以前接触过Java的人来说似乎都很熟悉。
还有一个附带说明：为了保持宇宙的正常，如果你不使用上下文，不要忘记关闭你的池/执行器（这是如此棒，它为你做了）
下面的代码可以运行10个线程同时打印0到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()
下面的代码是上述代码循环版本的简写，运行10个线程，同时打印0到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]
结果如下：
...
99
83
97
84
98
99
85
86
87
88
...
推荐文章
- 有没有办法在python中做HTTP PUT
- “foo Is None”和“foo == None”之间有什么区别吗?
- 类没有对象成员
- Django模型“没有显式声明app_label”
- 熊猫能自动从CSV文件中读取日期吗?
- 在python中zip的逆函数是什么?
- 有效的方法应用多个过滤器的熊猫数据框架或系列
- 如何检索插入id后插入行在SQLite使用Python?
- 我如何在Django中添加一个CharField占位符?
- 如何在Python中获取当前执行文件的路径?
- 我如何得到“id”后插入到MySQL数据库与Python?
- super()失败，错误:TypeError "参数1必须是类型，而不是classobj"当父不继承对象
- Python内存泄漏
- 实现嵌套字典的最佳方法是什么?
- 如何在tensorflow中获得当前可用的gpu ?
