python多线程threading学习

import threading
import time

print(threading.active_count())  # 当前线程数量
print(threading.enumerate())     # 当前线程列表
print(threading.current_thread())  # 当前线程

def thread_job():
    time.sleep(1)
    print("This is an added Thread, number is %s" % threading.current_thread())

def main():
    added_thread = threading.Thread(target=thread_job, name='T1')  # 定义线程 target是线程要执行的函数 name是线程名字
    added_thread.start()  # start()方法是启动线程
    added_thread.join()   # join()方法是等待线程结束

if __name__ == '__main__':
    main()

import threading
from queue import Queue

def job(l, q):
    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))  # args是线程函数的参数，需要是一个tuple
        t.start()  # start()方法是启动线程
        threads.append(t)  # 将线程加入线程列表
    for thread in threads:
        thread.join()  # join()方法是等待线程结束
    results = []
    for _ in range(4):
        results.append(q.get())  # q.get()方法是从队列中取出一个值
    print(results)

if __name__ == '__main__':
    multithreading()

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()  # 定义一个lock
    A = 0
    t1 = threading.Thread(target=job1)  # 定义线程
    t2 = threading.Thread(target=job2)  # 定义线程
    t1.start()  # 启动线程
    t2.start()  # 启动线程
    t1.join()  # 等待线程结束
    t2.join()  # 等待线程结束