python多进程和多线程

斯露德

已于 2023-10-12 19:57:08 修改

阅读量83

点赞数 2

文章标签： python

于 2023-10-03 22:40:32 首次发布

本文链接：https://blog.csdn.net/2301_76481440/article/details/133528004

版权

import time

def sing():
    for i in range(3):
        print("唱歌")
        time.sleep(0.5)
def dance():
    for i in range(3):
        print("跳舞")
        time.sleep(0.5)
if __name__ == "__main__":
    before = time.time()
    sing()
    dance()
    after = time.time()
    print(f"花费时间{after - before}")#3秒多

上面这个就是一个默认主进程

import time
from multiprocessing import Process
#multiprocessing是python中的进程包，从这里面导入可以实例化成进程对象的进程类Process

def sing():
    for i in range(3):
        print("唱歌")
        time.sleep(0.5)
def dance():
    for i in range(3):
        print("跳舞")
        time.sleep(0.5)
if __name__ == "__main__":
    before = time.time()#返回高精度浮点数
    sing_process=Process(target=sing)
    dance_process=Process(target=dance)

    sing_process.start()#对应进程对象启动进程执行函数或者其他任务
    dance_process.start()#上面的进程先启动，但是这俩开始结束时间都差不多（在有时间延迟的条件上），否则也可以说差蛮多
    after = time.time()
    print(f"花费时间{after - before}")#这个和下面%s的精度一样，都比%f的精度高很多
    print("花费时间%s" % (after - before))
    print("花费时间%f" % (after - before))#这个小数点后6位

"""
花费时间0.011434316635131836
花费时间0.011434316635131836
花费时间0.011434
唱歌
跳舞
唱歌
跳舞
唱歌
跳舞

"""
#正是因为有时间延迟，才能一定程度上保证交替显示函数结果

上面这是没有参数的任务的俩非主进程对象的创建和开启，（比子进程先启动的主进程）的任务可能一下子就没了但是他一定会等子进程都结束后再结束

下面是有参数任务的

import time
from multiprocessing import Process
#multiprocessing是python中的进程包，从这里面导入可以实例化成进程对象的进程类Process

def sing(a,b):
    for i in range((a-b)):
        print("唱歌")
        time.sleep(0.5)
def dance(fack,num):
    for i in range((fack-num)):
        print("跳舞")
        time.sleep(0.5)
if __name__ == "__main__":
    before = time.time()#返回高精度浮点数
    sing_process=Process(target=sing,args=(4,1))#args就是用元组对应盲传，元组最起码要有一个逗号，参数不多不少
    dance_process=Process(target=dance,kwargs={'num':1,'fack':4})#kwargs就是用字典的键对应形参名来传参数值，要提前知道形参名，好处是就不用对应顺序

    sing_process.start()#对应进程对象启动进程自动调用执行对应函数或者其他任务
    dance_process.start()#无参任务时上面的进程先启动，但是这俩开始结束时间都差不多（在有时间延迟的条件上），否则也可以说差蛮多
    #传递参数要时间，会拖慢进程对象启动,所以先后没有绝对，并且，上面的出错不会影响下面的非主进程和主进程执行
    after = time.time()
    print(f"花费时间{after - before}")#这个和下面%s和直接输出的精度一样，都比%f的精度高很多
    print("花费时间%s" % (after - before))
    print("花费时间",(after - before))  
    print("花费时间%f" % (after - before))#这个小数点后6位

"""
花费时间0.011434316635131836
花费时间0.011434316635131836
花费时间0.011434316635131836
花费时间0.011434
唱歌
跳舞
唱歌
跳舞
唱歌
跳舞

"""
#正是因为有时间延迟，才能一定程度上保证交替显示函数结果

下面这个是在验证主进程就是非主进程的父进程



import time
from multiprocessing import Process
#multiprocessing是python中的进程包，从这里面导入可以实例化成进程对象的进程类Process
import os
def sing(a,b):
    print("唱歌进程的pid:",os.getpid())
    print("唱歌父进程的pid:",os.getppid())
    for i in range((a-b)):
        print("唱歌")
        time.sleep(0.5)
def dance(fack,num):
    print("跳舞进程的pid:", os.getpid())
    print("跳舞父进程的pid:", os.getppid())
    for i in range((fack-num)):
        print("跳舞")
        time.sleep(0.5)
if __name__ == "__main__":
    print("主进程的pid",os.getpid())#主进程就是非主进程的父进程，因为非主进程对象是在主进程中创建并启动的
    before = time.time()#返回高精度浮点数
    sing_process=Process(target=sing,args=(4,1))#args就是用元组对应盲传，元组最起码要有一个逗号，参数不多不少

    dance_process=Process(target=dance,kwargs={'num':1,'fack':4})#kwargs就是用字典的键对应形参名来传参数值，要提前知道形参名，好处是就不用对应顺序

    sing_process.start()#对应进程对象启动进程执行函数或者其他任务
    dance_process.start()#无参任务时上面的进程先启动，但是这俩开始结束时间都差不多（在有时间延迟的条件上），否则也可以说差蛮多
    #传递参数要时间，会拖慢进程对象启动,所以先后没有绝对，并且，上面的出错不会影响下面的非主进程和主进程执行
    after = time.time()
    print(f"花费时间{after - before}")#这个和下面%s和直接输出的精度一样，都比%f的精度高很多
    print("花费时间%s" % (after - before))
    print("花费时间",(after - before))
    print("花费时间%f" % (after - before))#这个小数点后6位


"""
主进程的pid 5432
花费时间0.012730598449707031
花费时间0.012730598449707031
花费时间 0.012730598449707031
花费时间0.012731
唱歌进程的pid: 11388
跳舞进程的pid: 7068
唱歌父进程的pid: 5432
唱歌
跳舞父进程的pid: 5432
跳舞
唱歌
跳舞
唱歌
跳舞


"""
#正是因为有时间延迟，才能一定程度上保证交替显示函数结果

下面这个是子进程保护父进程（主进程）的代码实例

import time
from multiprocessing import Process
# multiprocessing是python中的进程包，从这里面导入可以实例化成进程对象的进程类Process
import os


def sing(a, b):

    for i in range((a - b)):
        print("唱歌")
        time.sleep(0.5)


def dance(fack, num):

    for i in range((fack - num)):
        print("跳舞")
        time.sleep(0.5)


if __name__ == "__main__":

    before = time.time()
    sing_process = Process(target=sing, args=(4, 1))
    dance_process = Process(target=dance, kwargs={'num': 1, 'fack': 4})

    sing_process.daemon=True
    #由于这里父进程（主进程）任务很快没了，又让sing_process子进程守护父进程，也就是父进程任务结束，这个子进程就彻底结束
    #这时父进程如果还有其他的子进程就不会彻底结束
    sing_process.start()
    dance_process.start()
    after = time.time()
    print(f"花费时间{after - before}")

下面这个是主进程循环里有函数模块直接换高并发的黑马高并发copy器实例：

import os
import time
from multiprocessing import Process


def copy_file(filename, source_dir, dest_dir):
    source_path = source_dir + '\\' + filename
    dest_path = dest_dir + '\\' + filename
    # 想要对文件进行copy转移，就要知道源文件和目标文件的绝对路径，就是上面这俩

    print(source_path + '------------->' + dest_path)

    with open(source_path, "rb") as source_dile:
        with open(dest_path, "wb") as dest_dile:
            # 这俩with就是可以自己关闭这俩文件指针，源文件二进制读取，目标文件二进制写
            while True:
                data = source_dile.read(1024)  # 对同一个文件循环读取，文件指针自己会走，一次读1kb
                if data:
                    dest_dile.write(data)
                else:
                    break
    print(time.time())


if __name__ == "__main__":
    print(time.time())
    source_dir = r"D:\qq文件下载\面经"
    dest_dir = r"C:\Users\86193\Desktop\YYDSdest_dir"
    try:
        os.mkdir(dest_dir)
    except OSError:
        print("已婚，快走开")

    file_list = os.listdir(source_dir)
    for file_name in file_list:
        # copy_file(file_name, source_dir,dest_dir)这是只有主进程
        # 我们要用多子进程高并发，用同一个进程对象名不断指向新的进程对象内存空间
        # 说白了就是不同状态的copy_file函数几乎同时执行，大大减少时间
        sub_process = Process(target=copy_file, args=(file_name, source_dir, dest_dir))  # 需要三个参数，我们这里用元组对应顺序传参
        sub_process.start()

        # 经过验证，非常好用，yyds



"""0.1755038"""

多线程版本

import os
import time

from threading import Thread


def copy_file(filename, source_dir, dest_dir):
    source_path = source_dir + '\\' + filename
    dest_path = dest_dir + '\\' + filename
    # 想要对文件进行copy转移，就要知道源文件和目标文件的绝对路径，就是上面这俩

    print(source_path + '------------->' + dest_path)

    with open(source_path, "rb") as source_dile:
        with open(dest_path, "wb") as dest_dile:
            # 这俩with就是可以自己关闭这俩文件指针，源文件二进制读取，目标文件二进制写
            while True:
                data = source_dile.read(1024)  # 对同一个文件循环读取，文件指针自己会走，一次读1kb
                if data:
                    dest_dile.write(data)
                else:
                    break
    print(time.time())


if __name__ == "__main__":
    print(time.time())
    source_dir = r"D:\qq文件下载\面经"
    dest_dir = r"C:\Users\86193\Desktop\YYDSdest_dir"
    try:
        os.mkdir(dest_dir)
    except OSError:
        print("已婚，快走开")

    file_list = os.listdir(source_dir)
    for file_name in file_list:
        # copy_file(file_name, source_dir,dest_dir)这是只有主线程
        # 我们要用多子线程高并发，用同一个线程对象名不断指向新的线程对象内存空间
        # 说白了就是不同状态的copy_file函数几乎同时执行，大大减少时间
        sub_thread = Thread(target=copy_file, args=(file_name, source_dir, dest_dir))  # 需要三个参数，我们这里用元组对应顺序传参
        sub_thread.start()




    # 经过验证，非常好用，yyds,而且这玩意如果之前目标同名文件已经有了只会更新，不报错
"""0.008163"""

io操作中python多进程不如多线程高，多进程还得用在cpu计算密集任务上


下面是我复制几个jpg图片的时间

多线程：0.008163

多进程：0.1755038

斯露德

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫