Greenlet Vs. Threads

我是新手。我找到了一些关于如何使用它们的好文档，但是没有一个给我关于如何以及何时使用greenlet的理由!

他们到底擅长什么?
在代理服务器中使用它们是不是一个好主意?

我不确定的是，如果它们基本上是协同例程，它们如何为我们提供并发性。

greenlet提供并发性，但不提供并行性。并发是指代码可以独立于其他代码运行。并行性是指同时执行并发代码。当有很多工作要在用户空间中完成时，并行性特别有用，这通常是cpu繁重的工作。并发对于分解问题很有用，使得不同的部分可以更容易地并行调度和管理。

greenlet在网络编程中非常闪耀，其中与一个套接字的交互可以独立于与其他套接字的交互发生。这是并发的一个经典示例。因为每个greenlet都在自己的上下文中运行，所以您可以继续使用同步api而不使用线程。这很好，因为线程在虚拟内存和内核开销方面非常昂贵，因此使用线程可以实现的并发性大大降低。此外，由于GIL, Python中的线程比通常的线程更昂贵，也更有限。并发的替代方案通常是Twisted, libevent, libuv, node.js等项目，其中所有代码共享相同的执行上下文，并注册事件处理程序。

使用greenlet(通过适当的网络支持，例如通过gevent)编写代理是一个很好的主意，因为您的请求处理能够独立执行，并且应该这样编写。

greenlet提供并发性的原因我在前面提到过。并发性不是并行性。通过隐藏事件注册并为通常会阻塞当前线程的调用执行调度，像gevent这样的项目不需要更改异步API就可以公开这种并发性，并且大大降低了系统的成本。

线程与进程
多进程与线程
GIL vs. CPython

纠正@TemporalBeing上面的回答，greenlets并不比线程"快"，生成60000个线程来解决并发问题是一种不正确的编程技术，一个小的线程池是合适的。这是一个更合理的比较(来自我的reddit帖子，回应人们引用这篇文章)。

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代码处理数千个连接的速度快得多。

取@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上有一些显著的不同

这很有趣，值得分析。下面是比较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文档说它是用于网络操作的。对于网络密集型操作，线程切换是很好的，您可以看到多线程方法非常快。此外，使用python的官方库总是更好;我尝试在windows上安装greenlet，遇到了dll依赖问题，所以我在linux vm上运行了这个测试。写代码时，总是希望它能在任何机器上运行。

相关内容

最新更新

热门标签：