python多线程并发
㈠ 如何优雅的编写python并发程序
在Python中,由于历史原因(GIL),使得Python中多线程的效果非常不理想.GIL使得任何时刻Python只能利用一个CPU核,并
且它的调度算法简单粗暴:多线程中,让每个线程运行一段时间t,然后强行挂起该线程,继而去运行其他线程,如此周而复始,直到所有线程结束.
这使得无法有效利用计算机系统中的"局部性",频繁的线程切换也对缓存不是很友好,造成资源的浪费.
据说Python官方曾经实现了一个去除GIL的Python解释器,但是其效果还不如有GIL的解释器,遂放弃.后来Python官方推出了"利
用多进程替代多线程"的方案,在Python3中也有concurrent.futures这样的包,让我们的程序编写可以做到"简单和性能兼得".
多进程/多线程+Queue
一般来说,在Python中编写并发程序的经验是:计算密集型任务使用多进程,IO密集型任务使用多进程或者多线程.另外,因为涉及到资源共享,所
以需要同步锁等一系列麻烦的步骤,代码编写不直观.另外一种好的思路是利用多进程/多线程+Queue的方法,可以避免加锁这样麻烦低效的方式.
现在在Python2中利用Queue+多进程的方法来处理一个IO密集型任务.
假设现在需要下载多个网页内容并进行解析,单进程的方式效率很低,所以使用多进程/多线程势在必行.
㈡ 如何理解python的多线程编程
线程是程序员必须掌握的知识，多线程对于代码的并发执行、提升代码效率和运行都至关重要。今天就分享一个黑马程序员Python多线程编程的教程，从0开始学习python多任务编程，想了解python高并发实现，从基础到实践，通过知识点 + 案例教学法帮助你想你想迅速掌握python多任务。
课程内容：
1.掌握多任务实现的并行和并发
2.掌握多进程实现多任务
3.掌握多线程实现多任务
4.掌握合理搭配多进程和线程
适用人群：
1、对python多任务编程感兴趣的在校生及应届毕业生。
2、对目前职业有进一步提升要求，希望从事python人工智能行业高薪工作的在职人员。
3、对python人工智能行业感兴趣的相关人员。
基础课程主讲内容包括：
1.python多任务编程
基础班课程大纲：
00-课程介绍
01-多任务介绍
02-进程介绍
03-使用多进程来完成多任务
04-多进程执行带有参数的任务
05-获取进程的编号
06-进程注意点
07-案例-多进程实现传智视频文件夹多任务拷贝器
08-线程介绍
09-使用多线程执行多任务
10-线程执行带有参数的任务
11-主线程和子线程的结束顺序
12-线程之间的执行顺序是无序
13-线程和进程的对比
14-案例-多线程实现传智视频文件夹多任务拷贝器
15-课程总结
㈢ python 多线程支持并发吗
python3.2以前的都不支持。另外，也要看你的解释器是什么版本，一般的是cpython
㈣ Python多线程是什么意思
多线程能让你像运行一个独立的程序一样运行一段长代码。这有点像调用子进程（subprocess），不过区别是你调用shu的是一个函数或者一个类，而不是独立的程序。
程基本上是一个独立执行流程。单个进程可以由多个线程组成。程序中的每个线程都执行特定的任务。例如,当你在电脑上玩游戏时，比如说国际足联，整个游戏是一个单一的过程。,但它由几个线程组成，负责播放音乐、接收用户的输入、同步运行对手等。所有这些都是单独的线程，负责在同一个程序中执行这些不同的任务。
每个进程都有一个始终在运行的线程。这是主线。这个主线程实际上创建子线程对象。子线程也由主线程启动。
㈤ Python并发编程之创建多线程的几种方法
Django: Py Web应用开发框架
Diesel：基于Greenlet的事件I/O框架
Flask：一个用Py编写的轻量级Web应用框架
Cubes：轻量级Py OLAP框架
Kartograph.py：创造矢量地图的轻量级Py框架
Pulsar：Py的事件驱动并发框架
Web2py：全栈式Web框架
Falcon：构建云API和网络应用后端的高性能Py框架
Dpark：Py版的Spark
Buildbot：基于Py的持续集成测试框架
Zerorpc：基于ZeroMQ的高性能分布式RPC框架
Bottle: 微型Py Web框架
Tornado：异步非阻塞IO的Py Web框架
webpy: 轻量级的Py Web框架
Scrapy：Py的爬虫框架
㈥ 如何使用Python实现并发编程
多线程几乎是每一个程序猿在使用每一种语言时都会首先想到用于解决并发的工具（JS程序员请回避），使用多线程可以有效的利用CPU资源（Python例外）。然而多线程所带来的程序的复杂度也不可避免，尤其是对竞争资源的同步问题。
然而在python中由于使用了全局解释锁（GIL）的原因，代码并不能同时在多核上并发的运行，也就是说，Python的多线程不能并发，很多人会发现使用多线程来改进自己的Python代码后，程序的运行效率却下降了，这是多么蛋疼的一件事呀！如果想了解更多细节，推荐阅读这篇文章。实际上使用多线程的编程模型是很困难的，程序员很容易犯错，这并不是程序员的错误，因为并行思维是反人类的，我们大多数人的思维是串行（精神分裂不讨论），而且冯诺依曼设计的计算机架构也是以顺序执行为基础的。所以如果你总是不能把你的多线程程序搞定，恭喜你，你是个思维正常的程序猿：）
Python提供两组线程的接口，一组是thread模块，提供基础的，低等级（Low Level）接口，使用Function作为线程的运行体。还有一组是threading模块，提供更容易使用的基于对象的接口（类似于Java），可以继承Thread对象来实现线程，还提供了其它一些线程相关的对象，例如Timer，Lock
使用thread模块的例子
import thread
def worker():
"""thread worker function"""
print 'Worker'
thread.start_new_thread(worker)
使用threading模块的例子
import threading
def worker():
"""thread worker function"""
print 'Worker'
t = threading.Thread(target=worker)
t.start()
或者Java Style
import threading
class worker(threading.Thread):
def __init__(self):
pass
def run():
"""thread worker function"""
print 'Worker'
t = worker()
t.start()
㈦ 如何在Python中编写并发程序
GIL
在Python中,由于历史原因(GIL),使得Python中多线程的效果非常不理想.GIL使得任何时刻Python只能利用一个CPU核,并
且它的调度算法简单粗暴:多线程中,让每个线程运行一段时间t,然后强行挂起该线程,继而去运行其他线程,如此周而复始,直到所有线程结束.
这使得无法有效利用计算机系统中的"局部性",频繁的线程切换也对缓存不是很友好,造成资源的浪费.
据说Python官方曾经实现了一个去除GIL的Python解释器,但是其效果还不如有GIL的解释器,遂放弃.后来Python官方推出了"利
用多进程替代多线程"的方案,在Python3中也有concurrent.futures这样的包,让我们的程序编写可以做到"简单和性能兼得".
多进程/多线程+Queue
一般来说,在Python中编写并发程序的经验是:计算密集型任务使用多进程,IO密集型任务使用多进程或者多线程.另外,因为涉及到资源共享,所
以需要同步锁等一系列麻烦的步骤,代码编写不直观.另外一种好的思路是利用多进程/多线程+Queue的方法,可以避免加锁这样麻烦低效的方式.
现在在Python2中利用Queue+多进程的方法来处理一个IO密集型任务.
假设现在需要下载多个网页内容并进行解析,单进程的方式效率很低,所以使用多进程/多线程势在必行.
我们可以先初始化一个tasks队列,里面将要存储的是一系列dest_url,同时开启4个进程向tasks中取任务然后执行,处理结果存储在一个results队列中,最后对results中的结果进行解析.最后关闭两个队列.
下面是一些主要的逻辑代码.
# -*- coding:utf-8 -*-
#IO密集型任务
#多个进程同时下载多个网页
#利用Queue+多进程
#由于是IO密集型,所以同样可以利用threading模块
import multiprocessing
def main():
tasks = multiprocessing.JoinableQueue()
results = multiprocessing.Queue()
cpu_count = multiprocessing.cpu_count() #进程数目==CPU核数目
create_process(tasks, results, cpu_count) #主进程马上创建一系列进程,但是由于阻塞队列tasks开始为空,副进程全部被阻塞
add_tasks(tasks) #开始往tasks中添加任务
parse(tasks, results) #最后主进程等待其他线程处理完成结果
def create_process(tasks, results, cpu_count):
for _ in range(cpu_count):
p = multiprocessing.Process(target=_worker, args=(tasks, results)) #根据_worker创建对应的进程
p.daemon = True #让所有进程可以随主进程结束而结束
p.start() #启动
def _worker(tasks, results):
while True: #因为前面所有线程都设置了daemon=True,故不会无限循环
try:
task = tasks.get() #如果tasks中没有任务,则阻塞
result = _download(task)
results.put(result) #some exceptions do not handled
finally:
tasks.task_done()
def add_tasks(tasks):
for url in get_urls(): #get_urls() return a urls_list
tasks.put(url)
def parse(tasks, results):
try:
tasks.join()
except KeyboardInterrupt as err:
print "Tasks has been stopped!"
print err
while not results.empty():
_parse(results)
if __name__ == '__main__':
main()
利用Python3中的concurrent.futures包
在Python3中可以利用concurrent.futures包,编写更加简单易用的多线程/多进程代码.其使用感觉和Java的concurrent框架很相似(借鉴?)
比如下面的简单代码示例
def handler():
futures = set()
with concurrent.futures.ProcessPoolExecutor(max_workers=cpu_count) as executor:
for task in get_task(tasks):
future = executor.submit(task)
futures.add(future)
def wait_for(futures):
try:
for future in concurrent.futures.as_completed(futures):
err = futures.exception()
if not err:
result = future.result()
else:
raise err
except KeyboardInterrupt as e:
for future in futures:
future.cancel()
print "Task has been canceled!"
print e
return result
总结
要是一些大型Python项目也这般编写,那么效率也太低了.在Python中有许多已有的框架使用,使用它们起来更加高效.
㈧ python多线程作用
总结起来，使用多线程编程具有如下几个优点：
进程之间不能共享内存，但线程之间共享内存非常容易。
操作系统在创建进程时，需要为该进程重新分配系统资源，但创建线程的代价则小得多。因此，使用多线程来实现多任务并发执行比使用多进程的效率高。
Python 语言内置了多线程功能支持，而不是单纯地作为底层操作系统的调度方式，从而简化了 Python 的多线程编程。
在实际应用中，多线程是非常有用的。比如一个浏览器必须能同时下载多张图片；一个 Web 服务器必须能同时响应多个用户请求；图形用户界面（GUI）应用也需要启动单独的线程，从主机环境中收集用户界面事件……总之，多线程在实际编程中的应用是非常广泛的。
㈨ Python 多线程并发控制问题
python线程有两种,类或者函数
后者很简单,就跟pthread一样用啊。
不要打印就好了，或者你自己维护一个print加个自旋锁
第三个从但是开始就没看懂
既然要加print那一定要加锁了，否则是没办法
既然你想搞一个控制线程，那就由它来打印咯
㈩ python stackless 怎么多线程并发
1 介绍
1.1 为什么要使用Stackless
摘自stackless网站。
Note
Stackless Python 是Python编程语言的一个增强版本，它使程序员从基于线程的编程方式中获得好处，并避免传统线程所带来的性能与复杂度问题。Stackless为 Python带来的微线程扩展，是一种低开销、轻量级的便利工具，如果使用得当，可以获益如下：
改进程序结构
增进代码可读性
提高编程人员生产力
- def familyTacoNight():
- husband.eat(dinner)
- wife.eat(dinner)
- son.eat(dinner)
- daughter.eat(dinner)
- Python 2.4.3 Stackless 3.1b3 060504 (#69, May 3 2006, 19:20:41) [MSC v.1310 32
- bit (Intel)] on win32
- Type "help", "right", "credits" or "license" for more information.
- >>> import stackless
- >>>
- >>> def print_x(x):
- ... print x
- ...
- >>> stackless.tasklet(print_x)('one')
- <stackless.tasklet object at 0x00A45870>
- >>> stackless.tasklet(print_x)('two')
- <stackless.tasklet object at 0x00A45A30>
- >>> stackless.tasklet(print_x)('three')
- <stackless.tasklet object at 0x00A45AB0>
- >>>
- >>> stackless.run()
- one
- two
- three
- >>>
- Python 2.4.3 Stackless 3.1b3 060504 (#69, May 3 2006, 19:20:41) [MSC v.1310 32
- bit (Intel)] on win32
- Type "help", "right", "credits" or "license" for more information.
- >>> import stackless
- >>>
- >>> def print_three_times(x):
- ... print "1:", x
- ... stackless.schele()
- ... print "2:", x
- ... stackless.schele()
- ... print "3:", x
- ... stackless.schele()
- ...
- >>>
- >>> stackless.tasklet(print_three_times)('first')
- <stackless.tasklet object at 0x00A45870>
- >>> stackless.tasklet(print_three_times)('second')
- <stackless.tasklet object at 0x00A45A30>
- >>> stackless.tasklet(print_three_times)('third')
- <stackless.tasklet object at 0x00A45AB0>
- >>>
- >>> stackless.run()
- 1: first
- 1: second
- 1: third
- 2: first
- 2: second
- 2: third
- 3: first
- 3: second
- 3: third
- >>>
能够在微进程之间交换信息。
能够控制运行的流程。
- C:>c:python24python
- Python 2.4.3 Stackless 3.1b3 060504 (#69, May 3 2006, 19:20:41) [MSC v.1310 32
- bit (Intel)] on win32
- Type "help", "right", "credits" or "license" for more information.
- >>> import stackless
- >>>
- >>> channel = stackless.channel()
- >>>
- >>> def receiving_tasklet():
- ... print "Recieving tasklet started"
- ... print channel.receive()
- ... print "Receiving tasklet finished"
- ...
- >>> def sending_tasklet():
- ... print "Sending tasklet started"
- ... channel.send("send from sending_tasklet")
- ... print "sending tasklet finished"
- ...
- >>> def another_tasklet():
- ... print "Just another tasklet in the scheler"
- ...
- >>> stackless.tasklet(receiving_tasklet)()
- <stackless.tasklet object at 0x00A45B30>
- >>> stackless.tasklet(sending_tasklet)()
- <stackless.tasklet object at 0x00A45B70>
- >>> stackless.tasklet(another_tasklet)()
- <stackless.tasklet object at 0x00A45BF0>
- >>>
- >>> stackless.run()
- Recieving tasklet started
- Sending tasklet started
- send from sending_tasklet
- Receiving tasklet finished
- Just another tasklet in the scheler
- sending tasklet finished
- >>>
- >>> stackless.tasklet(sending_tasklet)()
- <stackless.tasklet object at 0x00A45B70>
- >>> stackless.tasklet(another_tasklet)()
- <stackless.tasklet object at 0x00A45BF0>
- >>>
- >>> stackless.run()
- Sending tasklet started
- Just another tasklet in the scheler
- >>>
- >>> stackless.tasklet(another_tasklet)()
- <stackless.tasklet object at 0x00A45B30>
- >>> stackless.run()
- Just another tasklet in the scheler
- >>>
- >>> #Finally adding the receiving tasklet
- ...
- >>> stackless.tasklet(receiving_tasklet)()
- <stackless.tasklet object at 0x00A45BF0>
- >>>
- >>> stackless.run()
- Recieving tasklet started
- send from sending_tasklet
- Receiving tasklet finished
- sending tasklet finished
- def ping():
- print "PING"
- pong()
- def pong():
- print "PONG"
- ping()
- ping()
- #
- # pingpong_stackless.py
- #
- import stackless
- ping_channel = stackless.channel()
- pong_channel = stackless.channel()
- def ping():
- while ping_channel.receive(): #在此阻塞
- print "PING"
- pong_channel.send("from ping")
- def pong():
- while pong_channel.receive():
- print "PONG"
- ping_channel.send("from pong")
- stackless.tasklet(ping)()
- stackless.tasklet(pong)()
- # 我们需要发送一个消息来初始化这个游戏的状态
- # 否则，两个微进程都会阻塞
- stackless.tasklet(ping_channel.send)('startup')
- stackless.run()
- import thread
- import random
- import sys
- import Queue
- class hackysacker:
- counter = 0
- def __init__(self,name,circle):
- self.name = name
- self.circle = circle
- circle.append(self)
- self.messageQueue = Queue.Queue()
- thread.start_new_thread(self.messageLoop,())
- def incrementCounter(self):
- hackysacker.counter += 1
- if hackysacker.counter >= turns:
- while self.circle:
- hs = self.circle.pop()
- if hs is not self:
- hs.messageQueue.put('exit')
- sys.exit()
- def messageLoop(self):
- while 1:
- message = self.messageQueue.get()
- if message == "exit":
- debugPrint("%s is going home" % self.name)
- sys.exit()
- debugPrint("%s got hackeysack from %s" % (self.name, message.name))
- kickTo = self.circle[random.randint(0,len(self.circle)-1)]
- debugPrint("%s kicking hackeysack to %s" % (self.name, kickTo.name))
- self.incrementCounter()
- kickTo.messageQueue.put(self)
- def debugPrint(x):
- if debug:
- print x
- debug=1
- hackysackers=5
- turns = 5
以上是Stackless Python很简明的释义，但其对我们意义何在？——就在于Stackless提供的并发建模工具，比目前其它大多数传统编程语言所提供的，都更加易用： 不仅是Python自身，也包括Java、C++，以及其它。尽管还有其他一些语言提供并发特性，可它们要么是主要用于学术研究的（如 Mozart/Oz），要么是罕为使用、或用于特殊目的的专业语言（如Erlang）。而使用stackless，你将会在Python本身的所有优势之 上，在一个（但愿）你已经很熟悉的环境中，再获得并发的特性。
这自然引出了个问题：为什么要并发？
1.1.1 现实世界就是并发的
现实世界就是“并发”的，它是由一群事物（或“演员”）所组成，而这些事物以一种对彼此所知有限的、松散耦合的方式相互作用。传说中面向对象编程有 一个好处，就是对象能够对现实的世界进行模拟。这在一定程度上是正确的，面向对象编程很好地模拟了对象个体，但对于这些对象个体之间的交互，却无法以一种 理想的方式来表现。例如，如下代码实例，有什么问题？
第一印象，没问题。但是，上例中存在一个微妙的安排：所有事件是次序发生的，即：直到丈夫吃完饭，妻子才开始吃；儿子则一直等到母亲吃完才吃；而女 儿则是最后一个。在现实世界中，哪怕是丈夫还堵车在路上，妻子、儿子和女儿仍然可以该吃就吃，而要在上例中的话，他们只能饿死了——甚至更糟：永远没有人 会知道这件事，因为他们永远不会有机会抛出一个异常来通知这个世界！
1.1.2 并发可能是(仅仅可能是)下一个重要的编程范式
我个人相信，并发将是软件世界里的下一个重要范式。随着程序变得更加复杂和耗费资源，我们已经不能指望摩尔定律来每年给我们提供更快的CPU了，当 前，日常使用的个人计算机的性能提升来自于多核与多CPU机。一旦单个CPU的性能达到极限，软件开发者们将不得不转向分布式模型，靠多台计算机的互相协 作来建立强大的应用（想想GooglePlex）。为了取得多核机和分布式编程的优势，并发将很快成为做事情的方式的事实标准。
1.2 安装stackless
安装Stackless的细节可以在其网站上找到。现在Linux用户可以通过SubVersion取得源代码并编译；而对于Windows用户， 则有一个.zip文件供使用，需要将其解压到现有的Python安装目录中。接下来，本教程假设Stackless Python已经安装好了，可以工作，并且假设你对Python语言本身有基本的了解。
2 stackless起步
本章简要介绍了stackless的基本概念，后面章节将基于这些基础，来展示更加实用的功能。
2.1 微进程(tasklet)
微进程是stackless的基本构成单元，你可以通过提供任一个Python可调用对象（通常为函数或类的方法）来建立它，这将建立一个微进程并将其添加到调度器。这是一个快速演示:
注意，微进程将排起队来，并不运行，直到调用stackless.run()。
2.2 调度器(scheler)
调度器控制各个微进程运行的顺序。如果刚刚建立了一组微进程，它们将按照建立的顺序来执行。在现实中，一般会建立一组可以再次被调度的微进程，好让每个都有轮次机会。一个快速演示:
注意：当调用stackless.schele()的时候，当前活动微进程将暂停执行，并将自身重新插入到调度器队列的末尾，好让下一个微进程被执行。一旦在它前面的所有其他微进程都运行过了，它将从上次 停止的地方继续开始运行。这个过程会持续，直到所有的活动微进程都完成了运行过程。这就是使用stackless达到合作式多任务的方式。
2.3 通道(channel)
通道使得微进程之间的信息传递成为可能。它做到了两件事：
又一个快速演示:
接收的微进程调用channel.receive()的时候，便阻塞住，这意味着该微进程暂停执行，直到有信息从这个通道送过来。除了往这个通道发送信息以外，没有其他任何方式可以让这个微进程恢复运行。
若有其他微进程向这个通道发送了信息，则不管当前的调度到了哪里，这个接收的微进程都立即恢复执行；而发送信息的微进程则被转移到调度列表的末尾，就像调用了stackless.schele()一样。
同样注意，发送信息的时候，若当时没有微进程正在这个通道上接收，也会使当前微进程阻塞:
发送信息的微进程，只有在成功地将数据发送到了另一个微进程之后，才会重新被插入到调度器中。
2.4 总结
以上涵盖了stackless的大部分功能。似乎不多是吧？——我们只使用了少许对象，和大约四五个函数调用，来进行操作。但是，使用这种简单的API作为基本建造单元，我们可以开始做一些真正有趣的事情。
3 协程(coroutine)
3.1 子例程的问题
大多数传统编程语言具有子例程的概念。一个子例程被另一个例程（可能还是其它某个例程的子例程）所调用，或返回一个结果，或不返回结果。从定义上说，一个子例程是从属于其调用者的。
见下例:
有经验的编程者会看到这个程序的问题所在：它导致了堆栈溢出。如果运行这个程序，它将显示一大堆讨厌的跟踪信息，来指出堆栈空间已经耗尽。
3.1.1 堆栈
我仔细考虑了，自己对C语言堆栈的细节究竟了解多少，最终还是决定完全不去讲它。似乎，其他人对其所尝试的描述，以及图表，只有本身已经理解了的人才能看得懂。我将试着给出一个最简单的说明，而对其有更多兴趣的读者可以从网上查找更多信息。
每当一个子例程被调用，都有一个“栈帧”被建立，这是用来保存变量，以及其他子例程局部信息的区域。于是，当你调用 ping() ，则有一个栈帧被建立，来保存这次调用相关的信息。简言之，这个帧记载着 ping 被调用了。当再调用 pong() ，则又建立了一个栈帧，记载着 pong 也被调用了。这些栈帧是串联在一起的，每个子例程调用都是其中的一环。就这样，堆栈中显示： ping 被调用所以 pong 接下来被调用。显然，当 pong() 再调用 ping() ，则使堆栈再扩展。下面是个直观的表示：
帧 堆栈
1 ping 被调用
2 ping 被调用，所以 pong 被调用
3 ping 被调用，所以 pong 被调用，所以 ping 被调用
4 ping 被调用，所以 pong 被调用，所以 ping 被调用，所以 pong 被调用
5 ping 被调用，所以 pong 被调用，所以 ping 被调用，所以 pong 被调用，所以 ping 被调用
6 ping 被调用，所以 pong 被调用，所以 ping 被调用，所以 pong 被调用，所以 ping 被调用……
现在假设，这个页面的宽度就表示系统为堆栈所分配的全部内存空间，当其顶到页面的边缘的时候，将会发生溢出，系统内存耗尽，即术语“堆栈溢出”。
3.1.2 那么，为什么要使用堆栈？
上例是有意设计的，用来体现堆栈的问题所在。在大多数情况下，当每个子例程返回的时候，其栈帧将被清除掉，就是说堆栈将会自行实现清理过程。这一般 来说是件好事，在C语言中，堆栈就是一个不需要编程者来手动进行内存管理的区域。很幸运，Python程序员也不需要直接来担心内存管理与堆栈。但是由于 Python解释器本身也是用C实现的，那些实现者们可是需要担心这个的。使用堆栈是会使事情方便，除非我们开始调用那种从不返回的函数，如上例中的，那 时候，堆栈的表现就开始和程序员别扭起来，并耗尽可用的内存。
3.2 走进协程
此时，将堆栈弄溢出是有点愚蠢的。 ping() 和 pong() 本不是真正意义的子例程，因为其中哪个也不从属于另一个，它们是“协程”，处于同等的地位，并可以彼此间进行无缝通信。
帧 堆栈
1 ping 被调用
2 pong 被调用
3 ping 被调用
4 pong 被调用
5 ping 被调用
6 pong 被调用
在stackless中，我们使用通道来建立协程。还记得吗，通道所带来的两个好处中的一个，就是能够控制微进程之间运行的流程。使用通道，我们可以在 ping 和 pong 这两个协程之间自由来回，要多少次就多少次，都不会堆栈溢出:
你可以运行这个程序要多久有多久，它都不会崩溃，且如果你检查其内存使用量（使用Windows的任务管理器或Linux的top命令），将会发现 使用量是恒定的。这个程序的协程版本，不管运行一分钟还是一天，使用的内存都是一样的。而如果你检查原先那个递归版本的内存用量，则会发现其迅速增长，直 到崩溃。
3.3 总结
是否还记得，先前我提到过，那个代码的递归版本，有经验的程序员会一眼看出毛病。但老实说，这里面并没有什么“计算机科学”方面的原因在阻碍它的正 常工作，有些让人坚信的东西，其实只是个与实现细节有关的小问题——只因为大多数传统编程语言都使用堆栈。某种意义上说，有经验的程序员都是被洗了脑，从 而相信这是个可以接受的问题。而stackless，则真正察觉了这个问题，并除掉了它。
4 轻量级线程
与当今的操作系统中内建的、和标准Python代码中所支持的普通线程相比，“微线程”要更为轻量级，正如其名称所暗示。它比传统线程占用更少的内存，并且微线程之间的切换，要比传统线程之间的切换更加节省资源。
为了准确说明微线程的效率究竟比传统线程高多少，我们用两者来写同一个程序。
4.1 hackysack模拟
Hackysack是一种游戏，就是一伙脏乎乎的小子围成一个圈，来回踢一个装满了豆粒的沙包，目标是不让这个沙包落地，当传球给别人的时候，可以耍各种把戏。踢沙包只可以用脚。
在我们的简易模拟中，我们假设一旦游戏开始，圈里人数就是恒定的，并且每个人都是如此厉害，以至于如果允许的话，这个游戏可以永远停不下来。
4.2 游戏的传统线程版本