python 07

1.主线程与小弟线程
调用 _thread 模块中的start_new_thread()函数来产生新线程。
语法 如下:
_thread.start_new_thread ( function, args[, kwargs] )
参数说明:
function - 线程函数。
args - 传递给线程函数的参数,他必须是个tuple类型。
kwargs - 可选参数。

import _thread   # 多线程            
import win32api

def show(i):
    # 0 代表系统，代表窗口类型0，1，2，3
    mystr = win32api.MessageBox(0,"你真帅","来自Joker的问候",0)


for i in range(5):   # 这是小弟线程
    _thread.start_new_thread(show,(i,))  # 前面是执行函数，后面是一个元组,可以不写前提是函数没有形参


while True:  # 在这里加入死循环是为了脚本主线程不死，小弟线程才能运行
    pass

2.用函数创建多线程，但是需要处理让脚本主线程不死

python`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是线程
    j.join() # 这里主线程同时等待所有线程都执行完毕，才执行“game over”
print("game over")

'''

3.类封装式
threading线程模块提供了Thread类来处理线程，Thread类提供了以下方法:
run(): 用以表示线程活动的方法。
start():启动线程活动。
join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
isAlive(): 返回线程是否活动的。
getName(): 返回线程名。
setName(): 设置线程名。

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.#基于函数构造实现多线程

import threading
import win32api

def show():
    win32api.MessageBox(0, "这是一个测试", "来自Joker", 0)

#target=show是线程函数，args=()是参数
threading.Thread(target=show, args=()).start()
threading.Thread(target=show, args=()).start()

5.线程冲突
多个线程抢夺同一资源

import _thread

num = 0
def add():
    for _ in range(10000):
        global num
        num += 1
    print(num)
'''
for j in range(5):
    add()
'''
for i in range(5):
    _thread.start_new_thread(add,())
#线程冲突，5个线程同时抢夺num的资源，导致最后结果错误
'''
1144840
1488805
1671079
1700819
1920182
'''
while True:  # 防止主线程不死
    pass

6.lock解决线程冲突（加锁）

class Mythread(threading.Thread):   # 继承threading.Thread类
    def run(self):  # 定义函数
        win32api.MessageBox(0,"hello",'joker',0)

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.死锁：
定义：一个资源多次调用，而多次调用对方都未能释放该资源就会造成一种互相等待的现象，它们都无法推进下去，此时称系统处于死锁状态或者系统产生了死锁。

若存在两个线程：线程A 与线程B

若线程A与线程B都 需要资源1与资源2才能执行

现在线程A拿到了资源1，线程B拿到了资源2，此时就构成了死锁。

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(1000):
    boy().start()
    girl().start()
 '''

8.信号限制线程数量

9.锁定匹配数量

import threading
 #为了合理利用资源
 #凑出线程数量，也就是说一定要至少凑成两个才能执行
 #换而言之，也就是说只有创建线程数是2，或者2的倍数才能全部执行                                  
bar = threading.Barrier(2)

def sever():
   print(threading.current_thread().name,"start")
    bar.wait()
    print(threading.current_thread().name,"end")

for i in range(3):
    threading.Thread(target=sever).start()

'''
Thread-1 start
Thread-2 start
Thread-2 end
Thread-1 end
Thread-3 start
这里出现Thread-3 是因为锁定在"start"之后，所以最后面Thread-3 end 是无法出现的
'''