Python三大“程”！線程，進程和協程詳解！這還學不會？不存在的

What is a Thread？

What is a Process？

進程與線程的區別？

1. 線程是執行的指令集，進程是資源的集合
2. 線程的啟動速度要比進程的啟動速度要快
3. 兩個線程的執行速度是一樣的
4. 進程與線程的運行速度是沒有可比性的
5. 線程共享創建它的進程的內存空間，進程的內存是獨立的。
6. 兩個線程共享的數據都是同一份數據，兩個子進程的數據不是共享的，而且數據是獨立的;
7. 同一個進程的線程之間可以直接交流，同一個主進程的多個子進程之間是不可以進行交流，如果兩個進程之間需要通信，就必須要通過一箇中間代理來實現;
8. 一個新的線程很容易被創建，一個新的進程創建需要對父進程進行一次克隆
9. 一個線程可以控制和操作同一個進程裡的其他線程，線程與線程之間沒有隸屬關係，但是進程只能操作子進程
10. 改變主線程，有可能會影響到其他線程的行為，但是對於父進程的修改是不會影響子進程;

一個多併發的小腳本

1. import threading
2. import time
3. def Princ(String):
4. print('task', String)
5. time.sleep(5)
6. # target=目標函數， args=傳入的參數
7. t1 = threading.Thread(target=Princ, args=('t1',))
8. t1.start()
9. t2 = threading.Thread(target=Princ, args=('t1',))
10. t2.start()
11. t3 = threading.Thread(target=Princ, args=('t1',))
12. t3.start()

參考文檔

進程與線程的一個簡單解釋

http://www.ruanyifeng.com/blog/2013/04/processes_and_threads.html

Linux進程與線程的區別

https://my.oschina.net/cnyinlinux/blog/422207

多線程

多線程在Python內實則就是一個假象，為什麼這麼說呢，因為CPU的處理速度是很快的，所以我們看起來以一個線程在執行多個任務，每個任務的執行速度是非常之快的，利用上下文切換來快速的切換任務，以至於我們根本感覺不到。

但是頻繁的使用上下文切換也是要耗費一定的資源，因為單線程在每次切換任務的時候需要保存當前任務的上下文。

什麼時候用到多線程？

首先IO操作是不佔用CPU的，只有計算的時候才會佔用CPU(譬如1+1=2)，Python中的多線程不適合CPU密集型的任務，適合IO密集型的任務(sockt server)。

啟動多個線程

主進程在啟動之後會啟動一個主線程，下面的腳本中讓主線程啟動了多個子線程，然而啟動的子線程是獨立的，所以主線程不會等待子線程執行完畢，而是主線程繼續往下執行，並行執行。

1. for i in range(50):
2. t = threading.Thread(target=Princ, args=('t-%s' % (i),))
3. t.start()

join()

join()方法可以讓程序等待每一個線程之後完成之後再往下執行，又成為串行執行。

1. import threading
2. import time
3. def Princ(String):
4. print('task', String)
5. time.sleep(1)
6. for i in range(50):
7. t = threading.Thread(target=Princ, args=('t-%s' % (i),))
8. t.start()
9. # 當前線程執行完畢之後在執行後面的線程
10. t.join()

讓主線程阻塞，子現在並行執行

1. import threading
2. import time
3. def Princ(String):
4. print('task', String)
5. time.sleep(2)
6. # 執行子線程的時間
7. start_time = time.time()
8. # 存放線程的實例
9. t_objs = []
10. for i in range(50):
11. t = threading.Thread(target=Princ, args=('t-%s' % (i),))
12. t.start()
13. # 為了不讓後面的子線程阻塞，把當前的子線程放入到一個列表中
14. t_objs.append(t)
15. # 循環所有子線程實例，等待所有子線程執行完畢
16. for t in t_objs:
17. t.join()
18. # 當前時間減去開始時間就等於執行的過程中需要的時間
19. print(time.time() - start_time)

查看主線程與子線程

1. import threading
2. class MyThreading(threading.Thread):
3. def __init__(self):
4. super(MyThreading, self).__init__()
5. def run(self):
6. print('我是子線程： ', threading.current_thread())
7. t = MyThreading()
8. t.start()
9. print('我是主線程： ', threading.current_thread())

輸出如下：

1. C:\Python\Python35\python.exe E:/MyCodeProjects/進程與線程/s3.py
2. 我是子線程：
3. 我是主線程： <_mainthread started=""/>
4. 
   
5. Process finished with exit code 0

查看當前進程的活動線程個數

1. import threading
2. class MyThreading(threading.Thread):
3. def __init__(self):
4. super(MyThreading, self).__init__()
5. def run(self):
6. print('www.anshengme.com')
7. t = MyThreading()
8. t.start()
9. print('線程個數： ', threading.active_count())

輸出如下：

1. C:\Python\Python35\python.exe E:/MyCodeProjects/進程與線程/s3.py
2. www.anshengme.com
3. # 一個主線程和一個子線程
4. 線程個數： 2
5. 
   
6. Process finished with exit code 0

Event

Event是線程間通信最間的機制之一：一個線程發送一個event信號，其他的線程則等待這個信號。用於主線程控制其他線程的執行。 Events 管理一個flag，這個flag可以使用set

()設置成True或者使用clear()重置為False，wait()則用於阻塞，在flag為True之前。flag默認為False。

選項描述Event.wait([timeout])堵塞線程，直到Event對象內部標識位被設為True或超時（如果提供了參數timeout）Event.set()將標識位設為TureEvent.clear()將標識伴設為FalseEvent.isSet()判斷標識位是否為Ture

1. #!/use/bin/env python
2. # _*_ coding: utf-8- _*_
3. 
   
4. import threading
5. 
   
6. def runthreading(event):
7. print("Start...")
8. event.wait()
9. print("End...")
10. event_obj = threading.Event()
11. for n in range(10):
12. t = threading.Thread(target=runthreading, args=(event_obj,))
13. t.start()
14. 
    
15. event_obj.clear()
16. inp = input("True/False?>> ")
17. if inp == "True":
18. event_obj.set()
19. `

守護進程(守護線程)

一個主進程可以啟動多個守護進程，但是主進程必須要一直運行，如果主進程掛掉了，那麼守護進程也會隨之掛掉

程序會等待主線程(進程)執行完畢，但是不會等待守護進程(線程)

1. import threading
2. import time
3. 
   
4. def Princ(String):
5. print('task', String)
6. time.sleep(2)
7. for i in range(50):
8. t = threading.Thread(target=Princ, args=('t-%s' % (i),))
9. t.setDaemon(True) # 把當前線程設置為守護線程，要在start之前設置
10. t.start()

場景預設： 比如現在有一個FTP服務，每一個用戶連接上去的時候都會創建一個守護線程，現在已經有300個用戶連接上去了，就是說已經創建了300個守護線程，但是突然之間FTP服務宕掉了，這個時候就不會等待守護線程執行完畢再退出，而是直接退出，如果是普通的線程，那麼就會登臺線程執行完畢再退出。

1. #!/use/bin/env python
2. # _*_ coding:utf-8 _*_
3. 
   
4. from multiprocessing import Process
5. import time
6. def runprocess(arg):
7. print(arg)
8. time.sleep(2)
9. 
   
10. 
    
11. p = Process(target=runprocess, args=(11,))
12. p.daemon=True
13. p.start()
14. 
    
15. print("end")

線程之間的數據交互與鎖(互斥鎖)

python2.x需要加鎖，但是在python3.x上面就不需要了

1. # _*_ coding:utf-8 _*_
2. import threading
3. def Princ():
4. # 獲取鎖
5. lock.acquire()
6. # 在函數內可以直接修改全局變量
7. global number
8. number += 1
9. # 為了避免讓程序出現串行，不能加sleep
10. # time.sleep(1)
11. # 釋放鎖
12. lock.release()
13. # 鎖
14. lock = threading.Lock()
15. # 主線程的number
16. number = 0
17. t_objs = []
18. for i in range(100):
19. t = threading.Thread(target=Princ)
20. t.start()
21. t_objs.append(t)
22. for t in t_objs:
23. t.join()
24. print('Number:', number)

遞歸鎖(Lock/RLock)

1. import threading
2. def run1():
3. print("grab the first part data")
4. lock.acquire()
5. global num
6. num += 1
7. lock.release()
8. return num
9. def run2():
10. print("grab the second part data")
11. lock.acquire()
12. global num2
13. num2 += 1
14. lock.release()
15. return num2
16. def run3():
17. lock.acquire()
18. res = run1()
19. print('--------between run1 and run2-----')
20. res2 = run2()
21. lock.release()
22. print(res, res2)
23. t_objs = []
24. if __name__ == '__main__':
25. num, num2 = 0, 0
26. lock = threading.RLock() # RLock()類似創建了一個字典，每次退出的時候找到字典的值進行退出
27. # lock = threading.Lock() # Lock()會阻塞在這兒
28. for i in range(10):
29. t = threading.Thread(target=run3)
30. t.start()
31. t_objs.append(t)
32. for t in t_objs:
33. t.join()
34. print(num, num2)

信號量(Semaphore)

互斥鎖同時只允許一個線程更改數據，而Semaphore是同時允許一定數量的線程更改數據

1. import threading
2. import time
3. def run(n):
4. semaphore.acquire() # 獲取信號，信號可以有多把鎖
5. time.sleep(1) # 等待一秒鐘
6. print("run the thread: %s\n" % n)
7. semaphore.release() # 釋放信號
8. t_objs = []
9. if __name__ == '__main__':
10. semaphore = threading.BoundedSemaphore(5) # 聲明一個信號量，最多允許5個線程同時運行
11. for i in range(20): # 運行20個線程
12. t = threading.Thread(target=run, args=(i,)) # 創建線程
13. t.start() # 啟動線程
14. t_objs.append(t)
15. for t in t_objs:
16. t.join()
17. print('>>>>>>>>>>>>>')

以上代碼中，類似與創建了一個隊列，最多放5個任務，每執行完成一個任務就會往後面增加一個任務。

多進程

多進程的資源是獨立的，不可以互相訪問。

啟動一個進程

1. from multiprocessing import Process
2. import time
3. def f(name):
4. time.sleep(2)
5. print('hello', name)
6. if __name__ == '__main__':
7. # 創建一個進程
8. p = Process(target=f, args=('bob',))
9. # 啟動
10. p.start()
11. # 等待進程執行完畢
12. p.join(

在進程內啟動一個線程

1. from multiprocessing import Process
2. import threading
3. def Thread(String):
4. print(String)
5. def Proces(String):
6. print('hello', String)
7. t = threading.Thread(target=Thread, args=('Thread %s' % (String),)) # 創建一個線程
8. t.start() # 啟動它
9. if __name__ == '__main__':
10. p = Process(target=Proces, args=('World',)) # 創建一個進程
11. p.start() # 啟動
12. p.join() # 等待進程執行完畢

啟動一個多進程

1. from multiprocessing import Process
2. import time
3. def f(name):
4. time.sleep(2)
5. print('hello', name)
6. if __name__ == '__main__':
7. for n in range(10): # 創建一個進程
8. p = Process(target=f, args=('bob %s' % (n),))
9. # 啟動
10. p.start()
11. # 等待進程執行完畢

獲取啟動進程的PID

1. # _*_ coding:utf-8 _*_
2. from multiprocessing import Process
3. import os
4. def info(String):
5. print(String)
6. print('module name:', __name__)
7. print('父進程的PID:', os.getppid())
8. print('子進程的PID:', os.getpid())
9. print("\n")
10. def ChildProcess():
11. info('\033[31;1mChildProcess\033[0m')
12. if __name__ == '__main__':
13. info('\033[32;1mTheParentProcess\033[0m')
14. p = Process(target=ChildProcess)
15. p.start()

輸出結果

1. C:\Python\Python35\python.exe E:/MyCodeProjects/多進程/s1.py
2. TheParentProcess
3. module name: __main__
4. # Pycharm的PID
5. 父進程的PID: 6888
6. # 啟動的腳本PID
7. 子進程的PID: 4660
8. 
   
9. ChildProcess
10. module name: __mp_main__
11. # 腳本的PID
12. 父進程的PID: 4660
13. # 父進程啟動的子進程PID
14. 子進程的PID: 8452
15. 
    
16. Process finished with exit code 0

進程間通信

默認情況下進程與進程之間是不可以互相通信的，若要實現互相通信則需要一箇中間件，另個進程之間通過中間件來實現通信，下面是進程間通信的幾種方式。

進程Queue

1. # _*_ coding:utf-8 _*_
2. from multiprocessing import Process, Queue
3. def ChildProcess(Q):
4. Q.put(['Hello', None, 'World']) # 在Queue裡面上傳一個列表
5. if __name__ == '__main__':
6. q = Queue() # 創建一個Queue
7. p = Process(target=ChildProcess, args=(q,)) # 創建一個子進程，並把Queue傳給子進程,相當於克隆了一份Queue
8. p.start() # 啟動子進程
9. print(q.get()) # 獲取q中的數據
10. p.join()

管道(Pipes)

1. # _*_ coding:utf-8 _*_
2. from multiprocessing import Process, Pipe
3. def ChildProcess(conn):
4. conn.send(['Hello', None, 'World']) # 寫一段數據
5. conn.close() # 關閉
6. if __name__ == '__main__':
7. parent_conn, child_conn = Pipe() # 生成一個管道實例，parent_conn, child_conn管道的兩頭
8. p = Process(target=ChildProcess, args=(child_conn,))
9. p.start()
10. print(parent_conn.recv()) # 收取消息
11. p.join()

數據共享(Managers)

1. # _*_ coding:utf-8 _*_
2. # _*_ coding:utf-8 _*_
3. from multiprocessing import Process, Manager
4. import os
5. 
   
6. def ChildProcess(Dict, List):
7. Dict['k1'] = 'v1'
8. Dict['k2'] = 'v2'
9. List.append(os.getpid()) # 獲取子進程的PID
10. print(List) # 輸出列表中的內容
11. 
    
12. if __name__ == '__main__':
13. manager = Manager() # 生成Manager對象
14. Dict = manager.dict() # 生成一個可以在多個進程之間傳遞共享的字典
15. List = manager.list() # 生成一個字典
16. 
    
17. ProcessList = [] # 創建一個空列表，存放進程的對象，等待子進程執行用於
18. 
    
19. for i in range(10): # 生成是個子進程
20. p = Process(target=ChildProcess, args=(Dict, List)) # 創建一個子進程
21. p.start() # 啟動
22. ProcessList.append(p) # 把子進程添加到p_list列表中
23. 
    
24. for res in ProcessList: # 循環所有的子進程
25. res.join() # 等待執行完畢
26. print('\n')
27. print(Dict)
28. print(List)

輸出結果

1. C:\Python\Python35\python.exe E:/MyCodeProjects/多進程/s4.py
2. [5112]
3. [5112, 3448]
4. [5112, 3448, 4584]
5. [5112, 3448, 4584, 2128]
6. [5112, 3448, 4584, 2128, 11124]
7. [5112, 3448, 4584, 2128, 11124, 10628]
8. [5112, 3448, 4584, 2128, 11124, 10628, 5512]
9. [5112, 3448, 4584, 2128, 11124, 10628, 5512, 10460]
10. [5112, 3448, 4584, 2128, 11124, 10628, 5512, 10460, 10484]
11. [5112, 3448, 4584, 2128, 11124, 10628, 5512, 10460, 10484, 6804]
12. 
    
13. 
    
14. {'k1': 'v1', 'k2': 'v2'}
15. [5112, 3448, 4584, 2128, 11124, 10628, 5512, 10460, 10484, 6804]
16. 
    
17. Process finished with exit code 0

鎖(Lock)

1. from multiprocessing import Process, Lock
2. 
   
3. def ChildProcess(l, i):
4. l.acquire() # 獲取鎖
5. print('hello world', i)
6. l.release() # 釋放鎖
7. 
   
8. if __name__ == '__main__':
9. lock = Lock() # 生成Lock對象
10. for num in range(10):
11. Process(target=ChildProcess, args=(lock, num)).start() # 創建並啟動一個子進程

進程池

同一時間啟動多少個進程

1. #!/use/bin/env python
2. # _*_ coding: utf-8 _*_
3. 
   
4. from multiprocessing import Pool
5. import time
6. 
   
7. def myFun(i):
8. time.sleep(2)
9. return i+100
10. 
    
11. def end_call(arg):
12. print("end_call>>", arg)
13. 
    
14. p = Pool(5) # 允許進程池內同時放入5個進程
15. for i in range(10):
16. p.apply_async(func=myFun, args=(i,),callback=end_call) # # 平行執行,callback是主進程來調用
17. # p.apply(func=Foo) # 串行執行
18. 
    
19. print("end")
20. p.close()
21. p.join() # 進程池中進程執行完畢後再關閉，如果註釋，那麼程序直接關閉。

線程池

簡單實現

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
3. import threading
4. import queue
5. import time
6. class MyThread:
7. def __init__(self,max_num=10):
8. self.queue = queue.Queue()
9. for n in range(max_num):
10. self.queue.put(threading.Thread)
11. def get_thread(self):
12. return self.queue.get()
13. def put_thread(self):
14. self.queue.put(threading.Thread)
15. pool = MyThread(5)
16. def RunThread(arg,pool):
17. print(arg)
18. time.sleep(2)
19. pool.put_thread()
20. for n in range(30):
21. thread = pool.get_thread()
22. t = thread(target=RunThread, args=(n,pool,))
23. t.start()

複雜版本

1. #!/usr/bin/env python
2. # -*- coding:utf-8 -*-
3. 
   
4. import queue
5. import threading
6. import contextlib
7. import time
8. 
   
9. StopEvent = object()
10. 
    
11. class ThreadPool(object):
12. 
    
13. def __init__(self, max_num, max_task_num = None):
14. if max_task_num:
15. self.q = queue.Queue(max_task_num)
16. else:
17. self.q = queue.Queue()
18. self.max_num = max_num
19. self.cancel = False
20. self.terminal = False
21. self.generate_list = []
22. self.free_list = []
23. 
    
24. def run(self, func, args, callback=None):
25. """
26. 線程池執行一個任務
27. :param func: 任務函數
28. :param args: 任務函數所需參數
29. :param callback: 任務執行失敗或成功後執行的回調函數，回調函數有兩個參數1、任務函數執行狀態；2、任務函數返回值（默認為None，即：不執行回調函數）
30. :return: 如果線程池已經終止，則返回True否則None
31. """
32. if self.cancel:
33. 
    
34. return
35. if len(self.free_list) == 0 and len(self.generate_list) < self.max_num:
36. self.generate_thread()
37. w = (func, args, callback,)
38. self.q.put(w)
39. 
    
40. def generate_thread(self):
41. """
42. 創建一個線程
43. """
44. t = threading.Thread(target=self.call)
45. t.start()
46. 
    
47. def call(self):
48. """
49. 循環去獲取任務函數並執行任務函數
50. """
51. current_thread = threading.currentThread()
52. self.generate_list.append(current_thread)
53. 
    
54. event = self.q.get()
55. while event != StopEvent:
56. 
    
57. func, arguments, callback = event
58. try:
59. result = func(*arguments)
60. success = True
61. except Exception as e:
62. success = False
63. result = None
64. 
    
65. if callback is not None:
66. try:
67. callback(success, result)
68. except Exception as e:
69. pass
70. 
    
71. with self.worker_state(self.free_list, current_thread):
72. if self.terminal:
73. event = StopEvent
74. else:
75. event = self.q.get()
76. else:
77. 
    
78. self.generate_list.remove(current_thread)
79. 
    
80. def close(self):
81. """
82. 執行完所有的任務後，所有線程停止
83. """
84. self.cancel = True
85. full_size = len(self.generate_list)
86. while full_size:
87. self.q.put(StopEvent)
88. full_size -= 1
89. 
    
90. def terminate(self):
91. """
92. 無論是否還有任務，終止線程
93. """
94. self.terminal = True
95. 
    
96. while self.generate_list:
97. self.q.put(StopEvent)
98. 
    
99. self.q.queue.clear()
100. 
     
101. @contextlib.contextmanager
102. def worker_state(self, state_list, worker_thread):
103. """
104. 用於記錄線程中正在等待的線程數
105. """
106. state_list.append(worker_thread)
107. try:
108. yield
109. finally:
110. state_list.remove(worker_thread)
111. 
     
112. # How to use
113. 
     
114. pool = ThreadPool(5)
115. 
     
116. def callback(status, result):
117. # status, execute action status
118. # result, execute action return value
119. pass
120. 
     
121. def action(i):
122. print(i)
123. 
     
124. for i in range(30):
125. ret = pool.run(action, (i,), callback)
126. 
     
127. time.sleep(5)
128. print(len(pool.generate_list), len(pool.free_list))
129. print(len(pool.generate_list), len(pool.free_list))
130. pool.close()
131. pool.terminate()

什麼是IO密集型和CPU密集型？

IO密集型(I/O bound)

頻繁網絡傳輸、讀取硬盤及其他IO設備稱之為IO密集型，最簡單的就是硬盤存取數據，IO操作並不會涉及到CPU。

計算密集型(CPU bound)

程序大部分在做計算、邏輯判斷、循環導致cpu佔用率很高的情況，稱之為計算密集型，比如說python程序中執行了一段代碼1+1，這就是在計算1+1的值

What is the association?

協程的優缺點：

優點

1. 無需線程上下文切換的開銷
2. 無需原子操作鎖定及同步的開銷(更改一個變量)
3. 方便切換控制流，簡化編程模型
4. 高併發+高擴展性+低成本：一個CPU支持上萬的協程都不是問題。所以很適合用於高併發處理。

缺點：

1. 無法利用多核資源：協程的本質是個單線程,它不能多核，協程需要和進程配合才能運行在多CPU上，當然我們日常所編寫的絕大部分應用都沒有這個必要，除非是CPU密集型應用。
2. 進行阻塞（Blocking）操作（如IO時）會阻塞掉整個程序

實現協程實例

yield

1. def consumer(name):
2. print("--->starting eating baozi...")
3. while True:
4. new_baozi = yield # 直接返回
5. print("[%s] is eating baozi %s" % (name, new_baozi))
6. 
   
7. def producer():
8. r = con.__next__()
9. r = con2.__next__()
10. n = 0
11. while n < 5:
12. n += 1
13. con.send(n) # 喚醒生成器的同時傳入一個參數
14. con2.send(n)
15. print("\033[32;1m[producer]\033[0m is making baozi %s" % n)
16. 
    
17. if __name__ == '__main__':
18. con = consumer("c1")
19. con2 = consumer("c2")
20. p = producer()

Greenlet

安裝greenlet

1. pip3 install greenlet
2. # -*- coding:utf-8 -*-
3. from greenlet import greenlet
4. 
   
5. def func1():
6. print(12)
7. gr2.switch()
8. print(34)
9. gr2.switch()
10. 
    
11. def func2():
12. print(56)
13. gr1.switch()
14. print(78)
15. 
    
16. # 創建兩個攜程
17. gr1 = greenlet(func1)
18. gr2 = greenlet(func2)
19. gr1.switch() # 手動切換

Gevent

Gevent可以實現併發同步或異步編程，在gevent中用到的主要模式是Greenlet， 它是以C擴展模塊形式接入Python的輕量級協程，Greenlet全部運行在主程序操作系統進程的內部，但它們被協作式地調度。

安裝Gevent

1. pip3 install gevent
2. import gevent
3. 
   
4. def foo():
5. print('Running in foo')
6. gevent.sleep(2)
7. print('Explicit context switch to foo again')
8. 
   
9. def bar():
10. print('Explicit context to bar')
11. gevent.sleep(3)
12. print('Implicit context switch back to bar')
13. 
    
14. # 自動切換
15. gevent.joinall([
16. gevent.spawn(foo), # 啟動一個協程
17. gevent.spawn(bar),
18. ])

頁面抓取

1. from urllib import request
2. from gevent import monkey
3. import gevent
4. import time
5. 
   
6. monkey.patch_all() # 當前程序中只要設置到IO操作的都做上標記
7. 
   
8. def wget(url):
9. print('GET: %s' % url)
10. resp = request.urlopen(url)
11. data = resp.read()
12. print('%d bytes received from %s.' % (len(data), url))
13. 
    
14. urls = [
15. 'https://www.python.org/',
16. 'https://www.python.org/',
17. 'https://github.com/',
18. 'https://yw666.blog.51cto.com/',
19. ]
20. 
    
21. # 串行抓取
22. start_time = time.time()
23. for n in urls:
24. wget(n)
25. print("串行抓取使用時間：", time.time() - start_time)
26. 
    
27. # 並行抓取
28. ctrip_time = time.time()
29. gevent.joinall([
30. gevent.spawn(wget, 'https://www.python.org/'),
31. gevent.spawn(wget, 'https://www.python.org/'),
32. gevent.spawn(wget, 'https://github.com/'),
33. gevent.spawn(wget, 'https://yw666.blog.51cto.com/'),
34. ])
35. print("並行抓取使用時間：", time.time() - ctrip_time)

輸出

1. C:\Python\Python35\python.exe E:/MyCodeProjects/協程/s4.py
2. GET: https://www.python.org/
3. 47424 bytes received from https://www.python.org/.
4. GET: https://www.python.org/
5. 47424 bytes received from https://www.python.org/.
6. GET: https://github.com/
7. 25735 bytes received from https://github.com/.
8. GET: https://blog.ansheng.me/
9. 82693 bytes received from https://yw666.blog.51cto.com/.
10. 串行抓取使用時間： 15.143015384674072
11. GET: https://www.python.org/
12. GET: https://www.python.org/
13. GET: https://github.com/
14. GET: https://blog.ansheng.me/
15. 25736 bytes received from https://github.com/.
16. 47424 bytes received from https://www.python.org/.
17. 82693 bytes received from https://yw666.blog.51cto.com/.
18. 47424 bytes received from https://www.python.org/.
19. 並行抓取使用時間： 3.781306266784668
20. 
    
21. Process finished with exit code 0

閱讀更多 繁華落盡and曲終人散 的文章

關鍵字: 三大 進程 腳本語言