day40 线程
目录
一、开启线程的两种方式
from threading import Thread
import time
# 直接创建
def func():
time.sleep(1)
print('aaa')
if __name__ == '__main__':
t = Thread(target=func)
t.start()
print('xxx')
# 类继承创建
class MyThread(Thread):
def __init__(self,name):
super().__init__()
self.name = name
def run(self):
print('start....')
print(self.name)
if __name__ == '__main__':
t = MyThread('hz')
t.start()
print('🐖')
二、用进程和线程分别实现tcp
服务端
from multiprocessing import Process
from threading import Thread
import socket
def school(conn):
while True:
res = conn.recv(1024)
if len(res) == 0:break
res = res.decode('utf-8')
msg = f'{res}已被我校录取'
print(msg)
conn.send(msg.encode("utf-8"))
conn.close()
if __name__ == '__main__':#windows内的进程对象必须在mian里创建否则会报错
s = socket.socket()
s.bind(('127.0.0.1',8080))
s.listen(5)
while True:
conn,addr = s.accept()
# t = Thread(target=school,args=(conn,))
t = Process(target=school,args=(conn,))
t.start()
客户端
import socket
s = socket.socket()
s.connect(('127.0.0.1',8080))
while True:
msg = input("your name:")
s.send(msg.encode('utf-8'))
data = s.recv(1024)
print(data.decode('utf-8'))
三、线程对象实现join方法
from threading import Thread
import time
def text():
print(123)
time.sleep(2)
if __name__ == '__main__':
t = Thread(target=text)
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)
五、线程对象属性及其他方法
from threading import Thread,active_count,current_thread
import time
a = 100
def text():
global a
a = 111
time.sleep(2)
print(a,)
if __name__ == '__main__':
t = Thread(target=text)
t1 = Thread(target=text)
t.start()
t1.start()
t.join()
print(active_count())# 统计当前活跃线程数，本身mian线程也是
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('主.......')
七、线程互斥锁
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.)
"""
"""
python解释器其实有多个版本
Cpython
Jpython
Pypypython
但是普遍使用的都是CPython解释器
在CPython解释器中GIL是一把互斥锁，用来阻止同一个进程下的多个线程的同时执行
同一个进程下的多个线程无法利用多核优势！！！
疑问:python的多线程是不是一点用都没有？？？无法利用多核优势
因为cpython中的内存管理不是线程安全的
内存管理(垃圾回收机制)
1.应用计数
2.标记清楚
3.分代回收
"""
"""
重点:
1.GIL不是python的特点而是CPython解释器的特点
2.GIL是保证解释器级别的数据的安全
3.GIL会导致同一个进程下的多个线程的无法同时执行即无法利用多核优势(******)
gil锁相当于线程锁，当一个进程内有多个线程出现，谁先执行取决于谁先拿到了gil锁，这个锁帮助这条线程打开了cup的执行权限，其他没有拿到的进程只能等待。
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线程同时创建完毕，这100个线程需要执行了，他们就会去抢GIL锁，抢到的那个可以开始执行代码，遇到了我们写的互斥锁，此时没有其他线程到了这一步就没有可以抢他的锁了，获取了money数据后，进入了io，此时这个线程就施放了GIL锁。在他io的这段时间，其他99个线程在争抢GIl锁，但是即使抢到了gil锁，他们也因为互斥锁把数据锁住了，导致他们无法获取数据，此时第一个抢到gil锁的线程结束io修改了数据施放了互斥所，也施放了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)
总结
进程和线程各有自己的优缺点
- 进程
- 优点：可以并发执行，可以实现多核工作，在计算密集型程序效果显著
- 缺点：开启多个线程会造成重复资源占用
- 线程
- 优点：节省了空间，在io密集型程序效果显著，因为在线程执行的时候需要抢到gil锁才能工作，io会让抢到的线程主动释放锁，加快了程序的执行，看上去像是实现了并发
- 缺点：不能并发执行
通常可以多进程多线程结合使用，既利用了多核优势，又减少消耗资源。
