并发编程 线程
1.线程的概念:
1. 什么是线程: 进程和线程都是虚拟单位,都是用来帮助我木门形象的描述某种事物
进程 : 资源单位 线程:执行单位
每一个进程都自带一个线程,线程才是真正的执行单位,进程只是在线程运行过程中提供代码运行所需要的资源
2. 为什么要有线程:
开进程 1 申请内存空间 耗资源, 拷贝代码, 耗资源
开线程 一个进程内可以起多个线程,并且线程与线程之间的数据是共享的
开启线程的开销要远远小于开启进程的开销
2.Threading.Thread 创建线程模块
Thread实例对象的方法 # isAlive(): 返回线程是否活动的。 # getName(): 返回线程名。 # setName(): 设置线程名。 threading模块提供的一些方法： # threading.currentThread(): 返回当前的线程变量。 # threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。 # threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
3.代码的实现
1.创建线程的两种方式
from threading import Thread import time def func(name): print(f'{name}线程正在创建') time.sleep(2) print(f'{name}线程结束') # 开线程不需要在__main__代码块内 但是习惯性的还是写在__main__代码块内 if __name__ == '__main__': t = Thread(target=func,args=('小明',)) t.start() print('主')
from threading import Thread import time class MyThread(Thread): def __init__(self,name): super().__init__() self.name = name def run(self): print(f'{self.name}线程正在创建') time.sleep(2) print(f'{self.name}线程结束') if __name__ == '__main__': t = MyThread('小明') t.start() print('主')
2.线程对象及其他方法:
from threading import Thread,current_thread,active_count import time import os def task(name,i): print('%s is running'%name) # print('子current_thread:',current_thread().name) # print('子',os.getpid()) time.sleep(i) print('%s is over'%name) # 开线程不需要在__main__代码块内 但是习惯性的还是写在__main__代码块内 t = Thread(target=task,args=('egon',1)) t1 = Thread(target=task,args=('jason',2)) t.start() # 告诉操作系统开辟一个线程 线程的开销远远小于进程 t1.start() # 告诉操作系统开辟一个线 t1.join() # 主线程等待子线程运行完毕 print('当前正在活跃的线程数',active_count()) # 小的代码执行完 线程就已经开启了 print('主') # print('主current_thread:',current_thread().name) # 线程名字 # print('主',os.getpid())
3. 守护线程:与进程方法相同,但需要注意的是:主线程的结束也就以为着进程的结束,主线程必须等待其他非守护线程的结束才能结束,也就是意味着子线程在运行的时候需要使用进程中的资源,而主线程一旦结束了资源也就销毁了
from threading import Thread,current_thread import time def task(i): print(current_thread().name) time.sleep(i) print('GG') t = Thread(target=task,args=(1,)) t.daemon = True t.start() print('主') ''' Thread-1 主 因为t线程为守护进程,主线程运行结束t线程也跟着结束 '''
4. 同一进程中线程之间的数据是共享的
from threading import Thread money = 666 def task(): global money money = 999 t = Thread(target=task) t.start() t.join() print(money) # 999 同一进程中线程间的数据是共享的
5. 线程中的互斥锁与进程中的使用方法一致
from threading import Thread,Lock import time n = 100 def task(mutex): global n mutex.acquire() tmp = n time.sleep(0.1) n = tmp - 1 mutex.release() t_list = [] mutex = Lock() for i in range(100): t = Thread(target=task,args=(mutex,)) # 创建100个线程 t.start() t_list.append(t) # 将线程对象添加到列表中 for t in t_list: # 遍历线程对象列表 t.join() # 等待所有线程程运行结束再执行主线程 print(n) # 0
6. 用线程实现sockte服务端的并发:
服务端:
import socket from threading import Thread def talk(conn): while 1: try: ret = conn.recv(1024) if len(ret) == 0: break print(ret) conn.send(ret.upper()) except ConnectionResetError: break conn.close() sk = socket.socket() sk.bind(('127.0.0.1',8080)) sk.listen() while 1: conn,addr = sk.accept() t = Thread(target=talk,args=(conn,)) t.start()
客户端:
import socket sk = socket.socket() sk.connect(('127.0.0.1',8080)) while 1: sk.send(b'hello') ret = sk.recv(1024) print(ret)
7: GIL全局解释器锁:
""" In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. """
ps:python解释器有很多种 最常见的就是Cpython解释器
GIL本质也是一把互斥锁:将并发变成串行牺牲效率保证数据的安全 他是用来阻止同一个进程下的多个线程的同时执行(同一个进程内多个线程无法实现并行但是可以实现并发)GIL的存在是因为CPython解释器的内存管理不是线程安全的,也就是说同一个进程中的多个线程再同一时间只有一个线程被cpu执行,GIL全局解释器锁只是针对线程的,进入IO自动释放
总结.在执行多个计算密集型的任务时.在计算机单核的情况下开线程最好,在多核情况下开进程会效率更高
.在执行多个IO密集型的任务时.开线程时最好的
8:死锁与递归锁:当一个进程或线程中同时出现多把锁容易造成死锁显现,程序卡死
递归锁: Rlock,可以多次acquire与release 当一个线程或进程中所有acquire都被release,其他的线程才能获得资源,注意使用递归锁时是链式赋值
科学家吃面示例:
import time from threading import Thread,RLock lock1 = lock2 = RLock() def eat1(name): lock2.acquire() print('%s 抢到了面条'%name) lock1.acquire() print('%s 抢到了叉子'%name) print('%s 吃面'%name) lock1.release() lock2.release() def eat2(name): lock1.acquire() print('%s 抢到了叉子' % name) time.sleep(1) lock2.acquire() print('%s 抢到了面条' % name) print('%s 吃面' % name) lock2.release() lock1.release() for name in ['小明','小黄','小亮']: t1 = Thread(target=eat1,args=(name,)) t2 = Thread(target=eat2,args=(name,)) t1.start() t2.start()
9 信号量: Semaphore: 用锁的原理实现的,内置了一个计数器,在同一时间只能有指定数量的进程或线程执行某一段代码,如果把互斥锁比作一个车位的话,那么信号量相当于多个车位
from threading import Thread,Semaphore # 线程使用信号量导入方法 # from multiprocessing import Process,Semaphore # 进程使用信号量导入方法 import time import random sm = Semaphore(5) # 5个车位 def func(name): sm.acquire() # 占车位 print(f'{name}占了一个车位') time.sleep(random.randint(1,2)) sm.release() # 让出车位 print(f'{name}让了一个车位') for i in range(20): t = Thread(target=func,args=(i,)) t.start() '''同时占用车位最多不会超过5个,一个让出去另一个才会占用 '''
10:事件:event类似于join 不过事件是在处理两个子进程或子线程之间互相等待的过程
常用方法:
from multiprocessing import Event e = Event() e.wait() # 阻塞态,状态为True不堵塞,为False 堵塞 e.is_set() # 查看状态 e.set() # False ---> True e.clear() # True ---> False
红绿灯示例:
from threading import Event,Thread import time e = Event() def light(): print('红灯亮了') time.sleep(3) e.set() print('绿灯亮了') def car(name): print(f'{name}正在等红灯') e.wait() print(f'{name}可以行驶了') l = Thread(target=light) l.start() for i in range(10): c = Thread(target=car,args=(i,)) c.start()
11. 线程队列:
1: queue 队列
import queue q = queue.Queue() q.put(1) q.put(2) print(q.get()) # 1 print(q.get()) # 2
2: Lifoqueue 堆栈
import queue q = queue.LifoQueue() # 堆栈 q.put(1) q.put(2) print(q.get()) # 2 print(q.get()) # 1
3: PriorityQueue 优先级队列
import queue q = queue.PriorityQueue() # 堆栈 q.put((1,'a')) # 放一个元组,第一个元素是优先级为int型,数字越小优先级越高 q.put((0,'b')) q.put((-1,'c')) q.put((1,'d')) # 同一优先级,按照内容对应的ASCII码表来确认优先级 print(q.get()) # (-1, 'c') print(q.get()) # (0, 'b') print(q.get()) # (1, 'a') print(q.get()) # (1, 'd')
