python 多线程

import threading
import time


# 通过函数方法创建多线程

def run(n):
    print('%s 线程开始了' % threading.current_thread().name)
    time.sleep(n)
    print('%s 线程结束了' % threading.current_thread().name)


if __name__ == '__main__':
    print('主线程开始执行：', threading.current_thread().name)
    s_time = time.time()
    # 创建thread对象，target传入线程执行的函数，args传参数
    t1 = threading.Thread(target=run, args=(1,))  # Python 元组语法规定，当 (object,) 元组中只有一个元素时，最后的逗号（,）不能省略
    t2 = threading.Thread(target=run, args=(2,))
    t3 = threading.Thread(target=run, args=(3,))
    # 使用start()开始执行
    t1.start()
    t2.start()
    t3.start()
    # 使用join()来完成线程同步
    t1.join()
    t2.join()
    t3.join()

    print('主线程执行结束', threading.current_thread().name)
    print('一共用时：', time.time() - s_time)

"""
主线程开始执行： MainThread
Thread-1 线程开始了
Thread-2 线程开始了
Thread-3 线程开始了
Thread-1 线程结束了
Thread-2 线程结束了
Thread-3 线程结束了
主线程执行结束 MainThread
一共用时： 3.004350185394287
"""

二、通过继承的方式创建多线程

import threading
import time


# 通过继承方式创建多线程
class MyThread(threading.Thread):

    def __init__(self, n):
        super(MyThread, self).__init__()
        self.n = n

    # 重写run方法
    def run(self):
        print('%s 线程开始了' % threading.current_thread().name)
        time.sleep(self.n)
        print('%s 线程结束了' % threading.current_thread().name)


if __name__ == '__main__':
    print('主线程开始执行', threading.current_thread().name)
    s_time = time.time()

    # 实例化MyThread对象
    t1 = MyThread(1)
    t2 = MyThread(2)
    t3 = MyThread(3)
    # 实例化后调用 start() 方法启动新线程，即它调用了线程的 run() 方法
    t1.start()
    t2.start()
    t3.start()
    # 使用join()来完成线程同步
    t1.join()
    t2.join()
    t3.join()

    print('一共用时：', time.time() - s_time)
    print('主线程结束执行', threading.current_thread().name)

"""
主线程开始执行 MainThread
Thread-1 线程开始了
Thread-2 线程开始了
Thread-3 线程开始了
Thread-1 线程结束了
Thread-2 线程结束了
Thread-3 线程结束了
一共用时： 3.002850294113159
主线程结束执行 MainThread
"""

线程锁

import threading
import time

'''
某个线程要更改共享数据时，先将其锁定，此时资源的状态为“锁定”，其他线程不能更改；
直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。
互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

lock = threading.Lock()  # 获取锁
lock.acquire()  # 上锁
lock.release()  # 解锁
'''

num = 0
lock = threading.Lock()  # 获取锁


def method1(count):
    global num
    for i in range(count):
        lock.acquire()  # 上锁
        temp = num
        num = temp + 1
        lock.release()  # 解锁
    print(num)


def method2(count):
    global num
    for i in range(count):
        lock.acquire()
        temp = num
        num = temp + 1
        lock.release()
    print(num)


if __name__ == '__main__':
    t1 = threading.Thread(target=method1, args=(1000,))
    t2 = threading.Thread(target=method2, args=(1000,))
    t1.start()
    t2.start()

    while len(threading.enumerate()) != 1:  # 线程数量
        time.sleep(1)
    print(num)

"""
1000
2000
2000
"""