【多线程】

目录

一、进程的创建

二、进程之间的通信

三、线程

一、进程的创建

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()