学python的第七天 啦啦啦啦

今天是2019.08.22 。

1.主线程与小弟线程

2.多线程速度

import _thread

import time

def go():
for i in range(5):
print(i,"---------")
time.sleep(1)
for i in range(5): # 同时执行5次
_thread.start_new_thread(go,())

for j in range(6):#让主线程卡顿6秒
time.sleep(1)
print(“over”)

一般不用_thread，不好用

3.线程冲突

import_thread
num=0
def add():
for _ in range(1000000)
global num
num +=1
print(num)
for j in range (5):
add()
for i in range(5):
_thread.start_new_thread(add,())
这里就发生了线程冲突，5个线程同时抢占num的资源，导致最后结果错误
while True:#防止主线程不死
pass

4.基于类实现多线程

import threading
NUM=0
class zsc(threading.Thread):#继承threading.Thread类
def init(self):
threading.Thread.init(self)
def run(self):#重写threading.Thread类中的run函数
global NUM
for _ in range(1000):
NUM +=1
print(NUM)
if name == “main”:
for i in range(5):#同时创建5个线程
t.start()#开启
while 1:
pass

两个线程，随机100个四维数码验证码
import threading
import random

class zsc(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',moda='a')as file:
        file.write(b)

if name==‘main’:
ts=[]
lock=threading.Lock()
for i in range(2):
t=zsc(lock)
t.start()
ts.append(t)
for t in ts:
t.join()
print(‘Over’)

5.类线程顺序风格

import threading
import win32api
class Myhtread(threading.Thread):#继承threading.Thread类
def run(self):#定义函数
win32api.MessageBox(0,“hello”,‘joker’,0)
for i in range(5)：
t=Myhtread()#初始化
t.start()
t.join()
print(“game over”)

6.类线程的乱序风格

import threading
import win32api
class Myhtread(threading.Thread):#继承threading.Thread类
def init(self,num):
threading.Thread.init(self)#父类初始化
self.num =num
def run(self):#定义函数
win32api.MessageBox(0,“hello”+str(self.num),‘zsc’,0)
print(self.getName())#获取线程名
Mythd=[]
for i in range(5)：
t = Myhtread(i) # 初始化
print(i)
t.start() # 开启
Mythd.append(t) # 将乱序线程（同时抢夺run这个函数）加入列表
for j in Mythd:# 这里与顺序不同，上面显示所有的线程都加入Mthd列表（所以一次性跳出5个窗口，但是主线程还没死，因为有join卡住）。
j.join() # 这里主线程同时等待所有线程都执行完毕，才执行“game over”
print(“game over”)

7.基于类解决线程冲突

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(5):
t = Myhtread()
t.start()
mythread.append(t)
for thread in mythread:
thread.join() # 或者直接将thread.join()加入for i in range(5)，也能解决线程冲突，但是貌似就变成单线程了
print(“game over”)

8.死锁

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()

9.Rlock

(了解一下就好了)
import threading
num = 0
mutext = threading.RLock() # PLOCK避免单线程死锁
class Mythreading(threading.Thread):
def run(self):
global num
if mutext.acquire(1):
num += 1
print(self.name, num)
if mutext.acquire(1):
num += 1000
mutext.release()
mutext.release()
for i in range(5): # 开启5个进程
t = Mythreading()
t.start()

10.创建多线程

第一种用函数创建多线程，但是需要处理让脚本主线程不死
import threading
import win32api
class Mythread(threading.Thread): # 继承threading.Thread类
def run(self): # 定义函数
win32api.MessageBox(0, “hello”, ‘joker’, 0)
Mythd = []
for i in range(5):
t = Mythread() # 初始化
print(i)
t.start() # 开启
Mythd.append(t) # 将乱序线程（同时抢夺run这个函数）加入列表
for j in Mythd:
# 这里与顺序不同，上面显示所有的线程都加入Mthd列表（所以一次性跳出5个窗口，但是主线程还没死，因为有join卡住）。
j.join() # 这里主线程同时等待所有线程都执行完毕，才执行“game over”
print(“game over”)