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()  # 激发事件

限制最大线程数