线程
什么是线程
进程:资源单位(起一个进程仅仅只是在内存空间中开辟一块独立的空间)
线程:执行单位(真正被cpu执行的其实是进程里面的线程，线程指的就是代码的执行过程，执行代码中所需要使用到的资源都找所在的进程索要)
每一个进程肯定自带一个线程
将操作系统比喻成一个大的工厂，那么进程就相当于工厂里面的车间，而线程就是车间里面的流水线。
为什么要有线程
开设进程
1.申请内存空间 耗资源
2.“拷贝代码” 耗资源
开线程
一个进程内可以开设多个线程，在用一个进程内开设多个线程无需再次申请内存空间操作
总结：
开设线程的开销要远远的小于进程的开销
同一个进程下的多个线程数据是共享的!!!
开设线程的两种方式
开启线程不需要在main下面执行代码 直接书写就可以，但是还是习惯性的将启动命令写在main下面
第一种方式
# from threading import Thread # import time # # # def task(name): # print('%s is running'%name) # time.sleep(1) # print('%s is over'%name) # # t = Thread(target=task,args=('ys',)) # t.start() # 创建线程的开销非常小 几乎是代码一执行线程就已经创建了 # print('主')
第二种方式
from threading import Thread import time class MyThead(Thread): def __init__(self, name): # 重写了别人的方法 又不知道别人的方法里有啥 你就调用父类的方法 super().__init__() self.name = name def run(self): print('%s is running'%self.name) time.sleep(1) print('egon DSB') if __name__ == '__main__': t = MyThead('ys') t.start() print('主')
线程对象的jion方法
from threading import Thread import time def task(name): print('%s is running'%name) time.sleep(3) print('%s is over'%name) if __name__ == '__main__': t = Thread(target=task,args=('ys',)) t.start() t.join() # 主线程等待子线程运行结束再执行 print('主')
同一个进程下的多个线程数据是否共享
from threading import Thread import time money = 100 def task(): global money money = 666 print(money) if __name__ == '__main__': t = Thread(target=task) t.start() t.join() print(money)
线程对象
统计当前正在活跃的线程数
print('主',active_count())
获取线程名字
print('主',current_thread().name)
验证线程是否在同一个进程
from threading import Thread, active_count, current_thread import os,time def task(n): print('hello world',os.getpid()) time.sleep(n) if __name__ == '__main__': t = Thread(target=task,args=(1,)) t.start() print('主',os.getpid())
代码
from threading import Thread, active_count, current_thread import os,time def task(n): # print('hello world',os.getpid()) print('hello world',current_thread().name) time.sleep(n) if __name__ == '__main__': t = Thread(target=task,args=(1,)) t1 = Thread(target=task,args=(2,)) t.start() t1.start() t.join() print('主',active_count()) # 统计当前正在活跃的线程数 # print('主',os.getpid()) # print('主',current_thread().name) # 获取线程名字
守护线程
主线程运行结束之后不会立刻结束 会等待所有其他非守护线程结束才会结束，因为主线程的结束意味着所在的进程的结束
# from threading import Thread # import time # # # def task(name): # print('%s is running'%name) # time.sleep(1) # print('%s is over'%name) # # # if __name__ == '__main__': # t = Thread(target=task,args=('egon',)) # t.daemon = True # t.start() # print('主')
迷惑性的例子
from threading import Thread import time def foo(): print(123) time.sleep(1) print('end123') def func(): print(456) time.sleep(3) print('end456') if __name__ == '__main__': t1 = Thread(target=foo) t2 = Thread(target=func) t1.daemon = True t1.start() t2.start() print('主.......')
线程互斥锁
lock
from threading import Thread,Lock import time money = 100 mutex = Lock() def task(): global money mutex.acquire() tmp = money time.sleep(0.1) money = tmp - 1 mutex.release() if __name__ == '__main__': t_list = [] for i in range(100): t = Thread(target=task) t.start() t_list.append(t) for t in t_list: t.join() print(money)
当多个人同时操作同一份数据，数据不安全的情况下，就加锁处理。将并发变成串行，牺牲了效率，增加了安全
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. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)
解译
在CPython解释器中GIL是一把互斥锁，用来阻止同一个进程下的多个线程的同时执行(同一个进程下的多个线程无法利用多核优势)。
因为cpython中的内存管理不是线程安全的
内存管理(垃圾回收机制)
引用计数
标记清除
分代回收
总结：
1、GIL不是python的特点而是CPython解释器的特点
2、GIL是保证解释器级别的数据的安全
3、GIL会导致同一个进程下的多个线程的无法同时执行即无法利用多核优势
4、针对不同的数据还是需要加不同的锁处理
5、解释型语言的通病:同一个进程下多个线程无法利用多核优势
GIL与普通互斥锁的区别
from threading import Thread,Lock import time mutex = Lock() money = 100 def task(): global money
# 互斥锁的另种写法 # with mutex: # tmp = money # time.sleep(0.1) # money = tmp -1 mutex.acquire() tmp = money time.sleep(0.1) # 只要你进入IO了 GIL会自动释放 money = tmp - 1 mutex.release() if __name__ == '__main__': t_list = [] for i in range(100): t = Thread(target=task) t.start() t_list.append(t) for t in t_list: t.join() print(money) """ 100个线程起起来之后 要先去抢GIL 我进入io GIL自动释放 但是我手上还有一个自己的互斥锁 其他线程虽然抢到了GIL但是抢不到互斥锁 最终GIL还是回到你的手上 你去操作数据 """
同一个进程下的多线程无法利用多核优势，是不是就没有用了
理论
""" 多线程是否有用要看具体情况 单核:四个任务(IO密集型\计算密集型) 多核:四个任务(IO密集型\计算密集型) """ # 计算密集型 每个任务都需要10s 单核(不用考虑了) 多进程:额外的消耗资源 多线程:介绍开销 多核 多进程:总耗时 10+ 多线程:总耗时 40+ # IO密集型 多核 多进程:相对浪费资源 多线程:更加节省资源
代码
计算密集型
# from multiprocessing import Process # from threading import Thread # import os,time # # # def work(): # res = 0 # for i in range(10000000): # res *= i # # if __name__ == '__main__': # l = [] # print(os.cpu_count()) # 获取当前计算机CPU个数 # start_time = time.time() # for i in range(12): # p = Process(target=work) # 1.4679949283599854 # t = Thread(target=work) # 5.698534250259399 # t.start() # # p.start() # # l.append(p) # l.append(t) # for p in l: # p.join() # print(time.time()-start_time)
IO密集型
from multiprocessing import Process from threading import Thread import os,time def work(): time.sleep(2) if __name__ == '__main__': l = [] print(os.cpu_count()) # 获取当前计算机CPU个数 start_time = time.time() for i in range(4000): # p = Process(target=work) # 21.149890184402466 t = Thread(target=work) # 3.007986068725586 t.start() # p.start() # l.append(p) l.append(t) for p in l: p.join() print(time.time()-start_time)
总结
多进程和多线程都有各自的优势
写项目的时候通常可以多进程下面再开设多线程，这样的话既可以利用多核也可以节省资源消耗
死锁与递归锁
当你知道锁的使用抢锁必须要释放锁，其实你在操作锁的时候也极其容易产生死锁现象(整个程序卡死 阻塞)
from threading import Thread, Lock import time mutexA = Lock() mutexB = Lock() # 类只要加括号多次 产生的肯定是不同的对象 # 如果你想要实现多次加括号得到的是相同的对象 单例模式 class MyThead(Thread): def run(self): self.func1() self.func2() def func1(self): mutexA.acquire() print('%s 抢到A锁'% self.name) # 获取当前线程名 mutexB.acquire() print('%s 抢到B锁'% self.name) mutexB.release() mutexA.release() def func2(self): mutexB.acquire() print('%s 抢到B锁'% self.name) time.sleep(2) mutexA.acquire() print('%s 抢到A锁'% self.name) # 获取当前线程名 mutexA.release() mutexB.release() if __name__ == '__main__': for i in range(10): t = MyThead() t.start()
递归锁(RLock)
特点
可以被连续的acquire和release
但是只能被第一个抢到这把锁执行上述操作
它的内部有一个计数器 每acquire一次计数加一 每realse一次计数减一，只要计数不为0 那么其他人都无法抢到该锁
实现
from threading import Thread, Lock, RLock import time mutexA = mutexB = RLock() class MyThead(Thread): def run(self): self.func1() self.func2() def func1(self): mutexA.acquire() print('%s 抢到A锁'% self.name) # 获取当前线程名 mutexB.acquire() print('%s 抢到B锁'% self.name) mutexB.release() mutexA.release() def func2(self): mutexB.acquire() print('%s 抢到B锁'% self.name) time.sleep(2) mutexA.acquire() print('%s 抢到A锁'% self.name) # 获取当前线程名 mutexA.release() mutexB.release() if __name__ == '__main__': for i in range(10): t = MyThead() t.start()
信号量
信号量在不同的阶段可能对应不同的技术点，在并发编程中信号量指的是锁!!!
大白话理解：
如果我们将互斥锁比喻成一个厕所的话，那么信号量就相当于多个厕所
代码演示
from threading import Thread, Semaphore import time import random sm = Semaphore(5) # 括号内写数字 写几就表示开设几个坑位 def task(name): sm.acquire() print('%s 正在蹲坑'% name) time.sleep(random.randint(1, 5)) sm.release() if __name__ == '__main__': for i in range(20): t = Thread(target=task, args=('伞兵%s号'%i, )) t.start()
Event事件
一些进程/线程需要等待另外一些进程/线程运行完毕之后才能运行，类似于发射信号一样
代码演示
from threading import Thread, Event import time event = Event() # 造了一个红绿灯 def light(): print('红灯亮着的') time.sleep(3) print('绿灯亮了') # 告诉等待红灯的人可以走了 event.set() def car(name): print('%s 车正在灯红灯'%name) event.wait() # 等待别人给你发信号 print('%s 车加油门飙车走了'%name) if __name__ == '__main__': t = Thread(target=light) t.start() for i in range(20): t = Thread(target=car, args=('%s'%i, )) t.start()
线程q
同一个进程下多个线程数据是共享的，为什么同一个进程下还会去使用队列呢，因为队列是管道 + 锁，所以用队列还是为了保证数据的安全
1、队列q 先进先出
# q = queue.Queue(3) # q.put(1) # q.get() # q.get_nowait() # q.get(timeout=3) # q.full() # q.empty()
2、后进先出q
# q = queue.LifoQueue(3) # last in first out # q.put(1) # q.put(2) # q.put(3) # print(q.get()) # 3
3、优先级q 你可以给放入队列中的数据设置进出的优先级
q = queue.PriorityQueue(4) q.put((10, '111')) q.put((100, '222')) q.put((0, '333')) q.put((-5, '444')) print(q.get()) # (-5, '444') # put括号内放一个元祖 第一个放数字表示优先级 # 需要注意的是 数字越小优先级越高!!!
TCP服务端实现并发的效果
服务端
import socket from threading import Thread from multiprocessing import Process server =socket.socket() # 括号内不加参数默认就是TCP协议 server.bind(('127.0.0.1',8080)) server.listen(5) # 将服务的代码单独封装成一个函数 def talk(conn): # 通信循环 while True: try: data = conn.recv(1024) # 针对mac linux 客户端断开链接后 if len(data) == 0: break print(data.decode('utf-8')) conn.send(data.upper()) except ConnectionResetError as e: print(e) break conn.close() # 链接循环 while True: conn, addr = server.accept() # 接客 # 叫其他人来服务客户 # t = Thread(target=talk,args=(conn,)) t = Process(target=talk,args=(conn,)) t.start()
客户端
import socket client = socket.socket() client.connect(('127.0.0.1',8080)) while True: client.send(b'hello world') data = client.recv(1024) print(data.decode('utf-8'))
