python进阶之 进程&线程区别
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了python进阶之 进程&线程区别，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含4276字，纯文字阅读大概需要7分钟。
内容图文
1.进程创建方式
import time
import os
from multiprocessing import Process
def func ():
time.sleep(1)
print(1,os.getpid(),os.getppid())
if __name__ == '__main__':
#异步执行func,在一秒钟的时间通过生成多个子进程来执行多个func
#1.先实例化
#2.实例化对象.start()
# 目标函数：target=
Process(target=func).start() #process类通知操作系统要为当前代码快在开辟一个进程，是异步过程
使用Process模块
import time
from multiprocessing import Process
class Myprocess(Process): #继承Process类
def __init__(self,name): #重新父类的__init__方法
super().__init__()
self.name =name
def run(self): #必须是run函数名
print(os.getpid(),os.getppid(),'我爱你%s' % self.name)
time.sleep(3)
if __name__ == '__main__':
start_time = time.time()
p1 = Myprocess('kobe')
p2 = Myprocess('kobe')
p3 = Myprocess('kobe')
p1.start()
p2.start()
p3.start()
p1.join() #阻塞，直到p1对应的进程结束之后，才结束阻塞，是异步阻塞，阻塞等待一个子进程结束
p2.join()
p3.join()
print(time.time()-start_time)
##阻塞一个子进程：p.join()
#阻塞多个子进程，将子进程加入到列表，然后分别阻塞
'''
10600 9384 我爱你kobe
10448 9384 我爱你kobe
10032 9384 我爱你kobe
1.1659998893737793
从上面结果来看，我们知道join也是异步阻塞的，在同一秒钟分别执行了p1,p2,p3的time.sleep()
和我本来预想的要阻塞3s+是结果是不同的
'''
继承Process类创建多进程
2.线程创建方式
from threading import Thread
import os
def func():
print('in fucn ',os.getpid())
print('in main ',os.getpid())
Thread(target=func).start()
#两个打印pid是一样的，说明线程是由进程产生的
使用Thread模块
from threading import Thread
import time
class Sayhi(Thread):
def __init__(self,name):
super().__init__() #重写父类的__init__方法
self.name=name
def run(self):
time.sleep(2)
print('%s say hello' % self.name)
if __name__ == '__main__':
t = Sayhi('kobe')
t.start()
print('主线程')
继承Thread类创建多线程
3.进程和线程的区别
线程和进程的区别 进程： 数据隔离(但是也可以丛进程间的数据共享) 开销大 线程： 数据共享 开销小 cpython中多进程可以使用多核(并发编程)，多线程不可以使用多核
os.getpid()不同
#线程
from threading import Thread
import os
import time
def func():
print('in func',os.getpid())
tt = Thread(target=func)
tt.start()
print('in main', os.getpid())
#进程
from multiprocessing import Process
import os
import time
def func():
print('in func',os.getpid())
if __name__ == '__main__':
tt = Process(target=func)
tt.start()
print('in main', os.getpid())
注意：线程不需要if __name__ == '__main__':
进程和线程的创建原理不同，所以不需要if __name__ == '__main__'，但是可以使用这种方式
因为新的线程是在主线程的内存中，所以新的线程和主线程共享同一段代码，不需要import导入，也就不存在子线程中又重复一次创建线程的过程
二者pid对比：
在进程内，父进程创建的所有子进程都是不同的pid，说明父进程只是创建了子进程并在子进程执行代码的时候会import 父进程文件，其余父子相互之间独立，使用不同的内存空间，所以pid不同
在线程中，主线程和子线程的pid完全相同，说明子线程是在主线程内部创建出来的，并且主线程会所有子线程的结束才结束。
二者开销对比
#线程开销时间
import time
from threading import Thread
def func(item):
item +=1
if __name__ == '__main__':
start = time.time()
t_l = []
for i in range(100):
t = Thread(target=func,args=(i,))
t.start()
t_l.append(t)
for t in t_l:
t.join()
print(time.time()-start)
#进程开销时间
import time
def func(item):
item +=1
from multiprocessing import Process
if __name__ == '__main__':
start = time.time()
t_l = []
for i in range(100):
t = Process(target=func,args=(i,))
t.start()
t_l.append(t)
for t in t_l:
t.join()
print(time.time()-start)
注意：为什么要join()?
因为要等待所有线程或进程全部都运行完，才计算时间
不能再func()函数里面写join()方法，这样就是同一时间只有一个线程或进程在之心，变成同步的了
二者开销对比：
分别执行上面代码，能够看到，做相同的操作，100个进程使用的时间比100个线程使用时间更长
说明进程在创建\销毁\上下文切换之间，需要更多的时间和系统资源
二者数据是否共享
#多个线程之间共享全局变量
from threading import Thread
item = 0
def func():
global item
item +=1
f_l= []
for ii in range(1000):
tt = Thread(target=func)
tt.start()
f_l.append(tt)
[x.join() for x in f_l ]
print(item)
#多个进程之间数据不共享
from multiprocessing import Process,Manager
item = 0
def func():
global item
item +=1
if __name__ == '__main__':
f_l= []
for ii in range(10):
tt = Process(target=func)
tt.start()
f_l.append(tt)
[x.join() for x in f_l ]
print(item)
二者数据是否共享：
在线程内，主线程内的全局变量对于子线程来说完全共享，其他不是全局的就不共享
在进程内，父进程和子线程的数据完全隔离，因为父子之间分别有不同的内存空间。
tets
内容总结
以上是互联网集市为您收集整理的python进阶之 进程&线程区别全部内容，希望文章能够帮你解决python进阶之 进程&线程区别所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】