多线程编程(Python版本)

引子01

# pip install pywin32
import win32api
'''
win32api.MessageBox(0代表系统,
"你的银行账户很危险"代表内容,
"来自国际黑客的问候"代表标题,
0代表不同类型
)
'''
for i in range(6):
    win32api.MessageBox(0,"你的银行账户很危险","来自国际黑客的问候",i)

# pip install pywin32
import _thread
import win32api
import threading

'''
win32api.MessageBox(0代表系统,
"你的银行账户很危险"代表内容,
"来自国际黑客的问候"代表标题,
0代表不同类型
)
'''


def show(i):
    win32api.MessageBox(0, "你的银行账户很危险" + str(i), "来自国际黑客的问候", i)


for i in range(5):
    _thread.start_new_thread(show, (i,))

show(100)








# pip install pywin32
import _thread
import win32api  # 引入系统函数
import threading
import time
import socket  # 网络通信 TCP,UDP


def show(i):
    win32api.MessageBox(0, "你的账户很危险"+str(i), "来自国际黑客的问候", 6)

'''
target=show线程函数

args=()参数
'''
threading.Thread(target=show, args=(1,)).start()
threading.Thread(target=show, args=(2,)).start()
threading.Thread(target=show, args=(3,)).start()

引子02

# pip install pywin32
import _thread
import win32api
import threading
import time


def go():
    for i in range(10):  # 10秒
        print(i, '-' * 10)
        time.sleep(1)


# 问题太慢
# for i in range(5):  # 50秒
#     go()

# 速度提高一点
for i in range(5):
    _thread.start_new_thread(go, ())

for i in range(12):  # 12秒
    time.sleep(1)

print("game over")

什么是多线程(thread)？

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务

应用Thread类的构造函数创建多线程

import time


# 导入threading 模块
import threading


def fun(i):  #定义每个线程要运行的函数
    print("running on number =\t", i)
    ''' 
        sleep()函数作用就是 告诉操作系统在一定时间内不在调用自己了，主动把时间片让出来给别的线程
    '''
    time.sleep(10)


def main():
    for i in range(1, 5):
        # 创建线程
        t = threading.Thread(target=fun, args=(i,))
        print("线程id号:\t", threading.get_ident())
        # 方法1
        print("当前处于alive状态的Thread对象数量:\t", threading.active_count())
        # 方法2
        print("当前处于alive状态的Thread对象数量::\t", threading.activeCount())
        # 方法1
        print("当前Thread对象:\t", threading.current_thread())
        # 方法2
        print("当前Thread对象:\t", threading.currentThread())
        print("当前处于alive状态的所有Thread对象列表:\t", threading.enumerate())
        print("返回主线程对象:\t", threading.main_thread())
        # 启动线程
        t.start()
        print("用来读取或者设置线程的名字:\t", t.name)  #获取线程名
        print("线程标识:\t", t.ident)
        print("线程是否是守护线程(返回结果是布尔值):\t", t.daemon) 
        # # 方法1
        print("测试线程是否处于alive状态:\t", t.is_alive())
        # # 方法2
        print("测试线程是否处于alive状态:\t", t.isAlive())


if __name__ == '__main__':
    main()

创建Thread子类构造多线程

import time

import tensorflow

# 导入threading 模块
import threading

# 定义线程子类
'''
定义线程子类
    线程子类包含__init__()和run()
'''


class MyThread(threading.Thread):
    '''
    threading.Thread的子类必须重写父类的__init__()和run()方法，
    并且在子类的__init__()方法中，要调用父类的__init__()
    '''
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):#定义每个线程要运行的函数
        print("线程开始:\t", self.name)


def main():
    t1 = MyThread()
    t1.start()
    print("用来读取或者设置线程的名字:\t", t1.name)
    print("线程标识:\t", t1.ident)
    print("线程是否是守护线程(返回结果是布尔值):\t", t1.daemon)
    # # 方法1
    print("测试线程是否处于alive状态:\t", t1.is_alive())
    # # 方法2
    print("测试线程是否处于alive状态:\t", t1.isAlive())

    t2 = MyThread()
    t2.start()
    print("用来读取或者设置线程的名字:\t", t2.name)
    print("线程标识:\t", t2.ident)
    print("线程是否是守护线程(返回结果是布尔值):\t", t2.daemon)
    # # 方法1
    print("测试线程是否处于alive状态:\t", t2.is_alive())
    # # 方法2
    print("测试线程是否处于alive状态:\t", t2.isAlive())


if __name__ == '__main__':
    main()

死锁例子

# pip install pywin32
import _thread
import win32api  # 引入系统函数
import threading
import time
import socket  # 网络通信 TCP,UDP

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()
boy1.start()

girl1 = Girl()
girl1.start()

死锁解决之术

# pip install pywin32
import _thread
import win32api  # 引入系统函数
import threading
import time
import socket  # 网络通信 TCP,UDP

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)
            boymutex.release()  # 男方先道歉
            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)
            # girlmutex.release() #女方先道歉
            if boymutex.acquire(1):  # 锁定不成功，就一直等待
                print(self.name + "girl say I am sorry down")
                boymutex.release()
            girlmutex.release()


# 开启两个线程

boy1 = Boy()
boy1.start()

girl1 = Girl()
girl1.start()

RLock锁

# pip install pywin32
import _thread
import win32api  # 引入系统函数
import threading
import time
import socket  # 网络通信 TCP,UDP

num = 0

'''
反复加锁 造成的 死锁
'''
# mutex = threading.Lock()
'''
解决办法 改为threading.RLock()
'''
mutex = threading.RLock() # RLock避免单线程死锁


class MyThread(threading.Thread):
    def run(self):
        global num  # 引用全局变量 需要用global 关键字
        if mutex.acquire(1):
            num += 1
            print(self.name, num)

            if mutex.acquire(1):
                num += 1000
                mutex.release()  # 释放锁

            mutex.release()


for i in range(5):  # 开启五个线程
    t = MyThread()
    t.start()

信号量

# pip install pywin32
import _thread
import win32api  # 引入系统函数
import threading
import time
import socket  # 网络通信 TCP,UDP

# 信号量解决 限制线程数量
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()

线程数量的限制操作

# pip install pywin32
import _thread
import win32api  # 引入系统函数
import threading
import time
import socket  # 网络通信 TCP,UDP
# 为了合理利用资源10000，必须N=10个线程一起执行
bar = threading.Barrier(2)  # 必须两一个线程一起执行


def server():
    print(threading.current_thread().name, "start")
    time.sleep(12)
    bar.wait()
    print(threading.current_thread().name, "end")


for i in range(5):
    threading.Thread(target=server).start()