多任务编程——day6

# 1. 导入进程包
# 2. 使用进程类创建进程对象
# 3. 使用进程对象启动进程执行指定任务


# 1. 导入进程包
import multiprocessing
import time
import os

# 唱歌
def sing(num, name):
    print("唱歌进程的pid：",os.getpid())
    print("唱歌进程的父进程ppid：", os.getppid())
    for i in range(num):
        print(name)
        print("唱歌。。。")
        time.sleep(0.5)


# 跳舞
def dance(num, name):
    print("跳舞进程的pid：", os.getpid())
    print("跳舞进程的父进程ppid：", os.getppid())
    for i in range(num):
        print(name)
        print("跳舞。。。|")
        time.sleep(0.5)


if __name__ == '__main__':
    # 2. 使用进程类创建进程对象
    #   target: 指定进程执行的函数名
    #   args：使用元组方式给指定任务传参
    #          元组的元素顺序就是任务的参数顺序
    #   kwargs: 使用字典方式给指定任务传参
    #           key名就是参数的名字
    sing_process = multiprocessing.Process(target=sing, args=(3, "xiaoming"))
    dance_process = multiprocessing.Process(target=dance, kwargs={"name": "传智", "num": 2})
    # 3. 使用进程对象启动进程执行指定任务
    sing_process.start()
    dance_process.start()

注意点：

import time
import multiprocessing


def work():
    # 子进程工作2秒钟
    for i in range(10):
        print("工作中。。。")
        time.sleep(0.2)


if __name__ == '__main__':
    work_process = multiprocessing.Process(target=work)
    # 设置守护主进程，主进程结束子进程不再执行进程代码
    work_process.daemon = True
    work_process.start()

    # 主进程睡眠1秒钟
    time.sleep(1)
    print("主进程执行完成。。。")

案例：

import os
import multiprocessing


def copy_file(file_name, source_dir, dest_dir):
    # 1. 拼接源文件路径和目标文件路径
    source_path = source_dir + "/" + file_name
    dest_path = dest_dir + "/" + file_name

    # 2. 打开源文件和目标文件
    with open(source_path, "rb") as source_file:
        with open(dest_path, "wb") as dest_file:
            # 3. 循环读取源文件到目标路径
            while True:
                data = source_file.read(1024)
                if data:
                    dest_file.write(data)
                else:
                    break


if __name__ == '__main__':
    # 1. 定义源文件夹和目标文件夹
    source_dir = "D:\任务编程入门"
    dest_dir = "D:\deskbackgrand"

    # 2. 创建目标文件夹
    try:
        os.mkdir(dest_dir)
    except:
        print("目标文件夹已经存在")

    # 3. 读取源文件夹的文件列表
    file_list = os.listdir(source_dir)
    # 4. 遍历文件列表实现拷贝
    # for file_name in file_list:
        # copy_file(file_name, source_dir, dest_dir)
    # 5. 使用多进程实现多任务拷贝
    sub_process = multiprocessing.Process(target=copy_file,
                                          args=(file_name, source_dir, dest_dir))
    sub_process.start()

线程

# 1. 导入线程模块
# 2. 创建线程对象
# 3. 启动线程并执行任务
import time
import threading

def sing():
    for i in range(3):
        print("唱歌。。。")
        time.sleep(1)


def dance():
    for i in range(3):
        print("跳舞。。。")
        time.sleep(1)


if __name__ == '__main__':
    # sing()
    # dance()

    sing_thread = threading.Thread(target=sing)
    dance_thread = threading.Thread(target=dance)


    sing_thread.start()
    dance_thread.start()

线程执行带有参数的任务

import time
import threading

def sing(num,name):
    for i in range(num):
        print(name, ": 唱歌。。。")
        time.sleep(1)


def dance(count):
    for i in range(count):
        print("跳舞。。。")
        time.sleep(1)

if __name__ == '__main__':
    # args:   以元组的方式给执行任务传递参数
    sing_thread = threading.Thread(target=sing, args=(3, "xiaoming"))
    # kwargs： 以字典方式给执行任务传递参数
    dance_thread = threading.Thread(target=dance, kwargs={"count": 2})

    sing_thread.start()
    dance_thread.start()

主线程和子线程的结束顺序

import threading
import time


def work():
    for i in range(10):
        print("工作。。。")
        time.sleep(0.2)


if __name__ == '__main__':
    # sub_thread = threading.Thread(target=work)
    # sub_thread.start()


    # 主线程结束不想等待子线程再结束，可以设置子线程守护主线程
    # 1. threading.Thread(target=work, daemon=True)
    # 2. 线程对象.setDaemon(True)
    # sub_thread = threading.Thread(target=work, daemon=True)
    sub_thread = threading.Thread(target=work)
    sub_thread.setDaemon(True)
    sub_thread.start()


    # 主线程等待1s后结束
    time.sleep(1)
    print("主线程结束了。。。")


# 结论： 主线程会等待所有的子线程执行结束再结束

线程之间的执行顺序

import threading
import time


def task():
    time.sleep(1)
    # current_thread： 获取当前线程的线程对象
    thread = threading.current_thread()
    print(thread)


if __name__ == '__main__':
    for i in range(5):
        sub_thread = threading.Thread(target=task)
        sub_thread.start()


# 多线程之间执行是无序的，由CPU调度

案例

import os
import threading


def copy_file(file_name, source_dir, dest_dir):
    # 1. 拼接源文件路径和目标文件路径
    source_path = source_dir + "/" + file_name
    dest_dir = dest_dir + "/" + file_name
    # 2. 打开源文件和目录文件
    with open(source_path, "rb") as source_file:
        with open(dest_path, "wb") as dest_file:
            # 3. 循环拷贝源文件到目标文件
            while True:
                data = source_file.read(1024)
                if data:
                    dest_file.write(data)

                else:
                    break

if __name__ == '__main__':
    # 1. 定义源目录路径和目标目录路径
    source_dir = "python教学视频"
    dest_dir = "/桌面"

    # 2. 创建目标目录
    try:
        os.mkdir(dest_dir)


    except:
        print("目标目录已经存在")
    # 3. 读取源文件列表
    file_list = os.listdir(source_dir)
    # 4. 遍历列表，获取需要拷贝的源文件
    for file_name in file_list:

        # 5. 创建子进程实现多任务拷贝
        # copy_file(file_name, source_dir, dest_dir)
        sub_thread = threading.Thread(target=copy_file, args=(file_name, source_dir, dest_dir))
        sub_thread.start()