python全栈第十九天 多进程

多进程

# 导入进程包
import multiprocessing
import time


# 跳舞任务
def dance():
    for i in range(3):
        print('跳舞中...')
        time.sleep(0.2)


# 唱歌任务
def sing():
    for i in range(3):
        print('唱歌中...')
        time.sleep(0.2)


# 创建子进程
# group：进程组，目前只能使用的None，一般不需要设置
# target：进程执行的目标任务
# name：进程名，如果不设置，默认是Process-1....
dance_process = multiprocessing.Process(target=dance)
sing_process = multiprocessing.Process(target=sing)

# 启动进程执行的对应任务
dance_process.start()
sing_process.start()
# sing()

获取进程编号

os.getpid 获取当前进程id

os.getppid 获取父进程id

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


# 跳舞任务
def dance():
    for i in range(3):
        # print(os.getpid())
        current_pid = os.getpid()
        print('跳舞中...')
        time.sleep(0.2)
        os.kill(current_pid, 9)


# 唱歌任务
def sing():
    for i in range(3):
        print(os.getpid())
        print("父进程编号{0}".format(os.getppid()))
        print('唱歌中...')
        time.sleep(0.2)


# 获取当前进程（主进程）的编号
print(os.getpid())

# 创建子进程
# group：进程组，目前只能使用的None，一般不需要设置
# target：进程执行的目标任务
# name：进程名，如果不设置，默认是Process-1....
dance_process = multiprocessing.Process(target=dance)
sing_process = multiprocessing.Process(target=sing)

# 启动进程执行的对应任务
dance_process.start()
sing_process.start()
# sing()

进程执行带有任务参数的

元组 args

字典 kwargs

import multiprocessing


def show_info(name, age):
    print(name, age)


# sub_process = multiprocessing.Process(target=show_info, args=('罗紫初', 26))
sub_process = multiprocessing.Process(target=show_info, kwargs={'age': 22, 'name': 'lzc'})
sub_process.start()

进程之间不共享变量

主进程会等子进程执行完再结束

如果强制子进程跟随主进程的生命周期

方法1设置守护 sub_process.daemon = True

方法2先销毁子进程 sub_process.terminate()

线程

多任务除了使用进程来完成，还可以使用线程来实现

线程是进程执行代码的一个分支

多线程的使用

1.导入线程模块

import threading

2.线程类Thread参数说明

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

group:线程组 目前只能使用None

target:执行的目标任务名

name:线程名，一般不设置

args:以元组的方式进行传参

kwargs:以字典的方式进行传参

3.启动线程

start()

import threading
import time


def sing():
    for i in range(3):
        print('唱歌中...')
        time.sleep(0.2)


def dance():
    for i in range(3):
        print('跳舞中...')
        time.sleep(0.2)


if __name__ == '__main__':
    sub_dance_thread = threading.Thread(target=dance)
    sub_sing_thread = threading.Thread(target=sing)
    sub_dance_thread.start()
    sub_sing_thread.start()

主线程会等子线程执行完再结束

子线程可以设置守护

线程之间可以共享数据变量

import threading
import time


g_list = []


def add():
    for i in range(3):
        g_list.append(i)
        print('add:', i)
        time.sleep(0.1)


def read_data():
    print('read:', g_list)


if __name__ == '__main__':
    sub_add_thread = threading.Thread(target=add)
    sub_read_thread = threading.Thread(target=read_data)
    sub_add_thread.start()
    sub_read_thread.start()
    

线程安全，锁

创建锁

mutex = threading.Lock()

上锁

mutex.acquire()

抢资源的代码块

释放锁

mutex.release()

死锁

多线程同时根据下标取值，但是同一个时刻只有一个线程取值

import threading


lock = threading.Lock()


def get_value(index):
    lock.acquire()
    my_list = [1, 4, 6]
    if index >= len(my_list):
        print("下标越界：", index)
        return

    value = my_list[index]
    print(value)
    lock.release()


if __name__ == '__main__':
    for i in range(10):
        sub_thread = threading.Thread(target=get_value, args=(i,))
        sub_thread.start()

正确写法要再return前写lock.release()

进程

优点：可以使用多核，稳定性强

缺点：资源开销大

线程

优点：资源开销小

缺点：不能使用多核，线程不能单独运行，必须在进程里