Python3：多线程的使用(_thread和threading)

1.声明

当前的学习来源：Python核心编程书籍

2.使用当前_thread模块创建线程

1.当前的_thread实现多线程主要通过：_thread.start_new(执行的方法的名称,当前执行方法需要的参数)

# python3的多线程
import _thread  # 导入多线程的模块
import time  # 导入时间模块


def prit_time(thread_name, delay):
    count = 0
    while count < 5:
        time.sleep(delay)
        count += 1
        print("线程名：{0}，当前的时间为：{1}".format(thread_name, time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))


# 创建两个线程
try:
    _thread.start_new(prit_time, ("Thread-1", 2))
    _thread.start_new(prit_time, ("Thread-2", 4))
except:
    print("Error :线程无法启动线程")

while 1:
    pass

结果：
在这里插入图片描述

3.使用_thread的锁

通过_thread.allocate_lock() 获得锁，通过acquire()加锁，通过release()释放锁

# 用于测试当前的锁
import _thread

from time import sleep, ctime

loops = [4, 2]


def loop(nloop, nsec, lock):
    print("start loop :{0}, at:{1}".format(nloop, ctime()))
    sleep(nsec)
    print("loop:{0},done at :{1}".format(nloop, ctime()))
    lock.release() # 这里是释放锁


def main():
    print("starting at:{0}".format(ctime()))
    locks = []
    nloops = range(len(loops))

    for i in nloops:
        lock = _thread.allocate_lock() # 获得线程的本地锁
        lock.acquire()  # 开始加锁，获得锁并加锁
        locks.append(lock) # 项当前的锁集合中添加该锁

    for i in nloops:
        _thread.start_new(loop,(i, loops[i], locks[i])) # 这里是启动2个线程用来执行loop函数并传递参数

    # 反复检查锁是否被锁住，如果被锁住就一直死循环，否者停止循环检查
    for i in nloops:
        while locks[i].locked(): pass # 最后会阻塞当前的线程，反复检查当前的锁是否被锁住，如果被锁住就暂停等待解锁，才能让主线程停止
    # 当所有的线程都执行完毕后就会执行最后的打印
    print("all DONE at:{0}".format(ctime()))


if __name__ == "__main__":
    main()

4.使用更高级的threading模块

1.通过threading.Thread(执行的函数，name="执行线程的名称",args=(执行函数需要的参数))创建一个可执行的线程，就像java中的Thread一样

2.通过start方法实现线程的启动，通过join方法实现线程阻塞，跟java一摸一样

# 使用threading实现多线程的操作
import threading
import time


# 定义统计的数量
class Sum:
    count = 0


# 使用三个线程执行当前的Sum.count++操作的时候就出现了线程安全问题，注意这里的target=sum,如果target=sum()就会让main线程执行
# 所以这个里需要加锁
def sum():
    while Sum.count < 10:
        time.sleep(1)
        Sum.count += 1
        current_name = threading.currentThread().getName()
        # 获取当前执行线程的名称
        current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())  # 获取当前执行的时间
        print("{0}:当前执行操作的时间：{1},当前count的结果为：{2}".format(current_name, current_time, Sum.count))


def main():
    print("线程开始执行。。。")
    threading.Thread(target=sum, name="线程一").start()
    threading.Thread(target=sum, name="线程二").start()
    threading.Thread(target=sum, name="线程三").start()
    print("线程结束执行。。。")


if __name__ == '__main__':
    main()

执行的结果：
在这里插入图片描述
存在多线程的安全问题

5.使用threading实现锁

通过threading.Lock()获得锁，通过acquire()实现加锁，通过release()释放锁

# 使用threading实现多线程的操作
import threading
import time


# 定义统计的数量
class Sum:
    count = 0
    thread_lock = threading.Lock()


# 使用三个线程执行当前的Sum.count++操作的时候就出现了线程安全问题，注意这里的target=sum,如果target=sum()就会让main线程执行
# 所以这个里需要加锁
def sum():
    while Sum.count < 10:
        time.sleep(1)
        # 使用锁的方式实现线程安全以及同步
        Sum.thread_lock.acquire()
        Sum.count += 1
        current_name = threading.currentThread().getName()
        # 获取当前执行线程的名称
        current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())  # 获取当前执行的时间
        print("{0}:当前执行操作的时间：{1},当前count的结果为：{2}".format(current_name, current_time, Sum.count))
        Sum.thread_lock.release()  # 释放锁


def main():
    print("线程开始执行。。。")
    threading.Thread(target=sum, name="线程一").start()
    threading.Thread(target=sum, name="线程二").start()
    threading.Thread(target=sum, name="线程三").start()
    print("线程结束执行。。。")


if __name__ == '__main__':
    main()