import threading

threading.active_count()  # 显示有多少个已经激活的线程

threading.enumerate()  # 显示已经激活的现场具体情况

threading.current_thread()  # 显示正在运行的线程

def thread_job():
    print("Thid is an added Thread, number is %s" % threading.current_thread())

def main():
    added_thread = threading.Thread(target=thread_job)  # 添加一个线程: 目标 thread_job
    added_thread.start()  # 运行这个线程
 

if __name__ == "__main__":
    main()

import threading
import time

def thread_job():
    print("T1start\n")
    for i in range(10):
        time.sleep(0.1)  # 每步暂停 0.1 秒
    print("T1 finish\n")
    
def T2_job():
    print('T2start\n')
    print('T2 finish')
    
 
def main():
    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')
    
if __name__ == "__main__":
    main()

import threading
import time
from queue import Queue
 
 
def job(l, q):
    for i in range(len(l)):
        l[i] **= 2
    q.put(l)  # 将计算后的列表放到 q 中
 
    
def multithreading():
    q = Queue()
    threads = []
    data = [[1, 2, 3], [3, 4, 5], [4, 4, 4], [5, 5, 5]]
    for i in range(4):  # 创建 4 个线程
        t = threading.Thread(target=job, args=(data[i], q))  # args 给 target 函数传递参数
        t.start()
        threads.append(t)
    for thread in threads:
        thread.join()
    results = []
    for _ in range(4):
        results.append(q.get())  # 从队列中拿出数据, 加入到 results 列表中
    print(results)
 
    
if __name__ == '__main__':
    multithreading()

import threading
from queue import Queue
import copy
import time
 
 
def job(l, q):
    res = sum(l)
    q.put(res)
 
 
def multithreading(l):  # 多线程方法
    q = Queue()
    threads = []
    for i in range(4):
        t = threading.Thread(target=job, args=(copy.copy(l), q), name='T%i' % i)
        t.start()
        threads.append(t)
    [t.join() for t in threads]
    total = 0
    for _ in range(4):
        total += q.get()
    print(total)
 
 
def normal(l):  # 常规方法
    total = sum(l)  # 对序列求和
    print(total)
 
 
if __name__ == '__main__':
    l = list(range(1000_000))
 
    s_t = time.time()
    normal(l * 4)
    print('normal:', time.time() - s_t)
 
    s_t = time.time()
    multithreading(l)
    print('multithreading:', time.time() - s_t)

import threading
 
 
def job1():
    global A  # A 是一个全局变量
    for i in range(10):
        A += 1
        print('job1', A)
    
    
def job2():
    global A  # A 是一个全局变量
    for i in range(10):
        A += 10
        print('job2', A)
    
    
if __name__ == '__main__':
    A = 0
    t1 = threading.Thread(target=job1)
    t2 = threading.Thread(target=job2)
    t1.start()
    t2.start()
    t1.join()
    t2.join()

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  # A 是一个全局变量
    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()