python 进程

# 概念
    # 同步异步阻塞和非阻塞
        # 同步阻塞 : 调用一个函数需要等待这个函数的执行结果,并且在执行这个函数的过程中CPU不工作
            # inp = input('>>>')
        # 同步非阻塞 :调用一个函数需要等待这个函数的执行结果,在执行这个函数的过程中CPU工作
            # ret = eval('1+2+3-4')
        # 异步非阻塞 :调用一个函数不需要等待这个函数的执行结果,并且在执行这个函数的过程中CPU工作
            # start()
        # 异步阻塞 : 调用一个函数不需要等待这个函数的执行结果,并且在执行这个函数的过程中CPU不工作
            # 开启10个进程 异步的
            # 获取这个进程的返回值,并且能做到哪一个进程先结束,就先获取谁的返回值
    # 进程的三状态图
        # 就绪 -操作系统调度->运行 -遇到io操作-> 阻塞 -阻塞状态结束-> 就绪
        #                         -时间片到了-> 就绪
    # 进程的调度算法 : 短作业和长作业是有区别的,越长的作业被调度的没有短作业调度的积极
                     # 每一个io操作都会让你辛苦排来的队执行的CPU机会让给其他程序
        # 先来先服务
        # 短作业优先
        # 分时的概念
        # 多级反馈算法
    # 进程开启和关闭
        # 父进程 开启了 子进程
        # 父进程 要负责给 子进程 回收子进程结束之后的资源

# from multiprocessing import Process
#
# def task(n):
#     print(123)
#     print(345)
#
# if __name__ == '__main__':
#     p1 = Process(target=task,args=(1,))
#     p1.start()
#     p2 = Process(target=task,args=(1,))
#     p2.start()
#     p1.join() # 阻塞 等待p1执行完毕  join加入
#     p2.join() # 阻塞 等待p2执行完毕
#     p3 = Process(target=task,args=(1,))
#     p3.start()

# Process类拾遗
    # 开启进程的另一种方法
        # 面向对象的方法,通过继承和重写run方法完成了启动子进程
        # 通过重写init和调用父类的init完成了给子进程传参数
    # Process类的一些其他方法属性
        # name pid ident daemon
        # terminate() isalive()
    # 守护进程
        # 在start一个进程之前设置daemon = True
        # 守护进程会等待主进程的代码结束就立即结束
            # 为什么守护进程只守护主进程的代码?而不是等主进程结束之后才结束
                # 因为主进程要最后结束,为了给守护进程回收资源
            # 守护进程会等待其他子进程结束么? 不会
# 进程同步 -- Lock 锁  *****
    # 进程之间数据安全的问题

# 进程之间通信 -- 队列 ***
# 进程之间的数据共享 -- Manager *

# import time
# from multiprocessing import Process
#
# def son1():
#     while True:
#         print('--> in son1')
#         time.sleep(1)
#
# def son2():   # 执行10s
#     for i in range(10):
#         print('in son2')
#         time.sleep(1)
#
# if __name__ == '__main__':    # 3s
#     p1 = Process(target=son1)
#     p1.daemon = True    # 表示设置p1是一个守护进程
#     p1.start()
#     p2 = Process(target=son2,)
#     p2.start()
#     time.sleep(3)
#     print('in main')


# 主进程会等待所有的子进程结束,是为了回收子进程的资源
# 守护进程会等待主进程的代码执行结束之后再结束,而不是等待整个主进程结束.
# 主进程的代码什么时候结束,守护进程就什么时候结束,和其他子进程的执行进度无关

# 要求守护进程p1必须在p2进程执行结束之后才结束
# import time
# from multiprocessing import Process
#
# def son1():
#     while True:
#         print('--> in son1')
#         time.sleep(1)
#
# def son2():   # 执行10s
#     for i in range(10):
#         print('in son2')
#         time.sleep(1)
#
# if __name__ == '__main__':    # 3s
#     p1 = Process(target=son1)
#     p1.daemon = True    # 表示设置p1是一个守护进程
#     p1.start()
#     p2 = Process(target=son2,)
#     p2.start()
#     time.sleep(3)
#     print('in main')
#     p2.join()    # 等待p2结束之后才结束

# 等待p2结束 --> 主进程的代码才结束 --> 守护进程结束

# 进城之间数据隔离
# 进程之间通信(IPC) Inter Process communication
    # 基于文件 :同一台机器上的多个进程之间通信
        # Queue 队列
            # 基于socket的文件级别的通信来完成数据传递的
    # 基于网络 :同一台机器或者多台机器上的多进程间通信
        # 第三方工具(消息中间件)
            # memcache
            # redis
            # rabbitmq
            # kafka