044.Python线程的数据安全

线程的数据安全

1 数据混乱现象

from threading import Thread,Lock

num = 0

lst = []

def func1():

        global num

        for i in range(100000):

                num -= 1

def func2():

        global num

        for i in range(100000):

                num += 1

for i  in range (10):

# 启动线程1

        t1 = Thread(target=func1)

        t1.start()

# 启动线程2

        t2 = Thread(target=func2)

        t2.start()

        lst.append(t1)

        lst.append(t2)

for i in lst:

        i.join()

print("主线程执行结束")

print(num)

执行

由于共享同一份，会出现数据混乱，如下结果

[root@node10 python]# python3 test.py

主线程执行结束

173624

[root@node10 python]# python3 test.py

主线程执行结束

131875

[root@node10 python]# python3 test.py

主线程执行结束

-4279

[root@node10 python]# python3 test.py

主线程执行结束

-93587

[root@node10 python]# python3 test.py

主线程执行结束

145643

这是因为线程是并发执行，同同一时间会有多个线程拿到同一个数据进行计算，然后再放回去，导致一个数字被多个线程修改，结果不准确

2 引入锁机制

from threading import Thread,Lock

num = 0

lst = []

def func1(lock):

        global num

        for i in range(100000):

                #上锁修改数据

                lock.acquire()

                num -= 1

                #解锁释放

                lock.release()

def func2(lock):

        global num

        for i in range(100000):

                #使用with，自动上锁和解锁

                with lock:

                        num += 1

lock = Lock()

for i  in range (10):

# 启动线程1

        t1 = Thread(target=func1,args=(lock,))

        t1.start()

# 启动线程2

        t2 = Thread(target=func2,args=(lock,))

        t2.start()

        lst.append(t1)

        lst.append(t2)

for i in lst:

        i.join()

print("主线程执行结束")

print(num)

执行

[root@node10 python]# python3 test.py

主线程执行结束

0

结果正确，但是消耗的时间毕竟长，但是可以换取数据正确

3 信号量

import time,random,os

def func(i,sem):

        time.sleep(random.uniform(0.1,1))

        with sem:

                print (i)

                print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))

                time.sleep(random.uniform(3,6))

sem = Semaphore(5)

for i in range (20):

        Thread(target = func,args=(i,sem)).start()

执行

[root@node10 python]# python3 test.py

3

2020-02-23 03:55:24

5

2020-02-23 03:55:24

14

2020-02-23 03:55:24

18

2020-02-23 03:55:24

6

2020-02-23 03:55:24

0

2020-02-23 03:55:27

2

2020-02-23 03:55:29

15

2020-02-23 03:55:29

1

2020-02-23 03:55:29

19

2020-02-23 03:55:30

12

2020-02-23 03:55:32

4

2020-02-23 03:55:32

17

2020-02-23 03:55:34

16

2020-02-23 03:55:34

13

2020-02-23 03:55:35

7

2020-02-23 03:55:36

10

2020-02-23 03:55:36

8

2020-02-23 03:55:39

9

2020-02-23 03:55:39

11

2020-02-23 03:55:40

信号量就相当于同时可以上多把锁

死锁,递归锁,互斥锁

4 死锁现象

模拟一个俱乐部玩枪，两把枪，两盒子弹，四个人同时抢，只有同时抢到子弹和枪的人，才能玩枪

初步逻辑

from threading import Thread,Lock

import time

#首先创建两把锁

gun = Lock()

bullet = Lock()

#定义第一种，先抢到枪，再抢到子弹

def play1(name):

        #抢到枪，上锁

        gun.acquire()

        print("%s拿到枪"%(name))

        #抢到子弹上锁

        bullet.acquire()

        print ("%s抢到子弹"%(name))

        print ("开枪玩一会")

        time.sleep(0.5)

        #放下枪，解锁

        gun.release()

        print("%s放下枪"%(name))

        #放下子弹，解锁

        bullet.release()

        print("%s放下子弹"%(name))

#定义第二种，先抢到子弹，再抢到枪

def play2(name):

        #抢到子弹上锁

        bullet.acquire()

        print ("%s抢到子弹"%(name))

         #抢到枪，上锁

        gun.acquire()

        print("%s拿到枪"%(name))

        print ("开枪玩一会")

        time.sleep(0.5)

        #放下子弹，解锁

        bullet.release()

        print("%s放下子弹"%(name))

        #放下枪，解锁

        gun.release()

        print("%s放下枪"%(name))

name_lst1 = ["John","Jim"]

name_lst2 = ["Tom","Jerry"]

for name  in  name_lst1:

        Thread(target=play1,args=(name,)).start()

for name  in  name_lst2:

        Thread(target=play2,args=(name,)).start()

这种情况就会有死锁现象

多次执行，结果如下

[root@node10 python]# python3 test.py

John拿到枪

Tom抢到子弹

#阻塞，是因为John和Tom同时上了枪锁和子弹锁，但是都没有解锁，造成死锁

[root@node10 python]# python3 test.py

John拿到枪

John抢到子弹

开枪玩一会

John放下枪

John放下子弹

Jim拿到枪

Tom抢到子弹

#阻塞，这次是John顺利的玩一局，但是到Jim和Tom同时抢到枪和子弹，上锁，但是没有解锁，造成死锁

[root@node10 python]# python3 test.py

John拿到枪

John抢到子弹

开枪玩一会

John放下枪

John放下子弹

Tom抢到子弹

Jim拿到枪

#阻塞

5 递归锁介绍

上几把锁，解几把锁

from threading import Thread,RLock

rlock = RLock()

def func(name):

        rlock.acquire()

        print(name,1)

        rlock.acquire()

        print(name,2)

        rlock.acquire()

        print(name,3)

        rlock.release()

        rlock.release()

        rlock.release()

for i in range(10):

        t = Thread(target=func,args=("name%s" % (i),) )

        t.start()

print("程序执行结束")

执行

[root@node10 python]# python3 ceshi.py

name0 1

name0 2

name0 3

name1 1

name1 2

name1 3

name2 1

name2 2

name2 3

name3 1

name3 2

name3 3

程序执行结束

name4 1

name4 2

name4 3

name5 1

name5 2

name5 3

name6 1

name6 2

name6 3

name7 1

name7 2

name7 3

name8 1

name8 2

name8 3

name9 1

name9 2

name9 3

6 利用递归锁,解决死锁现象

临时用于快速解决服务器崩溃死锁的问题,用递归锁应急问题

from threading import Thread,RLock

import time

#首先创建递归锁

gun=bullet = RLock()

#定义第一种，先抢到枪，再抢到子弹

def play1(name):

        #抢到枪，上锁

        gun.acquire()

        print("%s拿到枪"%(name))

        #抢到子弹上锁

        bullet.acquire()

        print ("%s抢到子弹"%(name))

        print ("开枪玩一会")

        time.sleep(0.5)

        #放下枪，解锁

        gun.release()

        print("%s放下枪"%(name))

        #放下子弹，解锁

        bullet.release()

        print("%s放下子弹"%(name))

#定义第二种，先抢到子弹，再抢到枪

def play2(name):

        #抢到子弹上锁

        bullet.acquire()

        print ("%s抢到子弹"%(name))

         #抢到枪，上锁

        gun.acquire()

        print("%s拿到枪"%(name))

        print ("开枪玩一会")

        time.sleep(0.5)

        #放下子弹，解锁

        bullet.release()

        print("%s放下子弹"%(name))

        #放下枪，解锁

        gun.release()

        print("%s放下枪"%(name))

name_lst1 = ["John","Jim"]

name_lst2 = ["Tom","Jerry"]

for name  in  name_lst1:

        Thread(target=play1,args=(name,)).start()

for name  in  name_lst2:

        Thread(target=play2,args=(name,)).start()

执行

[root@node10 python]# python3 test.py

John拿到枪

John抢到子弹

开枪玩一会

John放下枪

John放下子弹

Jim拿到枪

Jim抢到子弹

开枪玩一会

Jim放下枪

Jim放下子弹

Tom抢到子弹

Tom拿到枪

开枪玩一会

Tom放下子弹

Tom放下枪

Jerry抢到子弹

Jerry拿到枪

开枪玩一会

Jerry放下子弹

Jerry放下枪

执行成功，神奇

7 使用互斥锁解决

从语法上来看,锁是可以互相嵌套的,但是不要使用

上一次锁,就对应解开一把锁,形成互斥锁

拿枪和拿子弹是同时的,上一把锁就够了,不要分开上锁，也不要去写锁的嵌套,容易死锁

from threading import Thread,Lock

import time

#首先创建递归锁

mylock = Lock()

#定义第一种，先抢到枪，再抢到子弹

def play1(name):

        #抢到枪和子弹，上锁

        mylock.acquire()

        print("%s拿到枪"%(name))

        print ("%s抢到子弹"%(name))

        print ("开枪玩一会")

        time.sleep(0.5)

        #放下枪，和子弹解锁

        print("%s放下枪"%(name))

        print("%s放下子弹"%(name))

        mylock.release()

#定义第二种，先抢到子弹，再抢到枪

def play2(name):

        #抢到枪子弹上锁

        mylock.acquire()

        print ("%s抢到子弹"%(name))

        print("%s拿到枪"%(name))

        print ("%s开枪玩一会"%(name))

        time.sleep(0.5)

        #放枪下子弹，解锁

        print("%s放下子弹"%(name))

        print("%s放下枪"%(name))

        mylock.release()

name_lst1 = ["John","Jim"]

name_lst2 = ["Tom","Jerry"]

for name  in  name_lst1:

        Thread(target=play1,args=(name,)).start()

for name  in  name_lst2:

        Thread(target=play2,args=(name,)).start()

执行

[root@node10 python]# python3 test.py

John拿到枪

John抢到子弹

开枪玩一会

John放下枪

John放下子弹

Jim拿到枪

Jim抢到子弹

开枪玩一会

Jim放下枪

Jim放下子弹

Tom抢到子弹

Tom拿到枪

Tom开枪玩一会

Tom放下子弹

Tom放下枪

Jerry抢到子弹

Jerry拿到枪

Jerry开枪玩一会

Jerry放下子弹

Jerry放下枪

完成

巴特西