本节内容
| 一、线程进程介绍 |
1. 工作最小单元是线程
2. 应用程序 -> 至少有一个进程 -> 至少有一个线程
3. 应用场景：
IO密集型：线程
计算密集型：进程
4. GIL，全局解释器锁
保证同一个进程中只有一个线程同时被调度，如图所示
| 二、线程 |
1、线程基本使用
import threading
import time
def func(*args):
time.sleep(1)
print(*args)
for i in range(10):
t = threading.Thread(target=func, args=[i,])
t.start() # 程序准备好了，等待CPU调度
print('--main thread--')
print('线程总数：',threading.activeCount())
# 主线程先执行完，等待所有其它线程再执行完，最终程序执行完
上述代码创建了10个“前台”线程，然后控制器就交给了CPU，CPU根据指定算法进行调度，分片执行指令。
更多方法：
-
start 线程准备就绪，等待CPU调度
-
setName 为线程设置名称
-
getName 获取线程名称
-
setDaemon 设置为后台线程或前台线程（默认）
如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止
如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
-
join 逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义
-
run 线程被cpu调度后自动执行线程对象的run方法
1 import threading 2 import time 3 4 5 def func(*args): 6 time.sleep(1) 7 print(*args) 8 9 for i in range(30): 10 t = threading.Thread(target=func, args=[i,]) 11 12 # t.setDaemon(True) # 主线程终止，不等待子线程 13 t.start() # 程序准备好了，等待CPU调度 14 15 t.join() # 一直等，线程串行了 16 t.join(1) # 等待最大时间 17 18 print('--main thread--') 19 print('线程总数：',threading.activeCount())
class MyThread(threading.Thread): def __init__(self, func, *args, **kwargs): super(MyThread,self).__init__(*args, **kwargs) # self._target = target self.func = func def run(self): # 线程内部自动执行run方法，定制 self.func() def task(): time.sleep(1) print("*") obj = MyThread(task) obj.start()
2、线程锁（Lock、RLock）
由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏数据，
所以，出现了线程锁 - 同一时刻允许一个线程执行操作。
import threading
import time
v = 10
# 只能有一个人使用锁
# lock = threading.Lock()
lock = threading.RLock() # 开多重锁
def task(arg):
time.sleep(2) # 模拟可以并发代码
# 申请使用锁，其他人等
lock.acquire()
lock.acquire()
global v
v -= 1
print(v)
# 释放锁
lock.release()
lock.release()
for i in range(10):
t = threading.Thread(target=task, args=(i,))
t.start()
3、信号量（Semaphore）
互斥锁 同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 ，比如厕所有3个坑，那最多只允许3个人上厕所，
后面的人只能等里面有人出来了才能再进去。
import threading
import time
v = 10
# 多人同时使用锁
lock = threading.BoundedSemaphore(3)
def task(arg):
# 申请使用锁，其他人等
lock.acquire()
time.sleep(1)
global v
v -= 1
print(v)
# 释放锁
lock.release()
for i in range(10):
t = threading.Thread(target=task, args=(i,))
t.start()
4、事件（event）
python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。
事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，
那么event.wait 方法时便不再阻塞。
-
clear：将“Flag”设置为False
-
set：将“Flag”设置为True
import threading
import time
lock = threading.Event()
def task(arg):
time.sleep(1)
# 锁住所有线程
lock.wait()
print(arg)
for i in range(10):
t = threading.Thread(target=task, args=(i,))
t.start()
while True:
value = input(">>>>:")
if len(value) == 0:
continue
if value == 'q':
exit()
if value == '1':
lock.set()
lock.clear()
5、条件（Condition）
使得线程等待，只有满足某条件时，才释放n个线程
import threading
import time
lock = threading.Condition()
def task(arg):
time.sleep(1)
# 锁住所有线程
lock.acquire()
lock.wait()
print('线程：', arg)
lock.release()
for i in range(10):
t = threading.Thread(target=task, args=(i,))
t.start()
while True:
value = input(">>>:")
lock.acquire()
lock.notify(int(value)) # 输入几个就解锁几个线程
lock.release()
6、定时器 (Timer)
定时器，指定n秒后执行某操作
from threading import Timer
def hello():
print("hello, world")
t = Timer(1, hello)
t.start() # after 1 seconds, "hello, world" will be printed
7、线程池
涉及到多线程的使用时，我们更多使用线程池来解决问题
from concurrent.futures import ThreadPoolExecutor
import requests # pip3 install requests
def task(url):
response = requests.get(url)
print("得到结果：", url, len(response.content))
pool = ThreadPoolExecutor(2)
url_list = [
'http://www.oldboyedu.com',
'http://www.autohome.com.cn',
'http://www.baidu.com',
'http://www.miaocloud.cn'
]
for url in url_list:
print("开始请求", url)
pool.submit(task, url)
from concurrent.futures import ThreadPoolExecutor import requests # pip3 install requests def txt(future): download_response = future.result() print('处理中', download_response.url, download_response.status_code) def download(url): response = requests.get(url) return response pool = ThreadPoolExecutor(2) url_list = [ 'http://www.oldboyedu.com', 'http://www.autohome.com.cn', 'http://www.baidu.com', 'http://www.miaocloud.cn' ] for url in url_list: # 去连接池中获取链接 # 去下载吧 print("开始请求", url) future = pool.submit(download, url) # 下载完成之后，执行txt函数 future.add_done_callback(txt) # 其中txt的输入参数必须为future
| 三、进程 |
1、进程基本使用
from multiprocessing import Process
def task(arg):
print(arg)
if __name__ == "__main__":
for i in range(10):
p = Process(target=task, args=(i,))
# p.daemon = True
p.start()
# p.join()
p.join(1)
print('主进程中的主线程执行到最后...')
注意：由于进程之间的数据需要各自持有一份，所以创建进程需要的非常大的开销。
2、进程数据共享
进程各自持有一份数据，默认无法共享数据
1 def task(num, li): 2 li.append(num) 3 print(li) 4 5 if __name__ == "__main__": 6 v = [] # 每个进程都拷贝一份 7 for i in range(10): 8 p = Process(target=task, args=(i, v)) 9 # p = Thread(target=task, args=(i, v)) 10 p.start()
from multiprocessing import Process, Array, Manager
# 方法一 Array
def task(num, array):
array[num] = 1
print(list(array))
if __name__ == "__main__":
a = Array('i', 10)
for i in range(10):
p = Process(target=task, args=(i, a))
p.start()
# 方法二 Manager.dict()
def task(num, list1):
list1.append(num)
print(list1)
if __name__ == "__main__":
obj = Manager() # 基于socket实现
list1 = obj.list() # 可以实现数据共享
# dict1 = ojb.dict()
for i in range(10):
p = Process(target=task, args=(i, list1))
p.start()
# p.join()
'c': ctypes.c_char, 'u': ctypes.c_wchar, 'b': ctypes.c_byte, 'B': ctypes.c_ubyte, 'h': ctypes.c_short, 'H': ctypes.c_ushort, 'i': ctypes.c_int, 'I': ctypes.c_uint, 'l': ctypes.c_long, 'L': ctypes.c_ulong, 'f': ctypes.c_float, 'd': ctypes.c_double
当创建进程时（非使用时），共享数据会被拿到子进程中，当进程中执行完毕后，再赋值给原值。
3、进程池
进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，
直到进程池中有可用进程为止。
from concurrent.futures import ProcessPoolExecutor
pool = ProcessPoolExecutor(5)
def task(arg):
pass
for i in range(10):
pool.submit(task, i)
| 四、协程 |
线程和进程的操作是由程序触发系统接口，最后的执行者是系统；协程的操作则是程序员。
协程存在的意义：对于多线程应用，CPU通过切片的方式来切换线程间的执行，线程切换时需要耗时（保存状态，下次继续）。
协程，则只使用一个线程，在一个线程中规定某个代码块执行顺序。
协程的适用场景：当程序中存在大量不需要CPU的操作时（IO），适用于协程；
from gevent import monkey; monkey.patch_all()
import gevent
import requests
# 根据协程二次开发: 协程 + IO
def f(url):
response = requests.get(url)
print(response.url,response.status_code)
gevent.joinall(
[
gevent.spawn(f, 'http://www.baidu.com'),
gevent.spawn(f, 'http://www.jd.com'),
gevent.spawn(f, 'http://www.taobao.com'),
]
)