Python中线程与互斥锁

了解之前我们先了解一下什么是多任务?

概念: 几个不同的事件在同时运行就是多任务, 这样的话, 我们有牵扯到了真的多任务, 假的多任务;

并行: 真的多任务, 通过电脑的核数来确定

并发: 假的多任务, 即cpu的快速切换

线程

1.线程之间共享全局变量;

2.主线程等待子线程结束后才结束;

3.线程之间执行顺序是无序的;

4.互斥锁以及死锁的问题.

demo 如何创建线程:

import threading
from time import sleep,ctime

def sing():
    for i in range(3):
        print("正在唱歌...%d"%i)
        sleep(1)

def dance():
    for i in range(3):
        print("正在跳舞...%d"%i)
        sleep(1)

if __name__ == '__main__':
    print('---开始---:%s'%ctime())

    t1 = threading.Thread(target=sing)
    t2 = threading.Thread(target=dance)

    t1.start()  // 注意当调用start时才真正的开始执行程序
    t2.start()

    #sleep(5) # 屏蔽此行代码，试试看，程序是否会立马结束？
    print('---结束---:%s'%ctime())

多线程之间共享全局变量

demo:

from threading import Thread
import time

def work1(nums):
    nums.append(44)
    print("----in work1---",nums)


def work2(nums):
    #延时一会，保证t1线程中的事情做完
    time.sleep(1)
    print("----in work2---",nums)

g_nums = [11,22,33]

t1 = Thread(target=work1, args=(g_nums,))
t1.start()

t2 = Thread(target=work2, args=(g_nums,))
t2.start()

运行结果是:

----in work1--- [11, 22, 33, 44]

----in work2--- [11, 22, 33, 44]

互斥锁以及死锁的问题:
思考: 为什么要使用互斥锁?
线程之间共享资源, 这就导致了多个线程之间资源竞争, 导致了程序的运行.
思考: 锁的好处以及坏处?
好处: 保证了同一时间内允许一个线程的完整执行
坏处: 降低了效率, 可能会造成死锁问题

demo:

import threading
import time

# 定义一个全局变量
g_num = 0
def test1(num):
    global g_num

    for i in range(num):

        mutex.acquire()  # 上锁 注意了此时锁的代码越少越好
        g_num += 1
        mutex.release()  # 解锁
        
    print("-----in test1 g_num=%d----" % g_num)


def test2(num):
    global g_num
    for i in range(num):
        mutex.acquire()  # 上锁
        g_num += 1
        mutex.release()  # 解锁
    print("-----in test2 g_num=%d=----" % g_num)


# 创建一个互斥锁，默认是没有上锁的
mutex = threading.Lock()


def main():
    t1 = threading.Thread(target=test1, args=(1000000,))
    t2 = threading.Thread(target=test2, args=(1000000,))

    t1.start()
    t2.start()

    # 等待上面的2个线程执行完毕....
    time.sleep(2)

    print("-----in main Thread g_num = %d---" % g_num)

if __name__ == "__main__":
    main()

死锁: 在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁

demo:

import threading
import time


def test1(num):
    print("---test1---")
    mutex1.acquire()
    print("test1 请求 mutex1")
    time.sleep(1)
    print("test1 获得 mutex1")
    print("test1 请求 mutex2")
    mutex2.acquire()


def test2(num):
    print("---test2---")
    print("test2 请求 mutex2")
    mutex2.acquire()
    print("test2 获得 mutex2")
    time.sleep(1)
    print("test2 请求 mutex1")
    mutex1.acquire()
   
mutex1 = threading.Lock()
mutex2 = threading.Lock()

def main():
    t1 = threading.Thread(target=test1, args=(1000000,))
    t2 = threading.Thread(target=test2, args=(1000000,))

    t1.start()
    t2.start()

if __name__ == "__main__":
    main()

思考: 死锁如何避免?

1. 我们可以使用time.time()来进行一个超时等待;

2.银行家算法

 有需要的话可以关注我的微信公众号，会第一时间接收最新的知识。