概述

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

案例一

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

  
#coding=utf-8
import threading
import time
import os
count=10
def modifycount(nums):
    #获取当前线程对象
    t=threading.current_thread()
    for index in range(count):
        nums.append(index)
        print('%s,修改nums'%(t.name))
        time.sleep(0.1)
def printcount(nums):
    #获取当前线程对象
    t=threading.current_thread()
    for index in range(count):
        print('%s,nums=%s'%(t.name,nums))
        time.sleep(0.1)
if __name__ == "__main__":
    print('pid=%d'%os.getpid())
    nums=[]
    #创建线程，此线程修改全局变量
    t=threading.Thread(target=modifycount,args=(nums,))
    #创建线程，此线程打印全局变量
    t2=threading.Thread(target=printcount,args=(nums,))
    t.start()
    t2.start()
    t.join()
    t2.join()
    print('主线程结束,nums=%s'%(nums))

执行结果：

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

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

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

  
#coding=utf-8
import threading
import time
import os
count=10
def modifycount(num):
    #获取当前线程对象
    t=threading.current_thread()
    for index in range(count):
        num+=1
        print('%s,修改num,num=%d'%(t.name,num))
        time.sleep(0.1)
def printcount(num):
    #获取当前线程对象
    t=threading.current_thread()
    for index in range(count):
        print('%s,num=%d'%(t.name,num))
        time.sleep(0.1)
if __name__ == "__main__":
    print('pid=%d'%os.getpid())
    num=0
    #创建线程，此线程修改全局变量
    t=threading.Thread(target=modifycount,args=(num,))
    #创建线程，此线程打印全局变量
    t2=threading.Thread(target=printcount,args=(num,))
    t.start()
    t2.start()
    t.join()
    t2.join()
    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，不相同

案例二

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

  
#coding=utf-8
import threading
import time
import os
num=0
count=10
def modifycount():
    global num
    #获取当前线程对象
    t=threading.current_thread()
    for index in range(count):
        num+=1
        print('%s,修改num'%(t.name))
        time.sleep(0.1)
def printcount():
    global num
    #获取当前线程对象
    t=threading.current_thread()
    for index in range(count):
        print('%s,num=%d'%(t.name,num))
        time.sleep(0.1)
if __name__ == "__main__":
    print('pid=%d'%os.getpid())
    #创建线程，此线程修改全局变量
    t=threading.Thread(target=modifycount)
    #创建线程，此线程打印全局变量
    t2=threading.Thread(target=printcount)
    t.start()
    t2.start()
    t.join()
    t2.join()
    print('主线程结束,num=%d'%(num))

执行结果如下图：

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

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

结论

多线程之间 共享内存

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

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