问题：GreenletVS。线程数
我是gevents和greenlets的新手。我找到了一些有关如何使用它们的很好的文档，但是没有一个文档为我提供有关如何以及何时使用greenlets的理由！
- 他们真正擅长的是什么？
- 是否在代理服务器中使用它们是一个好主意吗？
- 为什么不线程？
我不确定的是，如果它们基本上是例程，它们如何为我们提供并发性。
回答 0
Greenlets提供并发性，但不提供并行性。并发是指代码可以独立于其他代码运行的时间。并行是同时执行并发代码。当在用户空间中有很多工作要做时，并行性特别有用，而这通常是占用大量CPU的工作。并发对于解决问题非常有用，它可以更轻松地并行调度和管理不同的部分。
Greenlets确实在网络编程中大放异彩，其中与一个套接字的交互可以独立于与其他套接字的交互而发生。这是并发的经典示例。由于每个greenlet都在其自己的上下文中运行，因此您可以继续使用同步API，而无需使用线程。这很好，因为就虚拟内存和内核开销而言，线程非常昂贵，因此线程可以实现的并发性要少得多。此外，由于使用GIL，Python中的线程比平时更昂贵且更受限制。并发的替代方法通常是Twisted，libevent，libuv，node.js等项目，其中所有代码共享相同的执行上下文，并注册事件处理程序。
使用greenlet（具有适当的网络支持，例如通过gevent）来编写代理是一个好主意，因为对请求的处理可以独立执行，因此应这样编写。
出于我之前提到的原因，Greenlets提供了并发性。并发不是并行性。通过隐藏事件注册并为通常会阻塞当前线程的调用执行调度，gevent之类的项目无需更改异步API即可公开此并发性，而系统的成本却大大降低。
回答 1
拿@Max的答案并为其添加一些相关性以进行缩放，您可以看到区别。我是通过更改要填充的URL来实现的，如下所示：
URLS_base = ['www.google.com', 'www.example.com', 'www.python.org', 'www.yahoo.com', 'www.ubc.ca', 'www.wikipedia.org']
URLS = []
for _ in range(10000):
for url in URLS_base:
URLS.append(url)在我有500个版本之前，我不得不放弃多进程版本。但经过10,000次迭代：
Using gevent it took: 3.756914
-----------
Using multi-threading it took: 15.797028因此，您可以看到使用gevent的I / O有一些明显的不同
回答 2
纠正上面的@TemporalBeing的答案，greenlets的速度并不比线程“快”，并且产生60000个线程来解决并发问题是不正确的编程技术，相反，较小的线程池是合适的。这是一个更合理的比较（根据我在reddit帖子中对有人引用此SO帖子的回应）。
import gevent
from gevent import socket as gsock
import socket as sock
import threading
from datetime import datetime
def timeit(fn, URLS):
t1 = datetime.now()
fn()
t2 = datetime.now()
print(
"%s / %d hostnames, %s seconds" % (
fn.__name__,
len(URLS),
(t2 - t1).total_seconds()
)
)
def run_gevent_without_a_timeout():
ip_numbers = []
def greenlet(domain_name):
ip_numbers.append(gsock.gethostbyname(domain_name))
jobs = [gevent.spawn(greenlet, domain_name) for domain_name in URLS]
gevent.joinall(jobs)
assert len(ip_numbers) == len(URLS)
def run_threads_correctly():
ip_numbers = []
def process():
while queue:
try:
domain_name = queue.pop()
except IndexError:
pass
else:
ip_numbers.append(sock.gethostbyname(domain_name))
threads = [threading.Thread(target=process) for i in range(50)]
queue = list(URLS)
for t in threads:
t.start()
for t in threads:
t.join()
assert len(ip_numbers) == len(URLS)
URLS_base = ['www.google.com', 'www.example.com', 'www.python.org',
'www.yahoo.com', 'www.ubc.ca', 'www.wikipedia.org']
for NUM in (5, 50, 500, 5000, 10000):
URLS = []
for _ in range(NUM):
for url in URLS_base:
URLS.append(url)
print("--------------------")
timeit(run_gevent_without_a_timeout, URLS)
timeit(run_threads_correctly, URLS)结果如下：
--------------------
run_gevent_without_a_timeout / 30 hostnames, 0.044888 seconds
run_threads_correctly / 30 hostnames, 0.019389 seconds
--------------------
run_gevent_without_a_timeout / 300 hostnames, 0.186045 seconds
run_threads_correctly / 300 hostnames, 0.153808 seconds
--------------------
run_gevent_without_a_timeout / 3000 hostnames, 1.834089 seconds
run_threads_correctly / 3000 hostnames, 1.569523 seconds
--------------------
run_gevent_without_a_timeout / 30000 hostnames, 19.030259 seconds
run_threads_correctly / 30000 hostnames, 15.163603 seconds
--------------------
run_gevent_without_a_timeout / 60000 hostnames, 35.770358 seconds
run_threads_correctly / 60000 hostnames, 29.864083 seconds每个人对使用Python进行非阻塞IO的误解都认为，Python解释器可以比网络连接本身返回IO的速度更快地完成从套接字检索结果的工作。尽管在某些情况下这确实是正确的，但事实并非如人们想象的那么频繁，因为Python解释器的确非常慢。在我的博客文章中，我说明了一些图形配置文件，这些图形配置文件显示即使对于非常简单的事情，如果您要处理对数据库或DNS服务器等事物的快速便捷的网络访问，这些服务的返回速度都将比Python代码快得多。可以参加成千上万的此类联系。
回答 3
这足以分析有趣。这是一个代码，用于比较greenlet与多处理池与多线程的性能：
import gevent
from gevent import socket as gsock
import socket as sock
from multiprocessing import Pool
from threading import Thread
from datetime import datetime
class IpGetter(Thread):
def __init__(self, domain):
Thread.__init__(self)
self.domain = domain
def run(self):
self.ip = sock.gethostbyname(self.domain)
if __name__ == "__main__":
URLS = ['www.google.com', 'www.example.com', 'www.python.org', 'www.yahoo.com', 'www.ubc.ca', 'www.wikipedia.org']
t1 = datetime.now()
jobs = [gevent.spawn(gsock.gethostbyname, url) for url in URLS]
gevent.joinall(jobs, timeout=2)
t2 = datetime.now()
print "Using gevent it took: %s" % (t2-t1).total_seconds()
print "-----------"
t1 = datetime.now()
pool = Pool(len(URLS))
results = pool.map(sock.gethostbyname, URLS)
t2 = datetime.now()
pool.close()
print "Using multiprocessing it took: %s" % (t2-t1).total_seconds()
print "-----------"
t1 = datetime.now()
threads = []
for url in URLS:
t = IpGetter(url)
t.start()
threads.append(t)
for t in threads:
t.join()
t2 = datetime.now()
print "Using multi-threading it took: %s" % (t2-t1).total_seconds()结果如下：
Using gevent it took: 0.083758
-----------
Using multiprocessing it took: 0.023633
-----------
Using multi-threading it took: 0.008327我认为greenlet声称它不像多线程库那样不受GIL的约束。而且，Greenlet doc说它是用于网络操作的。对于网络密集型操作，线程切换很好，您可以看到多线程方法非常快。同样，使用python的官方库总是很可取的。我尝试在Windows上安装greenlet并遇到dll依赖关系问题，因此我在linux vm上运行了该测试。始终尝试编写代码，希望它可以在任何计算机上运行。
