[已解决]线程和进程的问题！谢谢！

mcdmcd

这几天看了点关于进程和线程的只是，但是一直弄不明白python进程数据共享和线程数据共享的区别

哪位能指点一下！！！！  谢谢！！！！！！！！！！！！！

最佳答案

月排行榜 / 总排行榜

Stubborn

2020-2-25 02:46:19

线程
进程
每个进程都有自己的数据段，代码段，和堆栈段。
在子线程中对全局变量进行修改，对父进程中的全局变量没有影响
在创建子进程时对全局变量做了一个备份，父与子进程中的num是2个完全不同的变量

1. from multiprocessing import Process
   
2. import os
   
3. num = 100
   
4. def run(str):
   
5.     print("启动子线程")
   
6.     global num
   
7.     num += 1
   
8.     print("结束子线程")
   
9. 
   
10. if __name__ == '__main__':
    
11.     print("主(父)进程启动----%s"%(os.getpid()))
    
12.     p = Process(target=run,args=("nice",))
    
13.     p.start()
    
14.     #让父进程等待子进程结束，再执行父进程
    
15.     p.join()
    
16.     print("父进程结束---%d"%(num))

复制代码

进程间的“通讯”，利用到队列，数据原则是先进先出，后进后出。你用一个进程去产生某些数据，并存早列队里面，另外一个进程往这个列队取数据，实现进程之间的“通讯”

1. from multiprocessing import Process,Queue
   
2. import os,time
   
3. def write(Q):
   
4.     print("启动抓取子进程%s"%(os.getpid()))
   
5.     for chr in ["A","B","C","D"]:
   
6.         Q.put(chr)  #往队列传数据
   
7.         time.sleep(1)
   
8.     print("结束抓取子进程程%s" % (os.getpid()))
   
9. 
   
10. def read(Q):
    
11.     print("启动下载子进程%s"%(os.getpid()))
    
12.     while True:
    
13.         value = Q.get(True)  #没有数据，阻塞
    
14.         print("value = ",value)
    
15.     print("结束下载子进程%s" % (os.getpid()))
    
16. 
    
17. if __name__ == '__main__':
    
18.     #利用队列：由父进程创建队列，并传递给子进程，实现进程间的通讯
    
19.     print("父进程启动")
    
20.     q = Queue()
    
21.     writ = Process(target=write,args=(q,))
    
22.     rea = Process(target=read,args=(q,))
    
23.     writ.start()
    
24.     rea.start()
    
25.     writ.join()
    
26.     #rea进程里是个死循环，无法等待其结束 ，只能强行结束
    
27.     rea.terminate()
    
28.     print("父进程结束")

复制代码

多线程和多进程最大的不同在于，多进程中，同一个变量各自有一分拷贝存在每个进程中，互不影响
而多线程中，所有的变量都有所有线程共享。所以任何一个变量都可以被任意一个线程修改，
因此线程之间，共享数据最大的危险在于多个线程同时修改改一个变量，容易吧内容改乱。
如下代码当range大到一定数值，线程同时对数据修改，会产生不可估计的值。结果肯定不会为零

1. from threading import Thread
   
2. num = 0
   
3. 
   
4. def run(n):
   
5.     global num
   
6.     for i in range(10):
   
7.         num += n  #当线程同时执行到这里，num已经等于9，另外一个线程执行了 9 + 6 此时num=15
   
8.         num -= n #这里执行就变成  15 - 6
   
9. 
   
10. if __name__ == '__main__':
    
11.     t1 = Thread(target=run,args=(6,))
    
12.     t2 = Thread(target=run,args=(9,))
    
13.     t1.start()
    
14.     t2.start()
    
15.     t1.join()
    
16.     t2.join()
    
17. 
    
18.     print("NUM =",num)

复制代码

线程锁解决数据混乱

1. from threading import Thread,Lock
   
2. #锁对象
   
3. lock = Lock()
   
4. 
   
5. num = 0
   
6. def run(n):
   
7.     global num
   
8.     for i in range(10000000):
   
9.         '''
   
10.         # 加上线程锁
    
11.         #确保线程锁中，只能有一个线程存在执行
    
12.         #阻塞了多线程的并发执行，包含锁的某段代码实际上只能以单线程模式执行，所以效率消耗非常大
    
13.         #由于存在多个锁，不同线程持有不同的锁，并试图获取其他的锁，可能造成死锁，导致多个线程挂起（被挡在锁外面，一直等待），只能靠系统强制终止
    
14.         lock.acquire()
    
15.         try:
    
16.             num += n
    
17.             num -= n
    
18.         finally:
    
19.         #释放线程锁
    
20.             lock.release()
    
21.         '''
    
22.         #与上面代码功能相同，with lock ,可以自动上锁，与解锁
    
23.         with lock:
    
24.             num += n
    
25.             num -= n
    
26. 
    
27. if __name__ == '__main__':
    
28.     t1 = Thread(target=run,args=(6,))
    
29.     t2 = Thread(target=run,args=(9,))
    
30.     t1.start()
    
31.     t2.start()
    
32.     t1.join()
    
33.     t2.join()
    
34.     print("NUM =",num)

复制代码

跳转到最佳答案楼层

Stubborn

线程
进程
每个进程都有自己的数据段，代码段，和堆栈段。
在子线程中对全局变量进行修改，对父进程中的全局变量没有影响
在创建子进程时对全局变量做了一个备份，父与子进程中的num是2个完全不同的变量

1. from multiprocessing import Process
   
2. import os
   
3. num = 100
   
4. def run(str):
   
5.     print("启动子线程")
   
6.     global num
   
7.     num += 1
   
8.     print("结束子线程")
   
9. 
   
10. if __name__ == '__main__':
    
11.     print("主(父)进程启动----%s"%(os.getpid()))
    
12.     p = Process(target=run,args=("nice",))
    
13.     p.start()
    
14.     #让父进程等待子进程结束，再执行父进程
    
15.     p.join()
    
16.     print("父进程结束---%d"%(num))

复制代码

进程间的“通讯”，利用到队列，数据原则是先进先出，后进后出。你用一个进程去产生某些数据，并存早列队里面，另外一个进程往这个列队取数据，实现进程之间的“通讯”

1. from multiprocessing import Process,Queue
   
2. import os,time
   
3. def write(Q):
   
4.     print("启动抓取子进程%s"%(os.getpid()))
   
5.     for chr in ["A","B","C","D"]:
   
6.         Q.put(chr)  #往队列传数据
   
7.         time.sleep(1)
   
8.     print("结束抓取子进程程%s" % (os.getpid()))
   
9. 
   
10. def read(Q):
    
11.     print("启动下载子进程%s"%(os.getpid()))
    
12.     while True:
    
13.         value = Q.get(True)  #没有数据，阻塞
    
14.         print("value = ",value)
    
15.     print("结束下载子进程%s" % (os.getpid()))
    
16. 
    
17. if __name__ == '__main__':
    
18.     #利用队列：由父进程创建队列，并传递给子进程，实现进程间的通讯
    
19.     print("父进程启动")
    
20.     q = Queue()
    
21.     writ = Process(target=write,args=(q,))
    
22.     rea = Process(target=read,args=(q,))
    
23.     writ.start()
    
24.     rea.start()
    
25.     writ.join()
    
26.     #rea进程里是个死循环，无法等待其结束 ，只能强行结束
    
27.     rea.terminate()
    
28.     print("父进程结束")

复制代码

多线程和多进程最大的不同在于，多进程中，同一个变量各自有一分拷贝存在每个进程中，互不影响
而多线程中，所有的变量都有所有线程共享。所以任何一个变量都可以被任意一个线程修改，
因此线程之间，共享数据最大的危险在于多个线程同时修改改一个变量，容易吧内容改乱。
如下代码当range大到一定数值，线程同时对数据修改，会产生不可估计的值。结果肯定不会为零

1. from threading import Thread
   
2. num = 0
   
3. 
   
4. def run(n):
   
5.     global num
   
6.     for i in range(10):
   
7.         num += n  #当线程同时执行到这里，num已经等于9，另外一个线程执行了 9 + 6 此时num=15
   
8.         num -= n #这里执行就变成  15 - 6
   
9. 
   
10. if __name__ == '__main__':
    
11.     t1 = Thread(target=run,args=(6,))
    
12.     t2 = Thread(target=run,args=(9,))
    
13.     t1.start()
    
14.     t2.start()
    
15.     t1.join()
    
16.     t2.join()
    
17. 
    
18.     print("NUM =",num)

复制代码

线程锁解决数据混乱

1. from threading import Thread,Lock
   
2. #锁对象
   
3. lock = Lock()
   
4. 
   
5. num = 0
   
6. def run(n):
   
7.     global num
   
8.     for i in range(10000000):
   
9.         '''
   
10.         # 加上线程锁
    
11.         #确保线程锁中，只能有一个线程存在执行
    
12.         #阻塞了多线程的并发执行，包含锁的某段代码实际上只能以单线程模式执行，所以效率消耗非常大
    
13.         #由于存在多个锁，不同线程持有不同的锁，并试图获取其他的锁，可能造成死锁，导致多个线程挂起（被挡在锁外面，一直等待），只能靠系统强制终止
    
14.         lock.acquire()
    
15.         try:
    
16.             num += n
    
17.             num -= n
    
18.         finally:
    
19.         #释放线程锁
    
20.             lock.release()
    
21.         '''
    
22.         #与上面代码功能相同，with lock ,可以自动上锁，与解锁
    
23.         with lock:
    
24.             num += n
    
25.             num -= n
    
26. 
    
27. if __name__ == '__main__':
    
28.     t1 = Thread(target=run,args=(6,))
    
29.     t2 = Thread(target=run,args=(9,))
    
30.     t1.start()
    
31.     t2.start()
    
32.     t1.join()
    
33.     t2.join()
    
34.     print("NUM =",num)

复制代码