小结

将应用程序对硬件资源的竞态请求变得有序化

串行：一个程序‘完完整整’的执行完了再执行下一个程序

并发：看起来是同时运行的，实际上不是 （切换+保存状态）

并行：真正做到了同时运行

多道技术：（了解）
-空间复用：共用一个内存条，每一个进程都有自己独立的内存空间，互不干扰，物理级别的隔离
-时间复用：共用一个CPU
cpu切换（掌握） ：当进程遇 io 的时候或者占用时间过长，cpu会切换到下一个进程

现代计算机：

-现在的计算机一般书多核，那么每一个核都会利用多道技术

-有4个cpu,运行于CPU1的某个程序遇到 io 阻塞，会等到 io 结束再重新调度，会被调度到4个cpu中的任意一个，具体由操作系统调度算法决定

并发：切换+保存状态

坑 (如果没加 if _ _ name _ _ == '_ _main _ _', 会陷入递归)

开启子进程：把父进程的代码完整复制到一个新的内存空间里去执行
x =1
def task()
print(x)

createProcess(task)

开启子进程的方式一

#1. 导入模块  Process是一个类
from multiprocessing import Process
import time

def task():
    print('进程 start')
    time.sleep(2)
    print('进程 end')

if __name__ == '__main__':
    p=Process(target=task)
    p.start()
    time.sleep(5)
    print('主进程')

开启子进程方式一——多个子进程

#1. 导入模块  Process是一个类
from multiprocessing import Process
import time

def task(x):
    print(f'子进程{x} start')
    time.sleep(2)
    print(f'子进程{x} end')

if __name__ == '__main__':
    p=Process(target=task, args=('Nick',))
    p2=Process(target=task, args=('tank',))
    p.start()
    p2.start()
    time.sleep(5)
    print('主进程')

进程的执行顺序进度有操作系统控制（不是固定的）

开启子进程方式二

# 导入模块
from multiprocessing import Process
import time

# class Test(Process):
#     #用类开启必须要继承Process这个类
#     def run(self):
#         print('子进程 start')
#         time.sleep(2)
#         print('子进程 end')
#
# if __name__ == '__main__':
#     p=Test()
#     p.start()
#     time.sleep(5)
#     print('主进程')

class Test(Process):
    def __init__(self,name):
        super().__init__() #如果不写这一句就是在重写父类中的__init__,运行程序会报错
        self.name=name

    def run(self):
        print(f'子进程{self.name} start')
        time.sleep(2)
        print('子进程{self.end} end')
# p=Test('Nick')
# print(p.name) #Nick

if __name__ == '__main__':
    p=Test('Nick')
    p.start()
    print('主进程')

验证进程的内存空间隔离

from multiprocessing import Process
import time

x = 0
def task():
    global x #把x变成全局变量
    x = 100
    print('子进程的x修改为{}'.format(x))

if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    time.sleep(3)
    print('主进程')

测试

from multiprocessing import Process
import time

def task():
    print('子进程 start')
    time.sleep(2)
    print('子进程 end')

if __name__ == '__main__':
    p = Process(target=task)
    p1 = Process(target=task)

    p.start()
    p1.start()
    time.sleep(5)
    print('主进程')

'''主进程在等待所有的子进程结束
每一个进程都有一个pid，子进程结束后主进程可以立即对其进行回收，也可以等所有的子进程都结束后，主进程结束之前统一回收'''