協程中提到的非同步指的是兩個函式一起執行，各個函式執行到哪裡cpu會中斷是不一定的。

---------------------------------------------------------------------------------------

協程能執行成百上千個

協程就是併發的一種
併發不是並行,一個協程被阻塞，換其他協程繼續上
等待一個結束另一個在啟動的都是單執行緒
雖然不用gevent（畢竟python有自帶asyncio）不過非同步concurrent的原理都差不多
gevent應該是隻有一個event loop再跑。然後切換的是任務gevent做了monkey patch（例如python2沒有async sleep這類的支援）
gevent做了monkey patch（例如python2沒有async sleep這類的支援）
至於系統看到的執行緒。那個一直都只有一個。因為python執行緒是自己做。不是os。所以系統執行緒數量跟gevent無關（如果看python自己提供的thread count。看到的是一個）
gevent，greenlet跟asyncio這些是指給你（使用者）決定什麼時候切換。而執行緒則是python的runtime自己做。並且執行緒需要stack。這類的非同步task則不用
cpu並行你無論開多少個執行緒實際上都只有一個執行緒在跑
多程序：很吃cpu的程式碼
io密集 訪問網站，
CPU密集 大量計算的
多執行緒：io等待。但是同時執行執行緒在百來個之內（小1-2千也可以，看具體）
協程是什麼密集的呢？
非同步io（async）io等待。可以做上萬task“同時”
python3的話。自己有帶asyncio模組。就不用去使用第三方庫完成。python2的話。還是要gevent，greenlet，stackless這類的去實現
跑的是一個”event loop”
go不同。go自身的concurrent就是go routine
go routine 設計上就是asyncio這樣的（go自身實現的）
所以go很簡單： go 函式 就可以了
大多數情況下：多程序+多執行緒/非同步Io（協程）就夠了
換個說法：如果你需要多程序+多執行緒或者非同步。那麼一般來說。你不用問這些問題的。如果你問這些問題。說明你並不需要用那樣的架構
python的程序並不能直接設定cpu affinity。所以是否一個程序一個core沒法保證的
如果是linux系統。可以通過cgroups外圍形式來設定（開啟程序後。在os設定這個程序跑哪個core）
其他系統不知道。core的分配要看os、
程序是否保持跟core一致還是多還是少是根據你需要而定的
多程序也不一定都是跟運算有關
程序是獨立的。換句話說。一個程序掛了，其他的程序不影響。主程序不影響
所以設計的時候。也有些是為了穩定而採用多程序的
例如你跑一個服務。你是要長期跑的。你擔心有記憶體洩漏，擔心服務異常終止等待。那麼一般就是主程式fork自程序初開。主程序做為watchdog。守護你的自程序（並且負責重啟等等）
100個建議你直接thread吧
1000個的話。根據需要可能選擇攜程或者執行緒。100個基本不用想。直接thread多簡單（非同步程式碼會麻煩的多。尤其是異常處理部分，跟callback帶callback帶callback）




那如果程式碼中多個“子程序”的話，特定的一個協程有可能在不同的時間間隔被不同的子程序來處理嗎？
不會。


也就是說，程式碼設計的時候，某一個協程一定是“歸屬於”特定的程序來執行其返回的結果的
除非你自己做一個scheduler。把你的執行緒/攜程移到另外一個程序裡面（我不確定是否能真的做出來。不過簡單的demo應該可以）






程序就好像你的一個python指令碼 你可以寫兩個檔案。執行python 檔名。然後兩個檔案內的程式碼隨機跑在某個python（這裡指的是終端上執行的python pid）上嗎？
通訊是資訊傳遞。執行就不是資訊了。並不是說你把執行緒/攜程直接pickle起來另外一個程序直接unpack讀回去就可以
我建議你可以找找程序跟執行緒的基礎書看看。那個會講的比較全面。也比較正確
看過程序執行緒之後。可以看看非同步IO的東西。因為看過之後你大概就有個概念了。你可以看成：python的thread其實就是python自身維護了一個“thread-loop”
隨意python才有執行緒不能跨核的問題。因為系統（os）看到的只有一個執行緒而已
python在這個thread-loop中切換在不同的“thread”裡面。你使用。就有了“執行緒”的感覺了




但是python的這個thread-loop是你沒法控制的（什麼時候等待，什麼時候切換）等等。這些都是python自身在執行的時候決定
每個程式（其實嚴格的說包括程序）核心看到的都是個“執行緒”
例如c++你開10個執行緒。os看到的就是10個執行緒。所以os可以幫你放在不同cpu執行（效率）
因為c++直接用pthread來做。而python的話。os能看到的只是“python”自身。跟你都沒關係。是你那個叫做python的指令




你的程式碼都是在“python”裡面。python來處理在做的。對於os來說。跟notepad沒有區別


但是python雖然不能直接給你pthread來做執行緒。但是在自身pyyhon中。也是用一樣的機制來架構執行緒的




我：
python的執行緒沒法跨核，所以被吐槽了
多執行緒是為了榨乾單獨一個核的效能
多程序是榨乾整個cpu的效能






所以你會有stack size，會有thread的各種屬性（用起來感覺跟執行緒一樣）
多執行緒一般不是為了吃cpu的（哥哥語言都是）主要是避免一些緩慢的等待。例如IO（硬碟讀區。網路讀取等等）
如果吃cpu。單執行緒單程序。鎖定core（這樣os不會幫你跳去其他core）可以把一個core的資源吃光






而非同步（asyncio）跟執行緒最大的區別是。你自己決定。什麼時候把使用權給出去
例如你一個程式碼有5行。跑執行緒。你不知道在哪行。python就決定。你這個執行緒使用的cpu夠了。換下一個來
所以這五行中任意一行。都可能做為thread的切換點
asyncio則是把loop交給你（使用者）手裡了
你可以決定。我這5行程式碼。只有執行到第三行的時候。才會切換出去
這樣。你1運行了1一定會執行2然後才出去
2.x沒有內建的非同步。一般用gevent，greenlet，stackless這類的做
因為你自己做的event，你並沒有stack
不像thread。python需要一個標準的stack（記得最小32k）
所以你的效能會好很多。同時，你只有“收到切換”的時候才會切換。就不需要thread那麼複雜的scheduler來管理。一般來說。一個系統開1-2千個thread就差不多了。你可以花點功夫。做5-6千個（可以開啟，可以跑。但是效能就很不好了）而asyncio做event loop的話。可以輕鬆做上萬
python中比較出名的兩個：twisted 跟 tornado


看了下文件。是32k。沒記錯
threading.stack_size([size])
Return the thread stack size used when creating new threads. The optional size argument specifies the stack size to be used for subsequently created threads, and must be 0 (use platform or configured default) or a positive integer value of at least 32,768 (32 KiB). I
threading模組文件
tornado是web服務。是“效能比較好”的web服務
效能的來源就在於他們是用asyncio來做的。而不是thread
所以也有很多人。拿tornado程式碼過來。並不是跑服務。import之後。就用他們的async部分庫（python2自己是沒有asyncio的）
twisted的async庫有點類似node.js。是以defer這樣的形式來做
node.js之所以效能好。因為人家是async架構
go之所以很多人喜歡。也是因為是async架構（另外使用比較簡單）
python之所以很多人吐槽。不就是GIL（thread不能跨核）跟沒有非同步嘛
python3帶了asyncio。甚至event loop都允許掛自己的（或者第三方）
uvloop這個專案。至少他們自稱（自己公佈的）測試資料。python3自帶的asyncio+uvloop可以達到基本接近go的效能（簡單的非同步處理）
雖然說不可全信。而且實際應用的話程式碼會複雜很多，不可能保持那個效能。但是已經是很厲害了
GIl很好拆除呀
網上很多教程的
好想就3-5行程式碼。註釋掉就好了
不過為什麼要移除呢？
你真的需要誇核。直接用cython就好了。可以直接lift gil的
如果你程式架構沒錯（python屬於高階語言，很多東西做起來很簡單）gil不是問題
不用混編。不過允許你把python直接編譯成二進位制可執行。允許你混編
另外python不是有芹菜嘛
其實就算python自己帶的multiprocessing模組。manager也是可以跨越機器的
有幾個語言自帶的庫。可以讓我寫程式碼直接分散到幾百個電腦去的？
所以gil其實沒什麼好抱怨的
業餘中大多數情況下：多執行緒優越於非同步IO
就好像組合語言效能好。也沒說人人都在用
就是非專業很多人自己理解力有限
寫出來的東西穩定，效能什麼的就都有限
省事的多的多多多的多了
寫程式碼不是你看部落格看書例子那麼簡單的
另外一個也算在這個範圍的東西。就是event driven了
例如python的select模組
select，pool，epool，kqueue這些
select跟pool應該是各個平臺都有支援。epoll只有linux有kqueue只有bsd
unix好像還有一個什麼。不記得了。文件應該有寫


https://docs.python.org/3/library/select.html
這個python2根3都支援




不過3支援一個新的selectors很好用。這個自動使用select下面的最適合你當前os的方法
也就是說。不用自己寫程式碼分別區分處理linux，osx，windows的區別
例如select.epool或者kqueue也是可以直接單執行緒上輕鬆10k連結的東西
select.select是比較老的。有1024的file descriptor的限制


但是我概念上就不理解，如果程式碼本身已經寫成多程序，那麼flask中的這個多程序選項processes=N是不是就沒用了呢？？？


我就用過一次flask（一共就一天時間。為了寫個rest server）
run(host=None, port=None, debug=None, **options)
options – the options to be forwarded to the underlying Werkzeug server. See werkzeug.serving.run_simple() for more information.
所以還不是flask直接用的
我不是做開發的。就寫過那麼一次web
processes – if greater than 1 then handle each request in a new process up to this maximum number of concurrent processes.
http://werkzeug.pocoo.org/docs/0.14/serving/#werkzeug.serving.run_simple
等於你的route是丟進一個process pool裡面的
run的時候process設定的是你的pool的大小




你開pool的話 不執行開始的時候就init了
然後東西都給pool中空閒的資源去處理
處理完了就處理下一個
可以看multiprocessing中的pool那段
flask是做上層的。下面處理http自身的是另外的程式碼
flask是邏輯
http自身的request是後面的另外那個用。所以process是丟到那邊去的




不能直觀看到協程  內部有協程佇列儲存協程狀態




總結下：系統只能看到python的主執行緒，看不到python開的子執行緒
協程歸程序來管，執行緒不能跨核，協程也不能。










大佬 22:07:33
因為我們公司開發比我厲害的太多了
大佬 22:07:57
我這種水平（甚至測試裡面很多比我好的）都還不夠開發的標準
大佬 22:09:37
你看flask官網的第一句話：Flask is a microframework for Python based on Werkzeug, 
大佬 22:10:03
run裡面的process是直接傳給werkzeug的
大佬 22:10:55
看文件介紹。感覺就是個pool設定process的數量。具體的實際情況。翻一下werkzeug程式碼就知道了
太古時代的小鯉魚 22:13:23
好的，謝謝您~
太古時代的小鯉魚 22:13:32
我正在整理記錄您的話~




好奇，就看了一下flask的run裡面的processes這個引數


大佬 22:33:36
flask的run是把引數直接傳遞給 
werkzeug.serving.run_simple 
run_simple用這個引數叫了make_serve
make_server說 ：
elif processes > 1: 
    return ForkingWSGIServer(host, port, app, processes, request_handler, passthrough_errors, ssl_context, fd=fd)


所以這個引數又給了ForkingWSGIServer


ForkingWSGIServer繼承了兩個class
werkzeug.serving： https://github.com/pallets/werkzeug/blob/master/werkzeug/serving.py


大佬 22:33:43
ForkingWSGIServer(ForkingMixIn, BaseWSGIServer)
    self.max_children = processes
大佬 22:34:03
ForkingMixIn又是什麼？
if can_fork:
    ForkingMixIn = socketserver.ForkingMixIn
else:
    class ForkingMixIn(object):
        pass


大佬 22:34:16
搞了半天是跳去了python內建的socketserver.ForkingMixin了


大佬 22:34:38
回到python內建部分（socketserver是python自帶的）
https://github.com/python/cpython/blob/master/Lib/socketserver.py




大佬 22:34:47
class ForkingMixIn:
        """Mix-in class to handle each request in a new process."""
        timeout = 300
        active_children = None
        max_children = 40


大佬 22:34:53
while len(self.active_children) >= self.max_children: 
    try:
        pid, _ = os.waitpid(-1, 0)
        self.active_children.discard(pid)
    except ChildProcessError:
        # we don't have any children, we're done
        self.active_children.clear()
        except OSError:
            break


大佬 22:35:20
就是直接os.fork出去的子程序做處理


大佬 22:35:30
看完了，就沒什麼神祕的了


大佬 22:36:40
def process_request(self, request, client_address):
            """Fork a new subprocess to process the request."""
            pid = os.fork()
            if pid:


大佬 22:37:03
所以就是在處理請求的時候，建立一個新的程序來處理


大佬 22:37:42
直到達到了你給的最大數字


大佬 22:38:01
python自己內定的是開40個程序


大佬 22:38:28
不算是proess pool，因為pool是把process開起來了之後，丟task過去。這個是task來了，再開


大佬 22:38:38
你平時不怎麼看程式碼的關係吧


太古時代的小鯉魚 22:39:14
是的，直接拿來用了
太古時代的小鯉魚 22:39:33
 
大佬 22:40:12
你上班平時不用第三方庫？


太古時代的小鯉魚 22:40:52
分不清哪個是第三方庫~


太古時代的小鯉魚 22:40:55
都沒太在意


太古時代的小鯉魚 22:41:03
雖然上次有人說過一次




就是你import的東西不是python自帶的


太古時代的小鯉魚 22:41:13
但是依然沒有留下深刻的音箱
太古時代的小鯉魚 22:41:18
用啊




大佬 22:41:21
因為python自帶的都比較好，文件一定齊全
太古時代的小鯉魚 22:41:35
可是吧


大佬 22:41:35
如果是其他的，就很難說了，文件不好的時候，都是需要翻看原始碼的
太古時代的小鯉魚 22:41:44
原始碼這東西
太古時代的小鯉魚 22:41:51
沒註釋真的看起來挺煩的


大佬 22:42:20
不覺得，python的原始碼覺得真的很容易看


大佬 22:42:29
其他語言，沒有遇到比這個更容易看的
太古時代的小鯉魚 22:42:37
好吧，大神~ 


大佬 22:43:56
一般都是這樣的
太古時代的小鯉魚 22:44:08
   
大佬 22:44:17
第三方庫，有些可能基本沒有文件，註釋不怎麼寫（請問你寫程式碼會寫很多註釋給別人看嗎？）
太古時代的小鯉魚 22:44:31
我都寫蠻詳細的註釋


太古時代的小鯉魚 22:44:34
不過吧
太古時代的小鯉魚 22:44:36
沒人會看


太古時代的小鯉魚 22:44:41
因為只有我自己一個人寫


太古時代的小鯉魚 22:44:47
python


太古時代的小鯉魚 22:44:52
沒人會去改動他


太古時代的小鯉魚 22:44:57
所以。。。。也是蠻尷尬的


大佬 22:45:26
所以都是看程式碼。不過python程式碼規則比較嚴謹，一般一種東西也只有一兩個做法，所以很容易理解（不像ruby，如果用python的眼光看，那就是一堆monkey patch，簡直沒法看）
大佬 22:45:43
省事


大佬 22:46:03
不像我們整天都爭著搶提交


大佬：
設計模式
演算法
架構
大佬 23:22:14
程式碼架構
程式碼嚴謹程度
程式碼質量：不夠。如果寫個自己的服務，一般保證幾個星期連續執行沒有問題。幾個月或者一年的那種？不敢給任何保證（現在有個我寫的東西，還是平均幾個月就掛一次，我都不知道哪裡的問題）
大佬 23:24:45
知道的東西：少。畢竟不是做這個的。公司要求用狀態機，我才開始看什麼是狀態機。
公司要求用RX了（ReactiveX）我才看是學什麼是RX




try except可以防止掛嗎


大佬 23:36:10
try:
    xxxx
except Exception as error:
    yyy
這樣的程式碼可以後，一般整個專案只能有一個（總入口）用來處理所有的未知錯誤
太古時代的小鯉魚 23:36:48
不能一邊改一邊上線嗎？
太古時代的小鯉魚 23:37:02
感覺您那邊應該是屬於開發-測試流程很嚴謹的那種
太古時代的小鯉魚 23:37:14
我之前待的小公司直接改完bug沒怎麼測試就上了
太古時代的小鯉魚 23:37:19
雙擊檢視原圖
大佬 23:38:33
一般的程式碼寫法：
try:
    你要做的事情
except ValueError as error:
    處理 ValueError 
except IOError as error:
    處理 IOError
except OSError as error:
    處理 OSError
    raise #丟回上面的stack
except AttributeError as error:
    處理 AttributeError
    raise ApplicationError(error) #處理一個error，然後raise成其他的
大佬 23:40:07
我在外企
太古時代的小鯉魚 23:40:10
我的想法是：不能是出錯的直接跳過，先繼續跑後面的任務嗎
太古時代的小鯉魚 23:40:12
？
大佬 23:40:15
洋人要求比較多
太古時代的小鯉魚 23:40:18
我知道，您提過
大佬 23:40:27
例如程式碼沒有過系統的測試。都無法提交的
太古時代的小鯉魚 23:40:35
這樣。。。。
太古時代的小鯉魚 23:40:44
不容易
大佬 23:40:50
try的作用是“抓到你認為會出現的錯誤”
大佬 23:41:06
如果你try之後的except不寫原因。那麼很簡單，你自己都不知道你程式碼哪裡會錯
太古時代的小鯉魚 23:41:18
對啊
大佬 23:41:43
換句話說，自己寫的，自己都不懂的程式碼，那麼誰應該懂？誰應該看？
太古時代的小鯉魚 23:41:49
就這麼搞啊，如果我知道哪裡會出錯，我直接就改過來了呀，就不用try except了啊
太古時代的小鯉魚 23:41:50
可是
太古時代的小鯉魚 23:41:56
他們之前告訴我的是：
太古時代的小鯉魚 23:42:11
使用try except是在自己不知道哪裡會出錯的情況下使用的，他們強調說，防止掛掉
大佬 23:42:16
所以那種except拿到所有錯誤（Exception）的，一個專案只有最外面的那個大出口的 __name__ == '__main__' 下面可以出現一次
太古時代的小鯉魚 23:42:35
感覺您講的比他們說的嚴謹多了
大佬 23:42:40
如果你都不知道出的什麼錯？你怎麼防止掛掉？
大佬 23:42:45
你只是“希望”不會掛掉
太古時代的小鯉魚 23:42:46
直接pass
太古時代的小鯉魚 23:42:59
他們說，跑到except那裡，可以直接pass
太古時代的小鯉魚 23:43:10
繼續執行下一輪迴圈或者之後的程式碼
太古時代的小鯉魚 23:43:32
那也就是說：您那邊的程式碼都經過系統測試，不怕掛，那麼也就是不需要try except了？
23:44:01
你撤回了一條訊息
23:44:04
你撤回了一條訊息
大佬 23:44:05
例如系統給你一個MemoryError （因為你沒有足夠的記憶體了）難道pass系統就自動增加記憶體了？
大佬 23:44:27
需要很多的try except，但是是你自己知道的東西，自己要去處理
太古時代的小鯉魚 23:44:51
那想不到的error怎麼辦
太古時代的小鯉魚 23:45:06
那種想不到的會導致系統掛掉的error
太古時代的小鯉魚 23:45:26
之前群裡說用try except，聽您這麼一講，其實他們是在濫用了
大佬 23:45:42
例如我寫個function，接受一個變數，要求這個變數是 JSON 的字串，然後處理
太古時代的小鯉魚 23:46:25
我崩掉過，就是網路斷網了
太古時代的小鯉魚 23:46:31
直接崩掉
太古時代的小鯉魚 23:46:34
沒考慮到當時
太古時代的小鯉魚 23:47:19
您早點休息吧~改天我再請教您~
太古時代的小鯉魚 23:47:33
太晚了，真不好意思浪費您這麼多時間~
太古時代的小鯉魚 23:47:42
明天您還要上班呢~


大佬 23:25:20
這些很多的東西加在一起，就是說離開發還是很大的距離的。又何必為難自己去做開發呢？
太古時代的小鯉魚 23:32:07
不是說。。。
太古時代的小鯉魚 23:32:14
try except可以防止掛嗎
太古時代的小鯉魚 23:32:18
出問題可以繼續跑
太古時代的小鯉魚 23:32:33
設計模式我聽說web這塊用得比較多
太古時代的小鯉魚 23:32:40
但是面試官的gitlab我看了
太古時代的小鯉魚 23:32:46
他其實主要是java
太古時代的小鯉魚 23:32:53
python這塊他沒有用過設計模式
太古時代的小鯉魚 23:33:06
狀態機是離散數學裡的
太古時代的小鯉魚 23:33:14
其實我一開始接觸狀態機是在數字電路里的
太古時代的小鯉魚 23:33:53
程式碼架構我也不會
太古時代的小鯉魚 23:34:12
演算法的話，不去做AI，音訊和影象，那麼基本是用不到的吧
太古時代的小鯉魚 23:34:17
哎
太古時代的小鯉魚 23:34:19
早點休息
太古時代的小鯉魚 23:34:22
謝謝您了
太古時代的小鯉魚 23:34:25
受益匪淺~
大佬 23:36:10
try:
    xxxx
except Exception as error:
    yyy
這樣的程式碼可以後，一般整個專案只能有一個（總入口）用來處理所有的未知錯誤
太古時代的小鯉魚 23:36:48
不能一邊改一邊上線嗎？
太古時代的小鯉魚 23:37:02
感覺您那邊應該是屬於開發-測試流程很嚴謹的那種
太古時代的小鯉魚 23:37:14
我之前待的小公司直接改完bug沒怎麼測試就上了
太古時代的小鯉魚 23:37:19
 
大佬 23:38:33
一般的程式碼寫法：
try:
    你要做的事情
except ValueError as error:
    處理 ValueError 
except IOError as error:
    處理 IOError
except OSError as error:
    處理 OSError
    raise #丟回上面的stack
except AttributeError as error:
    處理 AttributeError
    raise ApplicationError(error) #處理一個error，然後raise成其他的
大佬 23:40:07
我在外企
太古時代的小鯉魚 23:40:10
我的想法是：不能是出錯的直接跳過，先繼續跑後面的任務嗎
太古時代的小鯉魚 23:40:12
？
大佬 23:40:15
洋人要求比較多
太古時代的小鯉魚 23:40:18
我知道，您提過
大佬 23:40:27
例如程式碼沒有過系統的測試。都無法提交的
太古時代的小鯉魚 23:40:35
這樣。。。。
太古時代的小鯉魚 23:40:44
不容易
大佬 23:40:50
try的作用是“抓到你認為會出現的錯誤”
大佬 23:41:06
如果你try之後的except不寫原因。那麼很簡單，你自己都不知道你程式碼哪裡會錯
太古時代的小鯉魚 23:41:18
對啊
大佬 23:41:43
換句話說，自己寫的，自己都不懂的程式碼，那麼誰應該懂？誰應該看？
太古時代的小鯉魚 23:41:49
就這麼搞啊，如果我知道哪裡會出錯，我直接就改過來了呀，就不用try except了啊
太古時代的小鯉魚 23:41:50
可是
太古時代的小鯉魚 23:41:56
他們之前告訴我的是：
太古時代的小鯉魚 23:42:11
使用try except是在自己不知道哪裡會出錯的情況下使用的，他們強調說，防止掛掉
大佬 23:42:16
所以那種except拿到所有錯誤（Exception）的，一個專案只有最外面的那個大出口的 __name__ == '__main__' 下面可以出現一次
太古時代的小鯉魚 23:42:35
感覺您講的比他們說的嚴謹多了
大佬 23:42:40
如果你都不知道出的什麼錯？你怎麼防止掛掉？
大佬 23:42:45
你只是“希望”不會掛掉
太古時代的小鯉魚 23:42:46
直接pass
太古時代的小鯉魚 23:42:59
他們說，跑到except那裡，可以直接pass
太古時代的小鯉魚 23:43:10
繼續執行下一輪迴圈或者之後的程式碼
太古時代的小鯉魚 23:43:32
那也就是說：您那邊的程式碼都經過系統測試，不怕掛，那麼也就是不需要try except了？
23:44:01你撤回了一條訊息
23:44:04你撤回了一條訊息
大佬 23:44:05
例如系統給你一個MemoryError （因為你沒有足夠的記憶體了）難道pass系統就自動增加記憶體了？
大佬 23:44:27
需要很多的try except，但是是你自己知道的東西，自己要去處理
太古時代的小鯉魚 23:44:51
那想不到的error怎麼辦
太古時代的小鯉魚 23:45:06
那種想不到的會導致系統掛掉的error
太古時代的小鯉魚 23:45:26
之前群裡說用try except，聽您這麼一講，其實他們是在濫用了
大佬 23:45:42
例如我寫個function，接受一個變數，要求這個變數是 JSON 的字串，然後處理




大佬 0:13:07
只好做OOM kill
大佬 0:13:14
程序？如果consumer掛了，不是程序了
大佬 0:13:14
是你整個OS都掛了
大佬 0:13:14
因為producer不停的在queue裡面丟東西，最後OS