day36

 1、 进程理论
        并发、并行、串行
        进程运行的三种状态：（运行态、就绪态）非阻塞态、阻塞态
        调用任务的两种方式：同步调用、异步调用
 2、 进程的使用
        process

#1、什么是进程
进程是一个程序运行的过程

#2、什么是程序
程序就是一堆代码文件

#3、串行、并发、并行
串行：多个任务依次运行，一个运行完毕再运行下一个
并行：多个任务是真的在同时运行，只有多个cpu才有并行的概念
并发：多个任务看起来是在同时运行

#4、进程的创建
windows：CreateProcess
linux：fork
    对于通用系统，需要有系统运行过程中创建或撤销进程的能力，主要分为4种形式创建新的进程
　　1. 系统初始化（查看进程linux中用ps命令，windows中用任务管理器，前台进程负责与用户交互，后台运行的进程与用户无关，运行在后台并且只在需要时才唤醒的进程，称为守护进程，如电子邮件、web页面、新闻、打印）
　　2. 一个进程在运行过程中开启了子进程（如nginx开启多进程，os.fork,subprocess.Popen等）
　　3. 用户的交互式请求，而创建一个新进程（如用户双击暴风影音）
　　4. 一个批处理作业的初始化（只在大型机的批处理系统中应用）

无论哪一种，新进程的创建都是由一个已经存在的进程执行了一个用于创建进程的系统调用而创建的：
　　1. 在UNIX中该系统调用是：fork，fork会创建一个与父进程一模一样的副本，二者有相同的存储映像、同样的环境字符串和同样的打开文件（在shell解释器进程中，执行一个命令就会创建一个子进程）
　　2. 在windows中该系统调用是：CreateProcess，CreateProcess既处理进程的创建，也负责把正确的程序装入新进程。

      关于创建的子进程，UNIX和windows
　　1.相同的是：进程创建后，父进程和子进程有各自不同的地址空间（多道技术要求物理层面实现进程之间内存的隔离），任何一个进程的在其地址空间中的修改都不会影响到另外一个进程。
　　2.不同的是：在UNIX中，子进程的初始地址空间是父进程的一个副本，提示：子进程和父进程是可以有只读的共享内存区的。但是对于windows系统来说，从一开始父进程与子进程的地址空间就是不同的。

#5、进程的终止
    1. 正常退出（自愿，如用户点击交互式页面的叉号，或程序执行完毕调用发起系统调用正常退出，在linux中用exit，在windows中用ExitProcess）
　　2. 出错退出（自愿，python a.py中a.py不存在）
　　3. 严重错误（非自愿，执行非法指令，如引用不存在的内存，1/0等，可以捕捉异常，try...except...）
　　4. 被其他进程杀死（非自愿，taskill /F /PID 3333）

#6、程序运行的三种状态
运行态
就绪态
阻塞态


优化程序效率的核心法则：降低IO操作（硬盘IO、网络IO）
内存-->本地硬盘-->网络IO

#7、
进程运行的三种状态：（运行态、就绪态）非阻塞态、阻塞态
调用任务的两种方式：同步调用、异步调用



# import os
# import time
#
# print(os.getpid())
# time.sleep(1000)
# 可通过管理员cmd输入  ”taskkill /f /pid '进程id'  “ 终止进程

# 启动子进程
# 方式一
# from multiprocessing import Process
# import time
# import os
#
#
# def task(n, tag):
#     print('%s is running' % tag)
#     time.sleep(n)
#     print('%s is done' % tag)
#
#
# if __name__ == '__main__':
#     p1 = Process(target=task, args=(5, '子进程1'))       # 创建进程对象
#     p2 = Process(target=task, args=(3, '子进程2'))
#     p3 = Process(target=task, args=(2, '子进程3'))
#     p1.start()                                          # 启动子进程
#     p2.start()
#     p3.start()
#     print('主进程--->%s' % os.getpid())

# 方式二
# from multiprocessing import Process
# import time
# import os
#
#
# class Myprocess(Process):
#     def __init__(self, tag):
#         super(Myprocess,self).__init__()
#         self.tag = tag
#
#     def run(self) -> None:
#         print('%s is running.' % self.tag)
#         time.sleep(3)
#         print('%s is done.' % self.tag)
#
#
# if __name__ == '__main__':
#     p1 = Myprocess('子进程1')  # 创建进程对象
#     p2 = Myprocess('子进程2')
#     p3 = Myprocess('子进程3')
#     p1.start()                # p1.run()
#     p2.start()
#     p3.start()
#     print('主进程--->%s' % os.getpid())


# join      # 使主进程等待当前子进程运行结束后再运行后续代码
# （1）
# from multiprocessing import Process
# import time
# import os
#
#
# def task(n, tag):
#     print('%s is running' % tag)
#     time.sleep(n)
#     print('%s is done' % tag)
#
#
# if __name__ == '__main__':
#     p1 = Process(target=task, args=(5, '子进程1'))
#     p1.start()
#     p1.join()             # p1.join(timeout=3)  timeout指定时间，经过指定时间后无论进程是否结束都会开始运行后续代码
#     print('主进程--->%s' % os.getpid())

# （2）串行
# from multiprocessing import Process
# import time
# import os
#
#
# def task(n, tag):
#     print('%s is running' % tag)
#     time.sleep(n)
#     print('%s is done' % tag)
#
#
# if __name__ == '__main__':
#     p1 = Process(target=task, args=(5, '子进程1'))
#     p2 = Process(target=task, args=(3, '子进程2'))
#     p3 = Process(target=task, args=(2, '子进程3'))
#     start = time.time()
#     p1.start()
#     p1.join()
#
#     p2.start()
#     p2.join()
#
#     p3.start()
#     p3.join()
#     end = time.time()
#     print(end - start)
#     print('主进程--->%s' % os.getpid())


# （3）并发
# from multiprocessing import Process
# import time
# import os
#
#
# def task(n, tag):
#     print('%s is running' % tag)
#     time.sleep(n)
#     print('%s is done' % tag)
#
#
# if __name__ == '__main__':
#     p1 = Process(target=task, args=(5, '子进程1'))
#     p2 = Process(target=task, args=(3, '子进程2'))
#     p3 = Process(target=task, args=(2, '子进程3'))
#
#     start = time.time()
#     p1.start()
#     p2.start()
#     p3.start()
#
#     p1.join()
#     p2.join()
#     p3.join()
#     end = time.time()
#     print(end - start)
#     print('主进程--->%s' % os.getpid())


# 注意：是主进程等待，子进程不受影响
# from multiprocessing import Process
# import time
# import os
#
#
# def task(n, tag):
#     print('%s is running' % tag)
#     time.sleep(n)
#     print('%s is done' % tag)
#
#
# if __name__ == '__main__':
#     p1 = Process(target=task, args=(5, '子进程1'))
#     p2 = Process(target=task, args=(3, '子进程2'))
#     p3 = Process(target=task, args=(2, '子进程3'))
#
#     start = time.time()
#     p1.start()
#     p2.start()
#     p3.start()
#
#     p3.join()
#     p1.join()
#     p2.join()
#
#     end = time.time()
#     print(end - start)
#     print('主进程--->%s' % os.getpid())