PaythonDay07

多线程

1.最简单的函数线程

import _thread
import time
def go():
	for i in range(5):
		print(i,"------------")
		time.sleep
for i in rane(5):
	_thread.start_new_thread(go,())
for i in range(6):
	time.sleep(1)
print("over")	

2.线程冲突

每一个线程会抢占资源，谁先抢到谁先执行，因此会导致结果错误。

import _thread

num = 0
def add():
    for _ in range(1000000):
        global num
        num += 1
    print(num)
for i in range(5):
    _thread.start_new_thread(add,())
while True:  # 防止主线程不死
    pass

3.最简单的类实现多线程

类中要重写 run 函数

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

4.join

加了join(）后就等于给主进程或者主线程里的线程一个锁定在一个内存里，当其中的线程执行完毕，主线程或主进程才会执行

import threading
import win32api


class Mythread(threading.Thread):   # 继承threading.Thread类
    def run(self):  # 定义函数
        win32api.MessageBox(0,"hello",'joker',0)
for i in range(5):
    t = Mythread()  # 初始化
    t.start()  # 开启
   t.join()
print("game over")

5.线程的乱序

import threading
import win32api


class Mythread(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), 'joker', 0)
        print(self.getName())  # 获取线程名


Mythd = []
for i in range(5):
    t = Mythread(i)  # 初始化
    print(i)
    t.start()  # 开启
    Mythd.append(t)  # 将乱序线程（同时抢夺run这个函数）加入列表

for j in Mythd:
    # 这里与顺序不同，上面显示所有的线程都加入Mthd列表（所以一次性跳出5个窗口，但是主线程还没死，因为有join卡住）。
    # j是线程
    j.join()  # 这里主线程同时等待所有线程都执行完毕，才执行“game over”
print("game over")

6.锁

创建一个锁等于给所有的线程建立了一个私人空间，就像给一个单人卫生间上了一把锁，当有人在卫生间的时候，别人只能在外边等候，不能影响里边上厕所的人，里面的人出去的时候一定要打开锁，不然就出不去。

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

7死锁

就好比俩个人同住在一个大的房间里，一个睡在里屋，一个睡在外屋，睡在里屋的人要经过外屋才能进去，如果外屋的人先进去了，那么就会出现锁死的情况

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


# 开启两个线程
# boy1 = boy()   # Thread-1boy 第一个线程
# boy1.start()
# girl1 = girl()
# girl1.start()
'''
这种例子时间过短是无法很好的产生死锁
for i in range(10):
    Mythread1().start()
    Mythread2().start()

'''
for i in range(1000):
    boy().start()
    girl().start()

8.信号限制线程数量

import threading

import time

sem = threading.Semaphore(2)  # 限制最大线程数为2个
def gothread():
    with sem:  # 锁定数量
        for i in range(10):
            print(threading.current_thread().name, i)  # 打印线程名字
            time.sleep(1)


for i in range(5):
    threading.Thread(target=gothread).start()  # 乱序执行多线程，就可以考虑为有些cpu牛逼些能够执行快一点

9.线程通信

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