Process进程类的说明

Process([group [, target [, name [, args [, kwargs]]]]])

• group：指定进程组，目前只能使用None
• target：执行的目标任务名
• name：进程名字
• args：以元组方式给执行任务传参
• kwargs：以字典方式给执行任务传参

Process创建的实例对象的常用方法:

• start()：启动子进程实例（创建子进程）
• join()：等待子进程执行结束
• terminate()：不管任务是否完成，立即终止子进程

Process创建的实例对象的常用属性:

name：当前进程的别名，默认为Process-N，N为从1开始递增的整数

import multiprocessing
import time
# 跳舞任务
def dance():
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)
# 唱歌任务
def sing():
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)
if __name__ == '__main__':
    # 创建跳舞的子进程
    # group: 表示进程组，目前只能使用None
    # target: 表示执行的目标任务名(函数名、方法名)
    # name: 进程名称, 默认是Process-1, .....
    dance_process = multiprocessing.Process(target=dance, name="myprocess1")
    sing_process = multiprocessing.Process(target=sing)
    # 启动子进程执行对应的任务
    dance_process.start()
    sing_process.start()
复制代码

多进程创建步骤

1. 导入进程包
2. import multiprocessing
3. 创建子进程并指定执行的任务
4. sub_process = multiprocessing.Process (target=任务名)
5. 启动进程执行任务
6. sub_process.start()

获取进程编号

# os.getpid() 表示获取当前进程编号
# os.getppid() 表示获取当前父进程编号
import multiprocessing
import time
import os

?
# 跳舞任务
def dance():
    # 获取当前进程的编号
    print("dance:", os.getpid())
    # 获取当前进程
    print("dance:", multiprocessing.current_process())
    # 获取父进程的编号
    print("dance的父进程编号:", os.getppid())
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)
        # 扩展:根据进程编号杀死指定进程
        os.kill(os.getpid(), 9)
?
?
# 唱歌任务
def sing():
    # 获取当前进程的编号
    print("sing:", os.getpid())
    # 获取当前进程
    print("sing:", multiprocessing.current_process())
    # 获取父进程的编号
    print("sing的父进程编号:", os.getppid())
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)
?
?
if __name__ == '__main__':
?
    # 获取当前进程的编号
    print("main:", os.getpid())
    # 获取当前进程
    print("main:", multiprocessing.current_process())
    # 创建跳舞的子进程
    # group: 表示进程组，目前只能使用None
    # target: 表示执行的目标任务名(函数名、方法名)
    # name: 进程名称, 默认是Process-1, .....
    dance_process = multiprocessing.Process(target=dance, name="myprocess1")
    sing_process = multiprocessing.Process(target=sing)
?
    # 启动子进程执行对应的任务
    dance_process.start()
    sing_process.start()
复制代码

执行带参数的任务

import multiprocessing
import time
?
?
# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")
?
?
if __name__ == '__main__':
    # 创建子进程
    # args: 以元组的方式给任务传入参数
    # sub_process = multiprocessing.Process(target=task, args=(5,))
    # sub_process.start()
    # kwargs: 表示以字典方式传入参数
    sub_process = multiprocessing.Process(target=task, kwargs={"count": 3})
    sub_process.start()
复制代码

进程之间不共享变量

import multiprocessing
import time
?
# 定义全局变量
g_list = list()
?
?
# 添加数据的任务
def add_data():
    for i in range(5):
        g_list.append(i)
        print("add:", i)
        time.sleep(0.2)
?
    # 代码执行到此，说明数据添加完成
    print("add_data:", g_list)
?
?
def read_data():
    print("read_data", g_list)
?
?
if __name__ == '__main__':
    # 创建添加数据的子进程
    add_data_process = multiprocessing.Process(target=add_data)
    # 创建读取数据的子进程
    read_data_process = multiprocessing.Process(target=read_data)
?
    # 启动子进程执行对应的任务
    add_data_process.start()
    # 主进程等待添加数据的子进程执行完成以后程序再继续往下执行，读取数据
    add_data_process.join()
    read_data_process.start()
?
    print("main:", g_list)
?
    # 总结: 多进程之间不共享全局变量
    #输出
    add: 0
    add: 1
    add: 2
    add: 3
    add: 4
    add_data: [0, 1, 2, 3, 4]
    main: []
    read_data []
复制代码

线程类Thread的说明

Thread([group [, target [, name [, args [, kwargs]]]]])

• group: 线程组，目前只能使用None
• target: 执行的目标任务名
• args: 以元组的方式给执行任务传参
• kwargs: 以字典方式给执行任务传参
• name: 线程名，一般不用设置

import threading
import time
?
# 唱歌任务
def sing():
    # 扩展： 获取当前线程
    # print("sing当前执行的线程为：", threading.current_thread())
    for i in range(3):
        print("正在唱歌...%d" % i)
        time.sleep(1)
?
# 跳舞任务
def dance():
    # 扩展： 获取当前线程
    # print("dance当前执行的线程为：", threading.current_thread())
    for i in range(3):
        print("正在跳舞...%d" % i)
        time.sleep(1)
?
?
if __name__ == '__main__':
    # 扩展： 获取当前线程
    # print("当前执行的线程为：", threading.current_thread())
    # 创建唱歌的线程
    # target： 线程执行的函数名
    sing_thread = threading.Thread(target=sing)
?
    # 创建跳舞的线程
    dance_thread = threading.Thread(target=dance)
?
    # 开启线程
    sing_thread.start()
    dance_thread.start()
复制代码

1. 导入线程模块
2. import threading
3. 创建子线程并指定执行的任务
4. sub_thread = threading.Thread(target=任务名)
5. 启动线程执行任务
6. sub_thread.start()

线程执行带任务的参数

import threading
import time
?
?
# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")
?
?
if __name__ == '__main__':
    # 创建子线程
    # args: 以元组的方式给任务传入参数
    # sub_thread = threading.Thread(target=task, args=(5,))
    # sub_thread.start()
    sub_thread = threading.Thread(target=task, kwargs={"count": 3})
    sub_thread.start()
复制代码

互斥锁

# 创建锁
mutex = threading.Lock()
?
# 上锁
mutex.acquire()
?
...这里编写代码能保证同一时刻只能有一个线程去操作, 对共享数据进行锁定...
?
# 释放锁
mutex.release()
复制代码

互斥锁应用

import threading
?
?
# 定义全局变量
g_num = 0
?
# 创建全局互斥锁
lock = threading.Lock()
?
?
# 循环一次给全局变量加1
def sum_num1():
    # 上锁
    lock.acquire()
    for i in range(1000000):
        global g_num
        g_num += 1
?
    print("sum1:", g_num)
    # 释放锁
    lock.release()
?
?
# 循环一次给全局变量加1
def sum_num2():
    # 上锁
    lock.acquire()
    for i in range(1000000):
        global g_num
        g_num += 1
    print("sum2:", g_num)
    # 释放锁
    lock.release()
?
?
if __name__ == '__main__':
    # 创建两个线程
    first_thread = threading.Thread(target=sum_num1)
    second_thread = threading.Thread(target=sum_num2)
    # 启动线程
    first_thread.start()
    second_thread.start()
?
    # 提示：加上互斥锁，那个线程抢到这个锁我们决定不了，那线程抢到锁那个线程先执行，没有抢到的线程需要等待
    # 加上互斥锁多任务瞬间变成单任务，性能会下降，也就是说同一时刻只能有一个线程去执行