多线程 Threading

1.1 什么是多线程?

多线程 Threading 是一种让程序拥有分身效果. 能同时处理多件事情. 一般的程序只能从上到下一行行执行代码, 不过 多线程 (Threading) 就能打破这种限制. 让你的程序鲜活起来.

1.2 添加多线程

import threading
def thread_job():
    print("我是被添加的线程, 名称是: %s"% threading.current_thread())
def main():
    added_thread = threading.Thread(target=thread_job) # 添加线程(定义线程)
    added_thread.start()    # 启动线程
    print(threading.active_count()) # 查看当前可运行几个线程!
    print(threading.enumerate())    # 查看当前运行了那几个线程? MainThread 表示主进程, Thread 表示扩展的进程
    print(threading.current_thread()) # 查看当前运行的线程是那个?
if __name__ == '__main__':
    main()

1.3 join() 功能

join()的功能 等待该线程结束

# 多线程
import threading
import time
def thread_job():
    print(f"T1 start\n")
    for i in range(10):
        time.sleep(0.1)
    print(f"T1 finish\n")
def T2_job():
    print(f"T2 start\n")
    print(f"T2 finish\n")
def main():
    # print(threading.active_count()) # 查看当前可运行几个线程!
    # print(threading.enumerate())    # 查看当前运行了那几个线程? MainThread 表示主进程, Thread 表示扩展的进程
    # print(threading.current_thread()) # 查看当前运行的线程是那个?
    added_thread = threading.Thread(target=thread_job, name="T1") 
    thread2 = threading.Thread(target=T2_job, name="T2")
    added_thread.start()
    thread2.start()
    added_thread.join() # 等待这个线程结束
    thread2.join() # 等待这个线程结束
    print("all done\n")
"""
    有时候 t2 的线程比 t1 的线程 先结束, 因为t2的线程做的任务比较简单
"""
if __name__ == '__main__':
    main()

1.4 存储进程结果 Queue

# 多线程 queue
"""
    问题1: 在多线程当中,它是不能返回出来一个值的, 那么怎么解决?
        使用 模块 queue 和大写的 Queue 
"""
import threading
import time
from queue import Queue
def job(l,q):
    # 对每一个列表的值进行 2次方计算
    for i in range(len(l)):
        l[i] = l[i]**2
    q.put(l)
def multithreading():
    q = Queue()
    threads = []
    data = [[1,2,3],[3,4,5],[4,4,4],[5,5,5]]
    for i in range(4):
        t = threading.Thread(target=job, args=(data[i],q))
        t.start()
        # 把启动的线程 都加入到列表中
        threads.append(t)
    # 批量 等待线程结束, 结束之后,会把每个线程的返回数据 保存在q里
    for thread in threads:
        thread.join()
    results = []  # 定义1个空的变量用来保存 多线程(每个线程返回的值)
    for _ in range(4):
        results.append(q.get()) # 取出每个线程的值
    print(results)
if __name__ == '__main__':
    multithreading()

打印: [[1, 4, 9], [9, 16, 25], [16, 16, 16], [25, 25, 25]]

1.5 GIL 不一定有效率

1.6 线程锁 Lock

如果不设置 线程锁, 则会打印的数据很乱

# 线程锁
"""
    引用 lock = threading.Lock()
    加锁 lock.acquire()
    解锁 lock.release()
"""
import threading
def job1():
    global A, lock
    lock.acquire()
    for i in range(10):
        A += 1
        print("job1", A)
    lock.release()
def job2():
    global A, lock
    lock.acquire()
    for i in range(10):
        A += 10
        print("job2", A)
    lock.release()
if __name__ == '__main__':
    lock = threading.Lock()
    A =0;
    t1 = threading.Thread(target=job1)
    t2 = threading.Thread(target=job2)
    t1.start()
    t2.start()
    t1.join()
    t2.join()