创建一个进程需要使用multiprocessing模块的Process方法
使用方法：p1 = Process(target=func)
p1就是进程的对象，func就是进程启动是执行的任务；
在定义任务时也可以向任务中传参，通过Process方法中的args和kwagrs参数为任务中传递参数；
进程对象常用的几种方法：
start() 启动进程，当启动多个进程时为并行；
run() 启动进程，当启动多个任务时为串行，执行完上一个任务再执行下一个任务；
terminate() 终止进程，进程未执行完也终止，但是不释放进程占用的资源；
is_alive() 判断进程是否存活,True为存活，False为结束；
join() 加入，阻塞主进程后面的代码不执行,当对应的子进程执行完毕后再执行
close() 用于释放进程占用的资源，当进程在运行是，不可释放，将会报错，可以与terminate配合使用

代码示例

# encoding: utf-8
"""
进程
线程
协程
进程的多少与服务器的硬件配置相关，需要从cpu中分配资源
"""
from multiprocessing import Process
import time
import os
"""
创建进程示例
    from multiprocessing import Process
    p = Process(target=callable, args=(c1, c2, c3, ), kwagrs='')
    p.start()       #  启动进程

主进程：执行的时候，默认的进程称为主进程
子进程：在主进程中可以开启子进程
进程中的全局变量，在每个子进程中都有一份全局变量，各自操作各自进程中的全局变量，子进程之间互不影响
阻塞主进程后面代码
    p1.join()   # p1为子进程对象
"""
number = 100
def program():
    global number
    for i in range(5):
        print("第{}行代码".format(i), os.getpid(), os.getppid())
        time.sleep(0.5)
    number -= 10
    print("program中的number：", number)

def listen_music():
    global number
    musics = ["《全球》", "《qq》", "《全球2》", "《全球3》"]
    for i in musics:
        print("正在听{}".format(i), os.getpid(), os.getppid())
        time.sleep(0.5)
    number -= 20
    print("listen_music中的number：", number)

def look_book(book):
    global number
    for i in range(5):
        print("正在看书《{}》的第{}页".format(book, i),os.getpid(), os.getppid())
        time.sleep(0.5)
    number -= 30
    print("look_book中的number：", number)



if __name__ == '__main__':
    print("当前py文件进程号{} 以及父进程号{}".format(os.getpid(), os.getppid()))
    p1 = Process(target=program)            # 通过Process创建一个进程对象
    p2 = Process(target=listen_music)
    p3 = Process(target=look_book, args=("西游记", ))      # 在创建一个进程时指定执行的函数，并传递参数
    p1.start()
    p2.start()
    p3.start()
    # p1.run()      # 使用run时仅仅是运行这个进程，并且是串行，不会去cpu中分配新的资源
    # p2.run()
    # p3.run()
    # p1.terminate()        # 终止进程，进程未执行完也终止，但是不释放进程占用的资源
    # print(p1.is_alive())         # 判断进程是否存活,True为存活，False为结束
    # join()    加入，阻塞主进程后面的代码不执行,当对应的子进程执行完成后再执行
    p1.join()
    p2.join()
    p3.join()
    print("main中的number：", number)
    # p1.close()                # 用于释放进程占用的资源，当进程在运行是，不可释放，将会报错，可以与terminate配合使用
    # p2.close()

进程池

from multiprocessing import Process, Pool
import time
import os
"""
进程池：
    Pool
    阻塞式：
    非阻塞式：
    
"""

def task1():
    print("this is task1", os.getpid(), os.getppid())
    return "task2"


def task2(msg):
    print("this is :", msg, os.getpid(), os.getppid())

if __name__ == '__main__':
    print("当前py文件进程号{} 以及父进程号{}".format(os.getpid(), os.getppid()))
        pool = Pool(4)      # 创建进程池
    # 非阻塞式
    for i in range(10):
        pool.apply_async(task1, callback=task2)     # 阻塞式：进程池中一个任务结束后才能进行下一个任务
        print("------------------------>", i)
    pool.close()
    pool.join()             # 阻塞进程池,只有执行完一个进程才会执行下一个,执行完进程池中的所有进程才会执行主进程后面的代码
    print("main, over")