目录
一、进程的创建
1.Python提供了多进程包multiprocessing,借助这个包,可以轻松实现单进程到并发执行的转换,支持子进程通信和共享数据,创建一个Process进程语法格式为:
Process([group[,target[,name[,args[,kwargs]]]]])
2.Process实例方法:
方法 | 说明 |
is_alive() | 若p运行中,返回True |
join([timeout]) | 等待进程P终止,timeout是可选的超时期限,进程可被连接无数次,但是连接自身会出错 |
run() | 进程启动时运行的方法。默认情况下,会调用传递给Process构造函数的target.定义进程的另一-种方法是继承Process类并重新实现run()函数 |
start() | 启动进程,这将运行代表进程的子进程,并调用该子进程中的run()函数 |
terminate() | 强制终止进程。如果调用此函数,进程p将被立即终止,同时不会进行任何清理动作。如果进程p创建了它自己的子进程,这些进程将变为僵尸进程。 |
3.创建子进程并执行
from multiprocessing import Process
from time import sleep
#定义子进程代码
def run_proc(name,**kwargs):
print("子进程正在运行,name为:%s"%name)
print("字典kwargs:",kwargs)
if __name__=='__main__':
print('主进程开始执行')
#创建子进程,target接收任务
p=Process(target=run_proc,args=('proc',),kwargs={'key':12})
#调用子进程
p.start()
4.join()方法的使用
from multiprocessing import Process
from time import sleep
def worker(interval):
print("开始工作")
sleep(interval)
print("停止工作")
if __name__=="__main__":
print("主进程正在执行")
#创建子进程
p=Process(target=worker,args=(3,))
#调用子进程
p.start()
#sleep(5)
#调用join方法,主进程等待调用join的子进程结束
p.join(3)#timeout:等待时常,超出,主进程则先执行
print("主进程执行完毕")
5.Process实例属性
name:进程的名称
pid:进程的整数进程ID
6.使用继承方式创建进程
from multiprocessing import Process
from time import sleep
import time
#定义一个类
class ClockProcess(Process):
#重新初始化方法
def __init__(self,interval):
Process.__init__(self)
self.interval=interval
#重写run()方法
def run(self):
print("子进程开始执行时间:{}".format(time.ctime()))
sleep(self.interval)
print("子进程结束时间:{}".format(time.ctime()))
if __name__=='__main__':
print("主进程正在执行")
#创建子进程
p=ClockProcess(4)
#调用子进程
p.start()
p.join()
print("主进程执行完毕")
主进程正在执行
子进程开始执行时间:Sat Jul 30 16:23:17 2022
子进程结束时间:Sat Jul 30 16:23:21 2022
主进程执行完毕
二、进程之间的通信
1.多个进程之间的数据是不共享的,利用队列的put()和get()方法可以实现进程之间的通信
from multiprocessing import Process,Queue
from time import sleep
#定义写入方法
def write(q):
a=['apple','banana','orange']
for i in a:
print("写入的值为:%s"%i)
q.put(i)
sleep(1)
def reader(q):
for i in range(q.qsize()):
print("读到的值为:%s"%q.get())
sleep(1)
if __name__=="__main__":
#创建队列
q=Queue()
#创建进程
pw=Process(target=write,args=(q,))
pr=Process(target=reader,args=(q,))
pw.start()
pw.join()
pr.start()
pr.join()
写入的值为:apple
写入的值为:banana
写入的值为:orange
读到的值为:apple
读到的值为:banana
读到的值为:orange
三、线程
1.进程与线程的区别:
2.创建线程两种方法
_thread 模块:调用里面的函数start_new_thread()生成一个新的线程
_thred.start_new_thread(function,args[,kwargs])
function:线程函数;args:传递给线程函数的参数,必须为元组类型;kwargs:可选参数
import _thread
import time
def fun1(thread_name,delay): #两个参数,线程名称以及休眠时间
print("开始运行fun1,线程名称:",thread_name)
time.sleep(delay)
print("fun1运行结束")
def fun2(thread_name,delay):
print("开始运行fun2,线程名称:",thread_name)
time.sleep(delay)
print("fun2运行结束")
if __name__=='__main__':
print("开始运行")
#创建线程
_thread.start_new_thread(fun1,('thread-1',3))
_thread.start_new_thread(fun2,('thread-2',3))
time.sleep(6)
threading模块:
通过threading.Thread直接在线程中运行函数
通过继承类threading.Thread来创建线程
import threading
import time
def fun1(thread_name,delay): #两个参数,线程名称以及休眠时间
print("线程名称{}开始运行".format(thread_name))
time.sleep(delay)
print("线程名称{}运行结束".format(thread_name))
def fun2(thread_name,delay):
print("线程名称{}开始运行".format(thread_name))
time.sleep(delay)
print("线程名称{}运行结束".format(thread_name))
if __name__=='__main__':
print("开始运行")
#创建线程
t1=threading.Thread(target=fun1,args=('thread-1',3))
t2=threading.Thread(target=fun2,args=('thread-2',3))
t1.start()
t1.join()
t2.start()
t2.join()
import threading
import time
def fun1(delay):
print("线程名称{}开始运行".format(threading.current_thread().getName()))
time.sleep(delay)
print("线程名称{}运行结束".format(threading.current_thread().getName()))
def fun2(delay):
print("线程名称{}开始运行".format(threading.current_thread().getName()))
time.sleep(delay)
print("线程名称{}运行结束".format(threading.current_thread().getName()))
#创建一个类
class MyThread(threading.Thread):
#重写构造方法
def __init__(self,func,name,args):
super().__init__(target=func,name=name,args=args)
def run(self):
self._target(*self._args)
if __name__=='__main__':
print("开始运行")
#创建线程
t1=MyThread(fun1,'thread-1',(3,))
t2=MyThread(fun2,'thread-2',(3,))
t1.start()
t2.start()
t1.join()
t2.join()