多线程——Python

利用Python封装好的一个模块threading

1.怎么用？import导入

import threading
import time

# 多线程执行没有先后顺序，CPU随机选择
# 主线程会等待所有子线程死掉，最后自己才死掉


def test01():
    for i in range(5):
        print("我是子线程test01:%s" % (i))
        time.sleep(1)


def test02():
    for i in range(5):
        print("我是子线程test02:%s" % (i))


def main():
    print("hahah")
    t1 = threading.Thread(target=test01)
    t2 = threading.Thread(target=test02)
    t1.start()
    t2.start()
    print("hehe")
    print('23333')


if __name__ == "__main__":
    main()

也可以这样用

import threading
import time


class DouBan(threading.Thread):
    # def __init__(self, name):
    #     self.name = name

    def register(self):
        print("开始注册")

    def login(self):
        print("%s开始登录")

    def exit(self):
        print("正在退出！")

    def run(self):
        self.register()
        self.login()
        self.exit()

def main():
    print("---------正在测试---------")
    t1 = DouBan()
    t1.start()
    print("----------测试结束--------")


if __name__ == "__main__":
    main()

2.多线程共享全局变量带来的问题（如果在同一时间，不同线程都对去全局变量进行更改，到底听谁的？）

用互斥锁解决

import threading

g_num = 0


def test_A():
    global g_num

    for i in range(1000000):
        mutex.acquire()
        g_num += 1
        print("test_A的测试结果：%d" % (g_num))
        mutex.release()


def test_B():
    global g_num

    for i in range(1000000):
        mutex.acquire()
        g_num += 1
        mutex.release()
    print('test_B的测试结果：%d' % (g_num))

# 创建一个互斥锁
# 默认是没上锁状态
mutex = threading.Lock()


def main():
    a = threading.Thread(target=test_A)
    b = threading.Thread(target=test_B)
    a.start()
    b.start()


if __name__ == "__main__":
    main()

互斥锁同样会带来问题：死锁

银行家算法