day39作业:验证GIL,递归锁,event事件,线程池

1 通过启动跟自己机器cpu相同的进程和线程数，验证GIL的存在

from multiprocessing import Process
from threading import Thread
import time

def task():
	while True:
		pass
if __name__ == '__main__':
	for i in range(6):
		# t = Process(target=task,)
		t = Thread(target=task)
		t.start()

2 测试计算密集型和io密集型执行时间

from multiprocessing import Process
from threading import Thread
import time

def task():
	count=0
	for i in range(1000000):
		count+=i
if __name__ == '__main__':
	ctime=time.time()
	ll = []
	for i in range(10):
		# t = Process(target=task)  # 0.24833464622497559
		t = Thread(target=task)  # 0.5340824127197266
		t.start()
		ll.append(t)
	for t in ll:
		t.join()

	print(time.time()-ctime)

def task():
	time.sleep(2)

if __name__ == '__main__':
	ctime=time.time()
	ll=[]
	for i in range(10):
		# t = Process(target=task)  # 2.1586403846740723
		t = Thread(target=task)  # 2.0035741329193115
		t.start()
		ll.append(t)
	for t in ll:
		t.join()
	print(time.time()-ctime)

3 通过递归锁解决课上死锁现象

from threading import Thread,RLock
import time
import random

mutexA = mutexB = RLock()

def eat_apple(name):
	mutexA.acquire()
	print('%s获取到了a锁'%name)
	mutexB.acquire()
	print('%s获取到了b锁'%name)
	print('开始吃苹果,并且吃完了')
	mutexB.release()
	print('%s 释放了b锁'%name)
	mutexA.release()
	print('%s 释放了a锁'%name)

def eat_egg(name):
	mutexB.acquire()
	print('%s 获取到了b锁'%name)
	time.sleep(2)
	mutexA.acquire()
	print('%s 获取到了a锁'%name)
	print('开始吃鸡蛋,并且吃完了')
	mutexA.release()
	print('%s释放了a锁'%name)
	mutexB.release()
	print('%s释放了b锁'%name)

if __name__ == '__main__':
	ll=['egon','alex','tank']
	for name in ll:
		t = Thread(target=eat_apple,args=(name,))
		t1 = Thread(target=eat_egg,args=(name,))
		t.start()
		t1.start()

4 通过event事件，实现两个线程，一个线程读文件前一半，写入另一个文件，另一个线程读后一半写入文件

from threading import Thread,Event
import os
event=Event()

size=os.path.getsize('a.txt')

def read_first():
	with open('a.txt','r',encoding='utf-8')as f:
		n = size // 2
		data=f.read(n)
		print(data)
		print('我一半读完了,发个信号')
		event.set()
def read_last():
	event.wait()
	with open('a.txt','r',encoding='utf-8')as f:
		n = size // 2
		f.seek(n,0)
		data=f.read()
		print(data)

if __name__ == '__main__':
	t1=Thread(target=read_first)
	t2=Thread(target=read_last)
	t1.start()
	t2.start()

5 把上面的4的代码，通过线程池实现

from concurrent.futures import ThreadPoolExecutor

import os
pool = ThreadPoolExecutor(2)

size=os.path.getsize('a.txt')

def read_first():
	with open('a.txt','r',encoding='utf-8')as f:
		n = size // 2
		data=f.read(n)
		print(data)
		print('我一半读完了,发个信号')

def read_last():

	with open('a.txt','r',encoding='utf-8')as f:
		n = size // 2
		f.seek(n,0)
		data=f.read()
		print(data)
def call_back(f):
	# print(f.result(f))
	pass
if __name__ == '__main__':
	pool.submit(read_first).add_done_callback(call_back)
	pool.submit(read_last).add_done_callback(call_back)