概述

本文介绍多线程 共享内存，一个线程修改变量，一个线程访问变量

案例一

声明局部变量（该变量不能是数字或字符串），通过 Thread类的args参数，将局部变量传递给执行函数，让两个线程共享变量

1. #coding=utf-8
2. import threading
3. import time
4. import os
5. count=10
6. def modifycount(nums):
7. #获取当前线程对象
8. t=threading.current_thread()
9. for index in range(count):
10. nums.append(index)
11. print('%s,修改nums'%(t.name))
12. time.sleep(0.1)
13. def printcount(nums):
14. #获取当前线程对象
15. t=threading.current_thread()
16. for index in range(count):
17. print('%s,nums=%s'%(t.name,nums))
18. time.sleep(0.1)
19. if __name__ == "__main__":
20. print('pid=%d'%os.getpid())
21. nums=[]
22. #创建线程，此线程修改全局变量
23. t=threading.Thread(target=modifycount,args=(nums,))
24. #创建线程，此线程打印全局变量
25. t2=threading.Thread(target=printcount,args=(nums,))
26. t.start()
27. t2.start()
28. t.join()
29. t2.join()
30. print('主线程结束,nums=%s'%(nums))

执行结果：

这种方式与Process共享变量类似

传入数字或字符串类型的变量时

修改上面的代码，将局部变量改为数字或字符串，通过 Thread类的args参数传入变量，观察执行结果：

1. #coding=utf-8
2. import threading
3. import time
4. import os
5. count=10
6. def modifycount(num):
7. #获取当前线程对象
8. t=threading.current_thread()
9. for index in range(count):
10. num+=1
11. print('%s,修改num,num=%d'%(t.name,num))
12. time.sleep(0.1)
13. def printcount(num):
14. #获取当前线程对象
15. t=threading.current_thread()
16. for index in range(count):
17. print('%s,num=%d'%(t.name,num))
18. time.sleep(0.1)
19. if __name__ == "__main__":
20. print('pid=%d'%os.getpid())
21. num=0
22. #创建线程，此线程修改全局变量
23. t=threading.Thread(target=modifycount,args=(num,))
24. #创建线程，此线程打印全局变量
25. t2=threading.Thread(target=printcount,args=(num,))
26. t.start()
27. t2.start()
28. t.join()
29. t2.join()
30. print('主线程结束,num=%d'%(num))

执行结果如下：

说明：

1. 数字类型（或字符串类型）的变量，传入函数时，是值传递，将值传递给modifycount()函数的形参num，printcount()函数的形参num
2. 线程1修改的是modifycount()函数的形参num
3. 线程2修改的是printcount()函数的形参num
4. 主线程修改的局部变量num

如上图，也就是说，这三处的num只是同名，但不是同一个num（相当于3个人同名，都是叫“家瑞”，但不是同一个人），打印的结果，线程1的num，线程2的num，主线程的num，不相同

案例二

声明全局变量，让多线程直接修改全局变量：

1. #coding=utf-8
2. import threading
3. import time
4. import os
5. num=0
6. count=10
7. def modifycount():
8. global num
9. #获取当前线程对象
10. t=threading.current_thread()
11. for index in range(count):
12. num+=1
13. print('%s,修改num'%(t.name))
14. time.sleep(0.1)
15. def printcount():
16. global num
17. #获取当前线程对象
18. t=threading.current_thread()
19. for index in range(count):
20. print('%s,num=%d'%(t.name,num))
21. time.sleep(0.1)
22. if __name__ == "__main__":
23. print('pid=%d'%os.getpid())
24. #创建线程，此线程修改全局变量
25. t=threading.Thread(target=modifycount)
26. #创建线程，此线程打印全局变量
27. t2=threading.Thread(target=printcount)
28. t.start()
29. t2.start()
30. t.join()
31. t2.join()
32. print('主线程结束,num=%d'%(num))

执行结果如下图：

执行过程说明：
1.一个子线程让全局变量自增1
2.一个子线程打印全局变量，变量值也在自增1
3.最后主线程也打印全局变量，变量值也有变化

说明全局变量对于多线来说，是共用的，这与多进程操作全局变量不同

结论

多线程之间 共享内存

多线程共享全局变量的原因

由于多线程属于同一个进程，那么每个线程也就共享该进程的内存空间，全局变量在该进程的内存中，所以多线程可以共享全局变量