python_day_07

Day 07

• 进程和线程
  进程：进程就是一个过程、一个任务。
  线程：一个进程里面至少有一个控制线程，线程用的是进程里面包含的一堆资源,线程仅仅是一个调度单位，不包含资源。

• 进程与线程的区别：
  1.一个进程由一个或者多个线程组成，线程是一个进程中代码的不同执行路线。
  2.切换进程需要的资源比切换线程的要多的多。
  3.线程共享同一片内存空间，而进程各有独立的内存空间

• 主线程与小弟线程
  线程是资源共享的，依赖于进程

	eg1:
	import _thread #多线程
	import win32api
	
	def show(i):
	    mystr = win32api.MessageBox(0,"你真好看","是璐璐说的",0)
	                     #（0代表系统，“你真好看”是内容，“是璐璐说的”代表标题，0代表窗口类型）
	
	for i in range(5):
	    _thread.start_new_thread(show,(i,))
	
	while True:# 这里加入死循环是为了主线程不死
	    pass

运行结果：

• 多线程速度
  线程不是同时执行的

eg1:
	import _thread
	import time
	
	def go():
	    for i in range(3):
	        print(i,">>>>>>>")
	        time.sleep(1)
	
	for i in range(2):
	    _thread.start_new_thread(go,())
	
	for j in range(6): #使主线程卡顿6秒
	    time.sleep(1)
	
	print('over')
运行结果：
	0 >>>>>>>
	0 >>>>>>>
	1 >>>>>>>
	1 >>>>>>>
	2 >>>>>>>
	2 >>>>>>>
	over

• 线程冲突
  几个线程同时抢夺资源

eg1:
	import _thread
	
	num = 0
	def add():
	    for _ in range(100):
	        global num
	        num += 1
	    print(num)
	
	for i in range(5):
	    _thread.start_new_thread(add,())
	# 这里就是线程冲突，5个线程同时抢夺num的资源
	
	while True:  # 防止主线程不死
	    pass
运行结果：
	100
	200
	400
	500
	300

• 基于类实现多线程（可以使用继承方法）

	import threading
	import win32api
	
	
	class Mythread(threading.Thread):   # 继承threading.Thread类
	    def run(self):  # 重写threading.Thread类中的run函数
	        win32api.MessageBox(0,"lala",'ningning',0)
	
	
	for i in range(3):  # 同时创建3个线程
	    t = Mythread()  # 初始化
	    t.start()  # 开启
	
	
	while True:
	    pass

运行结果：

• 类线程顺序风格

eg1:
	import threading
	import win32api
	
	
	class Mythread(threading.Thread):   # 继承threading.Thread类
	    def run(self):  # 定义函数
	        win32api.MessageBox(0,"太难了",'杨宁说今天学的',0)
	
	
	for i in range(3):
	    t = Mythread()  # 初始化
	    t.start()  # 开启
	    # 等待一个线程执行完毕，再执行下一个线程，一方面可以阻止脚本主线程死掉，另一方面也可以防止线程冲突的一种办法
	    t.join()
	# t.join() 如果将其放在外部的不确定因素是，系统给for 循环和下面的代码锁定了一片内存，当循环执行完成之后，
	# 内存就开锁了，但是里面的东西还依然存在，所以才结束一个窗体，game over就出来了，
	# 就和删除文件后，内存中可能还有文件一样的道理
	
	print("over")

运行结果：
（出现了三次窗口，一个窗口出现关掉后跳出了下一个窗口）

• 类线程的乱序风格

eg1:

运行结果：
（一次性跳出3个窗口，按出现顺序的截图）

练习：
利用多线程随机产生100个验证码

	import random
	import threading
	
	class Myhtread(threading.Thread):
	    def __init__(self,lock):
	        threading.Thread.__init__(self)
	        self.lock = lock
	        self.list_ = []
	    def run(self):
	        for i in range(50):
	            res = random.randrange(1000,9999)
	            print(res)
	            self.list_.append(res)
	
	            with self.lock:
	                self.write(self.list_)
	
	    
	    def write(self,num):
	        b = [str(x)+'\n' for x in num]
	        b = ''.join(b)
	        with open('res.txt',mode='a') as f:
	            f.write(b)
	
	if __name__ == '__main__':
	    ts =[]
	    lock = threading.Lock()
	    for i in range(2):
	        t = Myhtread(lock)
	        t.start()
	        ts.append(t)
	    for t in ts:
	        t.join()
	    print('over')

运行结果：
（出现了很多，只截取了一部分）

*基于类解决线程冲突Lock

	import threading
	
	num = 0
	mutex = threading.Lock()  # 创建一个锁，threading.Lock()是一个类
	
	
	class Myhtread(threading.Thread):
	    def run(self):
	        global num
	        if mutex.acquire(1):  # 如果锁成功，那么线程继续干活，如果锁失败，下面的线程一直等待锁成功，1，代表独占
	            for i in range(1000):  # 数字小的时候还是不会产生线程冲突的
	                num += 1
	            mutex.release()  # 写完一定要解锁
	        print(num)
	
	
	mythread = []
	for i in range(3):
	    t = Myhtread()
	    t.start()
	    mythread.append(t)
	
	for thread in mythread:
	    thread.join()  
	
	print("over")
运行结果：
	1000
	2000
	3000
	over

• 死锁
  死锁： 是两个或两个以上的进程或线程在执行过程中，争夺资源而造成的一种互相等待的现象

eg1:
	import threading
	import time
	
	boymutex = threading.Lock()  # 创建一个锁
	girlmutex = threading.Lock()  # 创建一个锁
	
	
	class boy(threading.Thread):
	    def run(self):
	        if boymutex.acquire(1):  # 锁定成功就继续执行，锁定不成功，就一直等待
	            print(self.name + "boy  say i  am sorry   up")
	            # time.sleep(3)  # 时间过短的话也可以并发执行，不会锁死
	
	            if girlmutex.acquire(1):  # 锁定不成功，因为下面已经锁定
	                print(self.name + "boy  say i  am sorry   down")
	                girlmutex.release()
	            boymutex.release()
	
	class girl(threading.Thread):
	    def run(self):
	        if girlmutex.acquire(1):  # 锁定成功就继续执行，锁定不成功，就一直等待
	            print(self.name + "girl say i  am sorry  up")
	            # time.sleep(3)
	
	            if boymutex.acquire(1):  # 锁定不成功，同理上面已经锁定一直等待
	                print(self.name + "girl say i  am sorry  down")
	                boymutex.release()
	            girlmutex.release()
	
	'''
	这种例子时间过短是无法很好的产生死锁
	for i in range(10):
	    Mythread1().start()
	    Mythread2().start()
	'''
	for i in range(1000):
	    boy().start()
	    girl().start()

• 线程通信

	import threading
	import time
	
	
	def goevent():
	    e = threading.Event()  # 事件
	
	    def go():
	        e.wait()  # 等待事件，线程卡顿，等待set消息
	        print("go")
	
	    threading.Thread(target=go).start() # 需要创建一个线程
	    return e
	
	t = goevent()
	
	time.sleep(3)
	t.set()  # 激发事件

限制最大线程数