3_python高阶_线程—多线程-共享全局变量

一、多线程-共享全局变量

import threading
import time

# 定义一个全局变量
g_num = 100


def test1():
    global g_num
    g_num += 1
    print("-----in test1 g_num=%d----" % g_num)


def test2():
    print("-----in test2 g_num=%d=----" % g_num)


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

    t1.start()
    time.sleep(1)   # 延时一会，保证t1线程中的事情做完

    t2.start()
    time.sleep(1)

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

if __name__ == "__main__":
    main()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

运行结果:

-----in test1 g_num=101----
-----in test2 g_num=101=----
-----in main Thread g_num = 101---
1
2
3

1.1 全局变量

def test():
    global num
    num += 100

def test2():
    nums.append(33)


print(num)   # 100
print(nums)  # [11, 22]

test()
test2()

print(num)   # 200
print(nums)  # [11, 22, 33]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在一个函数中，对全局变量进行修改时侯，到底是否需要使用global进行说明，要看是否对全局变量的指向进行修改。

• 如果修改了指向，即让全局变量指向了一个新的地方，必须使用global。
• 如果仅仅是修改了指向的空间中的数据，此时不用必须使用global。

二、列表当做实参传递到线程中

import threading
import time

def test1(temp):
    temp.append(33)
    print("-----in test1 temp=%s----" % str(temp))


def test2(temp):
    print("-----in test2 temp=%s----" % str(temp))


g_nums = [11, 22]

def main():
    # target指定将来 这个线程去哪个函数执行代码
    # args指定将来调用 函数的时候 传递什么数据过去
    t1 = threading.Thread(target=test1, args=(g_nums,))
    t2 = threading.Thread(target=test2, args=(g_nums,))

    t1.start()
    time.sleep(1)

    t2.start()
    time.sleep(1)

    print("-----in main Thread g_nums = %s---" % str(g_nums))

if __name__ == "__main__":
    main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

运行结果:

-----in test1 temp=[11, 22, 33]----
-----in test2 temp=[11, 22, 33]----
-----in main Thread g_nums = [11, 22, 33]---
1
2
3

总结：

• 在一个进程内的所有线程共享全局变量，很方便在多个线程间共享数据
• 缺点就是，线程是对全局变量随意遂改可能造成多线程之间对全局变量的混乱（即线程非安全）

三、多线程-共享全局变量问题-资源竞争

假设两个线程t1和t2都要对全局变量g_num(默认是0)进行加1运算，t1和t2都各对g_num加10次，g_num的最终的结果应该为20。

但是由于是多线程同时操作，有可能出现下面情况：

1. 在g_num=0时，t1取得g_num=0。此时系统把t1调度为”sleeping”状态，把t2转换为”running”状态，t2也获得g_num=0
2. 然后t2对得到的值进行加1并赋给g_num，使得g_num=1
3. 然后系统又把t2调度为”sleeping”，把t1转为”running”。线程t1又把它之前得到的0加1后赋值给g_num。
4. 这样导致虽然t1和t2都对g_num加1，但结果仍然是g_num=1

3.1 测试1

import threading
import time

# 定义一个全局变量
g_num = 0


def test1(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("-----in test1 g_num=%d----" % g_num)


def test2(num):
    global g_num
    for i in range(num):  # 循环num=100次
        g_num += 1
    print("-----in test2 g_num=%d=----" % g_num)


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

    t1.start()
    t2.start()

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

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

if __name__ == "__main__":
    main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

运行结果：

-----in test1 g_num=100----
-----in test2 g_num=200=----
-----in main Thread g_num = 200---
1
2
3

3.2 测试2

import threading
import time

# 定义一个全局变量
g_num = 0


def test1(num):
    global g_num
    for i in range(num):
        g_num += 1
    print("-----in test1 g_num=%d----" % g_num)


def test2(num):
    global g_num
    for i in range(num):  # 循环num=100次
        g_num += 1
    print("-----in test2 g_num=%d=----" % g_num)


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

    t1.start()
    t2.start()

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

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

if __name__ == "__main__":
    main()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

运行结果：

-----in test1 g_num=1279625----
-----in test2 g_num=1497714=----
-----in main Thread g_num = 1497714---
1
2
3

3.3 结论

• 如果多个线程同时对同一个全局变量操作，会出现资源竞争问题，从而数据结果会不正确