Python中的进程&线程

文章目录

多进程与多线程

基本概念

这里再简单提一下线程和进程的基本概念和区别
进程指的是程序的一次执行，它是系统资源分配的单位，不同进程间的资源互相独立，但是系统开销较大
线程是进程的执行单元，它是CPU调度的基本单位，线程能够共享进程的资源，它的优点是效率高，缺点是会影响所在的进程

多进程

multiprocessing 类对象

Python中的多进程常用multiprocessing库实现，支持跨平台的多进程操作，一个实例如下：

from multiprocessing import Process
import os
import time
def run_proc(name):
	print('子进程 %s PID: %s 已经启动...' % (name,os.getpid()))
	time.sleep(5)
	print('子进程 %s PID: %s 终止...' % (name,os.getpid()))

if __name__ == '__main__':
	print('父进程PID: %s' % (os.getpid()))
	p=Process(target=run_proc,args=('test',))
	print('子进程即将启动...')
	p.start() #启动进程,并调用该子进程中的p.run()
	p.join()  #阻塞当前所在进程,等待所有进程退出  #尝试注释此行观察程序执行变化
	print('主进程终止...')

一个Processs对象就代表一个进程对象，传入的函数名及参数作为进程对象的参数
使用start方法启动进程对象，默认调用子进程的run()方法
join方法表示等待进程结束，此实例中用p.join()表示主进程阻塞，等待子进程执行推出后再继续执行

进程池

利用进程池运行进程的实例如下：

from multiprocessing import Pool
import os,time,random

def long_time_task(name):
	print('子进程 %s 启动, PID: %s' % (name, os.getpid()) )
	stime=time.time()
	# time.sleep(random.random()*3)
	time.sleep(1)
	etime=time.time()
	print('子进程 %s 运行结束,耗时: %f' % (name,(etime-stime)))


if __name__ == '__main__':
	print('主进程启动,PID:',os.getpid())
	stime=time.time()
	p=Pool(2)  #Pool()中的参数表示最多能够同时运行几个进程，其余进程需要等到已运行进程结束后才能运行
	for i in range(6):
		p.apply_async(long_time_task,args=(i,))
	print('等待所有子进程运行结束...')
	p.close()
	p.join()
	etime=time.time()
	print('所有子进程运行结束,共耗时:',(etime-stime))

执行结果：
在这里插入图片描述
解释：

每次同时运行两个进程，每个进程执行时间约1秒，共有6个进程，因此执行时间共为3秒
如果注释掉 join()的话主进程会直接结束，看不到子进程的输出

subprocess模块

subprocess 模块允许我们启动一个新进程，并连接到它们的输入/输出/错误管道，从而获取返回值。
其中的subprocess.call()则可以调用windows系统cmd命令行执行额外的命令。

import subprocess

print('利用subprocess查询DNS...')
r=subprocess.call(['nslookup','baidu.com'])
print('返回状态码',r)

执行结果
在这里插入图片描述
解释：利用subprocess.call()类似于我们开启了一个新的命令窗口(新的进程)，输入call()方法的参数，同时将命令执行结果的输出返回到当前进程的输出

进程间通信

multiprocessing模块提供了队列、管道等方式帮助进程之间交换数据
以下例子创建了两个进程，read进程向队列中读取数据，write进程向队列中写入数据

from multiprocessing import Process,Queue
import os,time,random

def write(q):
	print('write进程启动,PID:',os.getpid())
	for value in ['A','B','C','D']:
		print('将',value,'放入队列')
		q.put(value)
		time.sleep(1)

def read(q):
	print('read进程启动,PID:',os.getpid())
	while True:
		value=q.get()
		print('从队列中取出',value)
		pass

执行结果：
在这里插入图片描述

多线程

Python支持真正的多线程
通常用_thread和threading两个模块实现Python多线程，后者更为常用
线程执行的目标是函数，可以为线程命名

threading实现线程操作

import time,threading

def lp():
	print('线程',threading.current_thread().name,'正在运行')
	for i in range(3):
		print('线程进入第',i+1,'次循环')
		time.sleep(1)
	print('线程',threading.current_thread().name,'终止')

print('线程',threading.current_thread().name,'正在运行')
t=threading.Thread(target=lp,name='子线程')
t.start()
t.join()
print('线程',threading.current_thread().name,'终止')

执行结果
在这里插入图片描述

线程共享所有变量

以下是一个简单的例子，利用add和sub线程对共享变量进行修改

import time,threading
share=1000
def add():
	global share
	share+=5
	print('线程',threading.current_thread().name,'正在运行,变量share自增, share:',share)
	time.sleep(1)

def sub():
	global share
	share-=2
	print('线程',threading.current_thread().name,'正在运行,变量share自减, share:',share)
	time.sleep(1)

t1=threading.Thread(target=add,name='add')
t2=threading.Thread(target=sub,name='sub')
t1.start()
t2.start()
t1.join()
t2.join()
print('share:',share)

执行结果：
在这里插入图片描述

线程锁

让我们尝试修改一下上面的例子，add和sub线程随机修改三次共享变量share，没有线程锁时将出现混乱，我们无法预测哪个线程先对share变量进行修改，程序每次运行的结果可能会有不一样：

import time,threading,random

share=1000
lock=threading.Lock()

def add():
	global share
	#随机自增三次
	for i in range(3):
		share+=random.randint(1,10)
		print('线程',threading.current_thread().name,'正在运行,变量share随机自增, share:',share)
		time.sleep(random.random())

def sub():
	global share
	#随机自减三次
	for i in range(3):
		share-=random.randint(1,10)
		print('线程',threading.current_thread().name,'正在运行,变量share随机自减, share:',share)
		time.sleep(random.random())

t1=threading.Thread(target=add,name='add')
t2=threading.Thread(target=sub,name='sub')
t1.start()
t2.start()
t1.join()
t2.join()
print('share:',share)

运行结果：
在这里插入图片描述
加入线程锁之后，就可以等到某个线程执行结束后再执行另一个线程，不会出现交替执行的情况

import time,threading,random

share=1000
lock=threading.Lock()

def add():
	global share
	#随机自增三次
	try:
		lock.acquire()
		for i in range(3):
			share+=random.randint(1,10)
			print('线程',threading.current_thread().name,'正在运行,变量share随机自增, share:',share)
			time.sleep(random.random())
	finally:
		lock.release()
		

def sub():
	global share
	#随机自减三次
	try:
		lock.acquire()
		for i in range(3):
			share-=random.randint(1,10)
			print('线程',threading.current_thread().name,'正在运行,变量share随机自增, share:',share)
			time.sleep(random.random())
	finally:
		lock.release()

t1=threading.Thread(target=add,name='add')
t2=threading.Thread(target=sub,name='sub')
t1.start()
t2.start()
t1.join()
t2.join()
print('share:',share)

执行结果：
在这里插入图片描述

参考资料

Python正则表达式
 Python多进程与多线程
 subprocess.call()