python学习之多线程的特点与同步&互斥锁

1.
1.1线程之间的执行是无序的
线程调度是根据CPU调度决定的

import time
import threading
def task():
    time.sleep(1)
    print("当前线程是:  ",threading.current_thread().name)
if __name__ == '__main__':
    #每循环一次就创建一个子线程
    for i in range(5):
        t = threading.Thread(target=task)
        #启动子线程
        t.start()

import time
import threading
# 1.2线程之间共享资源
li = [] #定义全局变量
def wdata():
    for i in range(5):
        li.append(i)
        time.sleep(1)
    print('写入的数据是: ',li)
def rdata():
    print('读取的数据是: ',li)
if __name__ == '__main__':
    #创建子线程
    wd = threading.Thread(target=wdata)
    rd = threading.Thread(target=rdata)
    wd.start()
    wd.join()
    rd.start()
    wd.join()

import threading
# 1.3资源竞争
a = 0
b = 1000000
def add1():
    for i in range(b):
        global a
        a += 1
    print("第一次累加:",a)

def add2():
    for i in range(b):
        global a
        a += 1
    print("第二次累加:",a)
# add1()
# add2()
if __name__ == '__main__':
    a1 = threading.Thread(target=add1)
    a2 = threading.Thread(target=add2)
    a1.start()
    a2.start()

2.线程同步
主线程和创建的子线程之间各自执行完自己的代码直至结束
方式: 1. 线程等待 2.互斥锁
2.1. 线程等待

import threading
a = 0
b = 1000000
def add1():
    for i in range(b):
        global a
        a += 1
    print("第一次累加:",a)

def add2():
    for i in range(b):
        global a
        a += 1
    print("第二次累加:",a)
# add1()
# add2()
if __name__ == '__main__':
    a1 = threading.Thread(target=add1)
    a2 = threading.Thread(target=add2)
    a1.start()
    a1.join()   #等待a1子线程执行结束以后，代码再继续往下执行，开始执行a2子线程
    a2.start()
    a2.join()

2.2.互斥锁
概念:对共享资源进行锁定，保证多个线程访问共享数据不会出现共享数据错误问题:保证统同一时刻只能由一个线程去操作
方法:
acquire():上锁
release():释放锁
注意:两个方法必须同时出现，否则容易出现死锁
死锁；一直等待对方释放锁的情景就是死锁
会造成应用程序停止响应，不能再处理其他任务
互斥锁的缺点:会影响代码的执行效率

import threading
# 1.导入模块
from threading import Lock
# 2.创建全局互斥锁
lock = Lock()
a = 0
b = 1000000
def add1():
    # 3.上锁
    lock.acquire()
    for i in range(b):
        global a
        a += 1
    print("第一次累加:",a)
    # 4.释放锁
    lock.release()

def add2():
    lock.acquire()
    for i in range(b):
        global a
        a += 1
    print("第二次累加:",a)
    lock.release()

if __name__ == '__main__':
    a1 = threading.Thread(target=add1)
    a2 = threading.Thread(target=add2)
    a1.start()
    a2.start()

2.3 总结
互斥锁的作用:保证同一时刻只有一个线程去操作共享数据，保证共享数据不会出现错误问题