stacklesspython教程_python開發環境有哪些

A. 好學編程：好用的python解釋器有哪些這幾款值得下載

Python作為一門廣受歡迎的編程語言，其執行依賴於解釋器。本文將介紹幾種好用的Python解釋器，幫助你找到適合下載的版本。

Python解釋器詳解

Python代碼首先由解釋器讀取，經過詞法分析、解析、編譯和解釋等步驟，最終轉化為CPU可執行的指令。理解不同解釋器的作用對於優化程序性能至關重要。

1. CPython

作為Python的官方實現，CPython是用C語言編寫的，支持C擴展，適合跨平台使用，但更注重優化而非速度。

2. Pyston

Pyston是CPython的一個性能優化版本，旨在提高大型應用的運行速度，但需要重新編譯。

3. PyPy

PyPy是基於RPython的即時編譯器，能生成CPU直接執行的機器碼，適合長時間運行的程序，但C擴展支持有限。

4. RustPython

RustPython用Rust編寫，支持WebAssembly，可在瀏覽器中運行，且有JIT編譯器選項。

5. Stackless Python

Stackless Python增強了CPython，支持微線程和通道，適用於需要並行任務的場景。

6. Micro Python

MicroPython適合嵌入式設備，內存和存儲需求極低，但標准庫較簡。

性能評估

不同解釋器在性能上有所差異，適合的解釋器取決於任務需求。你可以通過像http://pybenchmarks.org這樣的網站進行對比。還有Nuitka這樣的工具能將Python代碼編譯成機器碼。

結論

Python因其易學性和實用性廣受歡迎。嘗試不同解釋器，尤其是對性能有高要求或特定平台使用時，將有助於提升開發效率。好學編程將持續分享更多編程知識，期待你的關注。

B. 如何看待Java綠色線程的相關應用效果

Java綠色線程到底是一個怎麼回事呢？這些問題需要我們從本質中看問題。下面我們就來看看Java綠色線程（Green Thread）是一個相對於操作系統線程（Native Thread）的概念。

操作系統線程（Native Thread）的意思就是，程序裡面的線程會真正映射到操作系統的線程，線程的運行和調度都是由操作系統控制的

Java綠色線程（Green Thread）的意思是，程序裡面的線程不會真正映射到操作系統的線程，而是由語言運行平台自身來調度。

當前版本的Python語言的線程就可以映射到操作系統線程。當前版本的Ruby語言的線程就屬於綠色線程，無法映射到操作系統的線程，因此Ruby語言的線程的運行速度比較慢。

Java線程同步如何才能排除阻塞
Java線程函數關鍵代碼詳細講述
Java線程同步引用基本代碼介紹
Java線程式控制制權源代碼的深入探討
Java線程同步問題在實踐中尋找答案

難道說，Java綠色線程要比操作系統線程要慢嗎？當然不是這樣。事實上，情況可能正好相反。Ruby是一個特殊的例子。線程調度器並不是很成熟。

目前，線程的流行實現模型就是Java綠色線程。比如，stackless Python，就引入了更加輕量的綠色線程概念。在線程並發編程方面，無論是運行速度還是並發負載上，都優於Python 。

另一個更著名的例子就是ErLang（愛立信公司開發的一種開源語言）。

ErLang的Java綠色線程概念非常徹底。ErLang的線程不叫Thread，而是叫做Process 。這很容易和進程混淆起來。這里要注意區分一下。

ErLang Process之間根本就不需要同步。因為ErLang語言的所有變數都是final的，不允許變數的值發生任何變化。因此根本就不需要同步。

final變數的另一個好處就是，對象之間不可能出現交叉引用，不可能構成一種環狀的關聯，對象之間的關聯都是單向的，樹狀的。因此，內存垃圾回收的演算法效率也非常高。這就讓ErLang能夠達到Soft
Real Time（軟實時）的效果。這對於一門支持內存垃圾回收的語言來說，可不是一件容易的事情。

C. python開發環境有哪些

PythonIDE工具是每個Python工程師必須使用的開發工具，選擇正確的編輯器對Python編程效率的影響是非常大的，因此選擇合適的Python開發工具十分重要，以下是通過長期實踐發掘的好用的Python IDE，它們功能豐富，性能先進，能夠幫助開發人員快速的進行應用程序開發。

1. Pydev + Eclipse – 最好的免費python IDEPydev的是Python IDE中使用最普遍的，原因很簡單，它是免費的，同時還提供很多強大的功能來支持高效的Python編程。Pydev是一個運行在eclipse上的開源插件，它把python帶進了eclipse的王國，如果你本來就是是一個eclipse的用戶那麼Pydev將給你家裡一樣的感覺。Pydev能高居榜首，得益於這些關鍵功能，包括Django集成、自動代碼補全、多語言支持、集成的Python調試、代碼分析、代碼模板、智能縮進、括弧匹配、錯誤標記、源代碼控制集成、代碼折疊、UML編輯和查看和單元測試整合等。雖然Pydev是最好的開源python IDE，但是它也和另一個名為Liclipse的產品一起打包，Liclipse是一個商業產品，同樣也構建在eclipse上，提供了易用性改進和額外的主題選項。除了python，Pydev也支持Jython and IronPython。2. PyCharm – 最好的商業python IDEPyCharm是專業的python集成開發環境，有兩個版本。一個是免費的社區版本，另一個是面向企業開發者的更先進的專業版本。大部分的功能在免費版本中都是可用的，包括智能代碼補全、直觀的項目導航、錯誤檢查和修復、遵循PEP8規范的代碼質量檢查、智能重構，圖形化的調試器和運行器。它還能與IPythonnotebook進行集成，並支持Anaconda及其他的科學計算包，比如matplotlib和NumPy。PyCharm專業版本支持更多高級的功能，比如遠程開發功能、資料庫支持以及對web開發框架的支持等。

3. VIM

VIM是一個很先進的文本編輯器，在python開發者社區中很受歡迎。它是一個開源軟體並遵循GPL協議，所以你可以免費的使用它。

雖然VIM是最好的文本編輯器，但是它提供的功能不亞於此，經過正確的配置後它可以成為一個全功能的Python開發環境。此外VIM還是一個輕量級的、模塊化、快速響應的工具，非常適合那些很牛的程序員——編程從不用滑鼠的人。

初始化配置需要花一定時間，因為你需要安裝些VIM的插件，並配置讓他們正常工作，最後你會發現這一切都是值得努力的。如果你在尋找一個linux系統下的python IDE，那麼VIM將是你的不二選擇。

4. Wing IDE

WingIDE是另外一個商業的、面向專業開發人員的python集成開發環境，可以運行在windows、OS X和Linux系統上，支持最新版本的python，包括stackless Python（python的增強版）。Wing IDE分三個版本：免費的基礎版，個人版，以及更強大的專業版。

調試功能是Wing IDE的一大亮點，包括多線程調試，線程代碼調試，自動子進程調試，斷點，單步代碼調試，代碼數據檢查等功能，此外還提供了在樹莓派上進行遠程調試的功能。

在代碼管理方面，Wing IDE能非常靈活的與Git、subversion、perforce、cvs、Bazaar、Mercurial等工具集成。

此外，Wing IDE也支持其他更多的python框架，比如Maya、MotionBbuilder、Zope、PyQt、PySide、pyGTK、PySide、Django、matplotlib等等。

5. Spyder Python

SpyderPython是一個開源的python集成開發環境，非常適合用來進行科學計算方面的python開發。是一個輕量級的軟體，是用python開發的，遵循MIT協議，可免費使用。

Spyderpython的基本功能包括多語言編輯器、互動式控制台、文件查看、variable explorer、文件查找、文件管理等。Spyder IDE也可以運行於windows、Mac 或者 Linux系統之上。

雖然Spyder是一個獨立的集成開發環境，能運行在windows、MacOS 、MacOS X、Linux等系統之上。但是它也可以作為PyQT的擴展庫，可以嵌入到PyQT的應用中去。

6. Komodo IDE

Komodo是Activestate公司開發的一個跨平台的集成開發環境，支持多種語言包括python。它是商用產品，但是提供了開源的免費版本叫Komodo Edit，能夠安裝在Mac、Windows 和Linux系統上。

全功能的Komodo對教育機構用戶是免費的，老師和教授可以將其應用於實驗室及教學中。學生也可以通過較低的費用得到Komodo的授權許可。

D. 下載安裝python(x,y)後，點擊spyder就跳出一個終端，終端消失後就沒反應了

應該是python版本混亂了吧。
如果安裝了兩個python版本，PATH里只能添加一個，作為默認python使用，另一個只能通過全路徑調用。
如果spyder只支持python2，你可以把python2作為默認的python，也就是把python2.7的路徑添加到PATH里。而要使用stackless的時候，在cmd中輸入完整的python路徑，比如：
d://python3/bin/python

E. Python是什麼

1、Python 介紹

學習一門新的語言之前，首先簡單了解下這門語言的背景。Python 是一種面向對象的解釋型計算機程序設計語言，由荷蘭人 Guido van Rossum 於 1989 年發明，第一個公開發行版發行於 1991 年。Python 在設計上堅持了清晰劃一的風格，這使得 Python 成為一門易讀、易維護，並且被大量用戶所歡迎的、用途廣泛的語言。Python 具有豐富和強大的庫。它常被昵稱為膠水語言，能夠把用其他語言製作的各種模塊(尤其是 C/C++)很輕松地聯結在一起。

2、Python 技術浪潮

IT行業熱門技術，更新換代非常的快，技術的浪潮一波接著一波，最初的浪潮無疑是桌面時代，使用 C# 搭建桌面應用開始嶄露頭角，MFC 還是計算機科學專業必學會的東西。接著就是以網站搭建為應用的背景，PHP，Ruby 等語言為主的。再到近幾年非常火熱的以移動開發為應用背景，Java(Android 開發)或者 OC(iOS 開發)語言為主。很明顯如今的浪潮就是以大數據和機器學習為應用背景，Python 語言為主。站在風尖浪口，豬都可以飛的起來。抓住這波技術浪潮，對於從事 IT 行業的人員來說有莫大的幫助。

3、Python 學習

學習一項新的技術，起步時最重要的是什麼?就是快速入門。學習任何一個學科的知識時，都有一個非常重要的概念：最少必要知識。當需要獲得某項技能的時候，一定要想辦法在最短的時間里弄清楚都有哪些最少必要知識，然後迅速掌握它們。

對於快速入門 python 來說最少必要知識，有以下幾點。

(1) Python 基礎語法

找一本淺顯易懂，例子比較好的教程，從頭到尾看下去。不要看很多本，專注於一本。把裡面的常式都手打一遍，搞懂為什麼。推薦去看《簡明python教程》，非常好的一本 Python 入門書籍。

(2)Python 實際項目

等你對 Python 的語法有了初步的認識，就可以去找些 Python 實際項目來練習。對於任何計算機編程語言來說，以實際項目為出發點，來學習新的技術，是非常高效的學習方式。在練習的過程中你會遇到各種各樣的問題：基礎的語法問題(關鍵字不懂的拼寫)，代碼毫無邏輯，自己的思路無法用代碼表達出來等等。這時候針對出現的問題，找到對應解決辦法，比如，你可以重新查看書本上的知識(關於基礎語法問題)，可以通過谷歌搜索碰到的編譯錯誤(編輯器提示的錯誤)，學習模仿別人已有的代碼(寫不出代碼)等等。已實際項目來驅動學習，會讓你成長非常的快。Python 實際項目網上非常的多，大家可以自己去搜索下。合理利用網路資源，不要意味的只做伸手黨。

(3) Python 的學習規劃

當你把上面兩點做好以後，你就已經入門了 Python，接下來就是規劃好自己的以後的學習規劃。能找到一個已經會 Python 的人。問他一點學習規劃的建議，然後在遇到卡殼的地方找他指點。這樣會事半功倍。但是，要學會搜索，學會如何更好地提問，沒人會願意回答顯而易見的問題。當然如果你身邊沒有人會 Python，也可以在網上搜索相應的資料。

Python 可以做的事非常的多，比如：Python 可以做日常任務，比如自動備份你的MP3;可以做網站，很多著名的網站像知乎、YouTube 就是 Python 寫的;可以做網路游戲的後台，很多在線游戲的後台都是 Python 開發的。每個人都有自己感興趣的方向，有的對網站開發比較感興趣，有的對數據處理感興趣，有的對後台感興趣。所以你們可以根據自己感興趣的方向，網上搜索相關資料，加以深入的學習，規劃好自己未來的方向。只要堅持，你就能精通 Python，成為未來搶手的人才。

F. python stackless 怎麼多線程並發

1 介紹

1.1 為什麼要使用Stackless

摘自stackless網站。

Note

Stackless Python 是Python編程語言的一個增強版本，它使程序員從基於線程的編程方式中獲得好處，並避免傳統線程所帶來的性能與復雜度問題。Stackless為 Python帶來的微線程擴展，是一種低開銷、輕量級的便利工具，如果使用得當，可以獲益如下：

改進程序結構
增進代碼可讀性
提高編程人員生產力

以上是Stackless Python很簡明的釋義，但其對我們意義何在？——就在於Stackless提供的並發建模工具，比目前其它大多數傳統編程語言所提供的，都更加易用：不僅是Python自身，也包括Java、C++，以及其它。盡管還有其他一些語言提供並發特性，可它們要麼是主要用於學術研究的（如 Mozart/Oz），要麼是罕為使用、或用於特殊目的的專業語言（如Erlang）。而使用stackless，你將會在Python本身的所有優勢之上，在一個（但願）你已經很熟悉的環境中，再獲得並發的特性。

這自然引出了個問題：為什麼要並發？

1.1.1 現實世界就是並發的

現實世界就是「並發」的，它是由一群事物（或「演員」）所組成，而這些事物以一種對彼此所知有限的、鬆散耦合的方式相互作用。傳說中面向對象編程有一個好處，就是對象能夠對現實的世界進行模擬。這在一定程度上是正確的，面向對象編程很好地模擬了對象個體，但對於這些對象個體之間的交互，卻無法以一種理想的方式來表現。例如，如下代碼實例，有什麼問題？

def familyTacoNight():

husband.eat(dinner)

wife.eat(dinner)

son.eat(dinner)

daughter.eat(dinner)

第一印象，沒問題。但是，上例中存在一個微妙的安排：所有事件是次序發生的，即：直到丈夫吃完飯，妻子才開始吃；兒子則一直等到母親吃完才吃；而女兒則是最後一個。在現實世界中，哪怕是丈夫還堵車在路上，妻子、兒子和女兒仍然可以該吃就吃，而要在上例中的話，他們只能餓死了——甚至更糟：永遠沒有人會知道這件事，因為他們永遠不會有機會拋出一個異常來通知這個世界！

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可調用對象（通常為函數或類的方法）來建立它，這將建立一個微進程並將其添加到調度器。這是一個快速演示:

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

three

注意，微進程將排起隊來，並不運行，直到調用stackless.run()。

2.2 調度器(scheler)

調度器控制各個微進程運行的順序。如果剛剛建立了一組微進程，它們將按照建立的順序來執行。在現實中，一般會建立一組可以再次被調度的微進程，好讓每個都有輪次機會。一個快速演示:

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

注意：當調用stackless.schele()的時候，當前活動微進程將暫停執行，並將自身重新插入到調度器隊列的末尾，好讓下一個微進程被執行。一旦在它前面的所有其他微進程都運行過了，它將從上次停止的地方繼續開始運行。這個過程會持續，直到所有的活動微進程都完成了運行過程。這就是使用stackless達到合作式多任務的方式。

2.3 通道(channel)

通道使得微進程之間的信息傳遞成為可能。它做到了兩件事：

能夠在微進程之間交換信息。
能夠控制運行的流程。

又一個快速演示:

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

接收的微進程調用channel.receive()的時候，便阻塞住，這意味著該微進程暫停執行，直到有信息從這個通道送過來。除了往這個通道發送信息以外，沒有其他任何方式可以讓這個微進程恢復運行。

若有其他微進程向這個通道發送了信息，則不管當前的調度到了哪裡，這個接收的微進程都立即恢復執行；而發送信息的微進程則被轉移到調度列表的末尾，就像調用了stackless.schele()一樣。

同樣注意，發送信息的時候，若當時沒有微進程正在這個通道上接收，也會使當前微進程阻塞:

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

發送信息的微進程，只有在成功地將數據發送到了另一個微進程之後，才會重新被插入到調度器中。

2.4 總結

以上涵蓋了stackless的大部分功能。似乎不多是吧？——我們只使用了少許對象，和大約四五個函數調用，來進行操作。但是，使用這種簡單的API作為基本建造單元，我們可以開始做一些真正有趣的事情。

3 協程(coroutine)

3.1 子常式的問題

大多數傳統編程語言具有子常式的概念。一個子常式被另一個常式（可能還是其它某個常式的子常式）所調用，或返回一個結果，或不返回結果。從定義上說，一個子常式是從屬於其調用者的。

見下例:

def ping():

print "PING"

pong()

def pong():

print "PONG"

ping()

ping()

有經驗的編程者會看到這個程序的問題所在：它導致了堆棧溢出。如果運行這個程序，它將顯示一大堆討厭的跟蹤信息，來指出堆棧空間已經耗盡。

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 這兩個協程之間自由來回，要多少次就多少次，都不會堆棧溢出:

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

你可以運行這個程序要多久有多久，它都不會崩潰，且如果你檢查其內存使用量（使用Windows的任務管理器或Linux的top命令），將會發現使用量是恆定的。這個程序的協程版本，不管運行一分鍾還是一天，使用的內存都是一樣的。而如果你檢查原先那個遞歸版本的內存用量，則會發現其迅速增長，直到崩潰。

3.3 總結

是否還記得，先前我提到過，那個代碼的遞歸版本，有經驗的程序員會一眼看出毛病。但老實說，這裡面並沒有什麼「計算機科學」方面的原因在阻礙它的正常工作，有些讓人堅信的東西，其實只是個與實現細節有關的小問題——只因為大多數傳統編程語言都使用堆棧。某種意義上說，有經驗的程序員都是被洗了腦，從而相信這是個可以接受的問題。而stackless，則真正察覺了這個問題，並除掉了它。

4 輕量級線程

與當今的操作系統中內建的、和標准Python代碼中所支持的普通線程相比，「微線程」要更為輕量級，正如其名稱所暗示。它比傳統線程佔用更少的內存，並且微線程之間的切換，要比傳統線程之間的切換更加節省資源。

為了准確說明微線程的效率究竟比傳統線程高多少，我們用兩者來寫同一個程序。

4.1 hackysack模擬

Hackysack是一種游戲，就是一夥臟乎乎的小子圍成一個圈，來回踢一個裝滿了豆粒的沙包，目標是不讓這個沙包落地，當傳球給別人的時候，可以耍各種把戲。踢沙包只可以用腳。

在我們的簡易模擬中，我們假設一旦游戲開始，圈裡人數就是恆定的，並且每個人都是如此厲害，以至於如果允許的話，這個游戲可以永遠停不下來。

4.2 游戲的傳統線程版本

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

導航:首頁 > 編程語言 > stacklesspython教程

stacklesspython教程

Python解釋器詳解

與stacklesspython教程相關的資料