线程
线程的创建Threading.Thread类
线程的创建：
import os import time from threading import Thread # 多线程并发 def func(a,b): g = 0 print(g,os.getpid()) t_lst = [] for i in range(10): t = Thread(target=func,args=(i,5)) t.start() t_lst.append(t) for t in t_lst : t.join()
import time from threading import Thread class MyTread(Thread): def __init__(self,arg): super().__init__() self.arg = arg def run(self): time.sleep(1) print(self.arg) t = MyTread(10) t.start()
进程 是 最小的 内存分配单位 线程 是 操作系统调度的最小单位 线程直接被CPU执行,进程内至少含有一个线程,也可以开启多个线程 开启一个线程所需要的时间要远远小于开启一个进程 多个线程内部有自己的数据栈,数据不共享 全局变量在多个线程之间是共享的 GIL锁(即全局解释器锁) 在Cpython解释器下的python程序 在同一时刻 多个线程中只能有一个线程被CPU执行 高CPU : 计算类 --- 高CPU利用率 高IO : 爬取网页 200个网页 qq聊天 send recv 处理日志文件 读文件 处理web请求 读数据库 写数据库
多线程与多进程
import time from threading import Thread from multiprocessing import Process def func(n): n + 1 if __name__ == '__main__': start = time.time() t_lst = [] for i in range(100): t = Thread(target=func,args=(i,)) t.start() t_lst.append(t) for t in t_lst:t.join() t1 = time.time() - start start = time.time() t_lst = [] for i in range(100): t = Process(target=func, args=(i,)) t.start() t_lst.append(t) for t in t_lst: t.join() t2 = time.time() - start print(t1,t2)
多线程实现socket
import socket from threading import Thread def chat(conn): conn.send(b'hello') msg = conn.recv(1024).decode('utf-8') print(msg) conn.close() sk = socket.socket() sk.bind(('127.0.0.1',8080)) sk.listen() while True: conn,addr = sk.accept() Thread(target=chat,args = (conn,)).start() sk.close()
import socket sk = socket.socket() sk.connect(('127.0.0.1',8080)) msg = sk.recv(1024) print(msg) inp = input('>>> ').encode('utf-8') sk.send(inp) sk.close()
全局解释器锁GIL
Python代码的执行由Python虚拟机(也叫解释器主循环)来控制。Python在设计之初就考虑到要在主循环中，同时只有一个线程在执行。虽然 Python 解释器中可以“运行”多个线程，但在任意时刻只有一个线程在解释器中运行。
对Python虚拟机的访问由全局解释器锁(GIL)来控制，正是这个锁能保证同一时刻只有一个线程在运行。
在多线程环境中，Python 虚拟机按以下方式执行：
a、设置 GIL；
b、切换到一个线程去运行；
c、运行指定数量的字节码指令或者线程主动让出控制(可以调用 time.sleep(0))；
d、把线程设置为睡眠状态；
e、解锁 GIL；
d、再次重复以上所有步骤。
在调用外部代码(如 C/C++扩展函数)的时候，GIL将会被锁定，直到这个函数结束为止(由于在这期间没有Python的字节码被运行，所以不会做线程切换)编写扩展的程序员可以主动解锁GIL。
守护线程
无论是进程还是线程，都遵循：守护xx会等待主xx运行完毕后被销毁。需要强调的是：运行完毕并非终止运行
#1.对主进程来说，运行完毕指的是主进程代码运行完毕 #2.对主线程来说，运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕，主线程才算运行完毕
#1 主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束， #2 主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。
from threading import Thread import time def func1(): print(666) time.sleep(10) def func2(): print("in func2") time.sleep(2) t1=Thread(target=func1,) t2=Thread(target=func2,) t1.daemon=True t1.start() t2.start() print(777) #先打印三个结果，然后过两秒，程序结束，由于func1是守护进程，所以不会等待十秒，其他程序结束他就结束 # 守护进程随着主进程代码的执行结束而结束 # 守护线程会在主线程结束之后等待其他子线程的结束才结束
锁
互斥锁：
import time from threading import Thread,Lock def func1(lock): lock.acquire() global n temp=n time.sleep(0.2) n=temp-1 lock.release() n=10 t_lst=[] lock=Lock() for i in range(10): t=Thread(target=func1,args=(lock,)) t.start() t_lst.append(t) for i in t_lst:i.join() print(n) #如果不加锁，会导致结果出错，导致数据不安全
死锁与递归锁
进程也有死锁与递归锁，在进程那里忘记说了，放到这里一切说了额
所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，如下就是死锁
import time from threading import Thread,Lock noodle_lock=Lock() fork_lock=Lock() def eat1(name): noodle_lock.acquire() print("%s拿到面条了"%name) fork_lock.acquire() print("%s拿到叉子了"%name) print("%s吃"%name) fork_lock.release() noodle_lock.release() def eat2(name): fork_lock.acquire() print("%s拿到叉子了"%name) time.sleep(2) noodle_lock.acquire() print("%s拿到面条了"%name) print("%s吃"%name) noodle_lock.release() fork_lock.release() t1=Thread(target=eat1,args=("小狗",)) t2=Thread(target=eat2,args=("小猫",)) t3=Thread(target=eat1,args=("小虎",)) t1.start() t2.start() t3.start()
解决方法，递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。
这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：
from threading import RLock # 递归锁 fork_lock = noodle_lock = RLock() # 一个钥匙串上的两把钥匙 def eat1(name): noodle_lock.acquire() # 一把钥匙 print('%s拿到面条啦'%name) fork_lock.acquire() print('%s拿到叉子了'%name) print('%s吃面'%name) fork_lock.release() noodle_lock.release() def eat2(name): fork_lock.acquire() print('%s拿到叉子了'%name) time.sleep(1) noodle_lock.acquire() print('%s拿到面条啦'%name) print('%s吃面'%name) noodle_lock.release() fork_lock.release() Thread(target=eat1,args=('alex',)).start() Thread(target=eat2,args=('Egon',)).start() Thread(target=eat1,args=('bossjin',)).start() Thread(target=eat2,args=('nezha',)).start()
递归锁是解决死锁问题的，可以在一个线程里多次acquire
信号量
同进程的一样
Semaphore管理一个内置的计数器，
每当调用acquire()时内置计数器-1；
调用release() 时内置计数器+1；
计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。
实例：(同时只有5个线程可以获得semaphore,即可以限制最大连接数为5)：
import time from threading import Semaphore,Thread def func(sem,a,b): sem.acquire() time.sleep(1) print(a+b) sem.release() sem = Semaphore(4) for i in range(10): t=Thread(target=func,args=(sem,i,i+5)) t.start()
事件
同进程的一样
线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行
event.isSet()：返回event的状态值； event.wait()：如果 event.isSet()==False将阻塞线程； event.set()： 设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度； event.clear()：恢复event的状态值为False。
例如，有多个工作线程尝试链接MySQL，我们想要在链接前确保MySQL服务正常才让那些工作线程去连接MySQL服务器，如果连接不成功，都会去尝试重新连接。那么我们就可以采用threading.Event机制来协调各个工作线程的连接操作
import time import random from threading import Thread,Event def connect_db(e): count = 0 while count < 3: e.wait(0.5) # 状态为False的时候,我只等待1s就结束 if e.is_set() == True: print('连接数据库') break else: count += 1 print('第%s次连接失败'%count) else: raise TimeoutError('数据库连接超时') def check_web(e): time.sleep(random.randint(0,3)) e.set() e = Event() t1 = Thread(target=connect_db,args=(e,)) t2 = Thread(target=check_web,args=(e,)) t1.start() t2.start()
