进程 和 多进程

#################     ============     multiprocess.process模块    多进程     ============
# process模块介绍
# process模块是一个创建进程的模块，借助这个模块，就可以完成进程的创建。
#     功能
# Process([group [, target [, name [, args [, kwargs]]]]])，
# 由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）
#
# 强调：
# 1. 需要使用关键字的方式来指定参数
# 2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号
#
# 参数介绍：
# 1 group参数未使用，值始终为None
# 2 target表示调用对象，即子进程要执行的任务
# 3 args表示调用对象的位置参数元组，args=(1,2,'egon',)
# 4 kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}
# 5 name为子进程的名称

# os.getpid()) # 查看当前进程的进程号
#  os.getppid()) # 查看当前进程的父进程
# p = Process(target=func,args=('参数','参数2'))   # 注册
#  p是一个进程对象,还没有启动进程
# p.start()       # 开启了一个子进程


# 方法介绍
# 1 p.start()：启动进程，并调用该子进程中的p.run()
# 2 p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法
# 3 p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，
# 使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
# 4 p.is_alive():如果p仍然运行，返回True
# 5 p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。
#p.join()     # 是感知一个子进程的结束,将异步的程序改为同步
# timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程


#  属性介绍
# 1 p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，
# 并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
# 2 p.name:进程的名称
# 3 p.pid：进程的pid
# 4 p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)
# 5 p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。
# 这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）


#  一个子进程
# import os
# import time
# from multiprocessing import Process
# def func(args,args2):
#     print(args,args2)
#     time.sleep(3)
#     print('子进程 :', os.getpid())
#     print('子进程的父进程 :', os.getppid())
#     print(12345)
#
# if __name__ == '__main__':
#     p = Process(target=func,args=('参数','参数2'))   # 注册
#     # p是一个进程对象,还没有启动进程
#     p.start()       # 开启了一个子进程
#     print('*'*10)
#     print('父进程 :',os.getpid()) # 查看当前进程的进程号
#     print('父进程的父进程 :',os.getppid()) # 查看当前进程的父进程

# 进程的生命周期
    # 主进程
    # 子进程
    # 开启了子进程的主进程 :
        # 主进程自己的代码如果长,等待自己的代码执行结束,
        # 子进程的执行时间长,主进程会在主进程代码执行完毕之后等待子进程执行完毕之后 主进程才结束

#    =============== === = == = = = = = = =  join()
# import time
# from multiprocessing import Process
#
# def func(arg1,arg2):
#     print('*'*arg1)
#     time.sleep(5)
#     print('*'*arg2)
#
# if __name__ == '__main__':
#     p = Process(target=func,args=(10,20))
#     p.start()
#     print('hahahaha')
#     p.join()     # 是感知一个子进程的结束,将异步的程序改为同步
#     print('====== : 运行完了')


#   = =  开启多个子进程后的 join 用法
# import os
# import time
# from multiprocessing import Process
#
# def func(filename,content):
#     with open(filename,'w') as f:
#         f.write(content*10*'*')
#
# if __name__ == '__main__':
#     p_lst = []
#     for i in range(10):
#         p = Process(target=func,args=('info%s'%i,0))
#         p_lst.append(p)
#         p.start()
#     for p in p_lst:p.join()   # 之前的所有进程必须在这里都执行完才能执行下面的代码
#     print([i for i in os.walk(r'E:python10day37')])


#     多进程的 第二种方式
# import os
# from multiprocessing import Process
#
# class MyProcess(Process):
#     def __init__(self,arg1,arg2):
#         super().__init__()
#         self.arg1 = arg1
#         self.arg2 = arg2
#
#     def run(self):         #必须是run
#         print(self.pid)
#         print(self.name)
#         print(self.arg1)
#         print(self.arg2)
#
# if __name__ == '__main__':
#     p1 = MyProcess(1,2)
#     p1.start()
#     p2 = MyProcess(3,4)
#     p2.start()

# 自定义类 继承Process类
# 必须实现一个run方法,run方法中是在子进程中执行的代码



# 进程 与 进程之间 数据隔离问题
# import os
# from multiprocessing import Process
#
# def func():
#     global n   # 声明了一个全局变量
#     n = 0       # 重新定义了一个n
#     print('pid : %s'%os.getpid(),n)
#
# if __name__ == '__main__':
#     n = 100
#     p = Process(target=func)
#     p.start()
#     p.join()
#     print(os.getpid(),n)


#        =============              守护进程
# 子进程 -- > 守护进程
# 会随着主进程的结束而结束。
# 主进程创建守护进程
# 　　其一：守护进程会在主进程代码执行结束后就终止
# 　　其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children
# 注意：进程之间是互相独立的，主进程代码运行结束，守护进程随即终止
# import time
# from multiprocessing import Process
#
# def func():
#     while True:
#         time.sleep(0.2)
#         print('我还活着')
#
# def func2():
#     print('in func2 start')
#     time.sleep(8)
#     print('in func2 finished')
#
# if __name__ == '__main__':
#     p = Process(target=func)
#     p.daemon = True   # 设置子进程为守护进程
#     p.start()
#     p2 = Process(target=func2)
#     p2.start()
#     p2.terminate()     # 结束一个子进程
#     time.sleep(1)
#     print(p2.is_alive())  # 检验一个进程是否还活着
#     print(p2.name)
#     i = 0
#     while i<5:
#         print('我是socket server')
#         time.sleep(1)
#         i+=1

# 守护进程 会 随着 主进程的代码执行完毕 而 结束
# 在主进程内结束一个子进程 p.terminate()
    #  结束一个进程不是在执行方法之后立即生效,需要一个操作系统响应的过程
# 检验一个进程是否活着的状态 p.is_alive()
# p.name p.pid 这个进程的名字和进程号


#  锁 保护文件
# 锁
#互斥锁同时只允许一个线程更改数据

# 火车票
# import json
# import time
# from multiprocessing import Process
# from multiprocessing import Lock
#
# def show(i):
#     with open('ticket') as f:
#         dic = json.load(f)
#     print('余票: %s'%dic['ticket'])
#
# def buy_ticket(i,lock):
#     lock.acquire() #拿钥匙进门
#     with open('ticket') as f:
#         dic = json.load(f)
#         time.sleep(0.1)
#     if dic['ticket'] > 0 :
#         dic['ticket'] -= 1
#         print('33[32m%s买到票了33[0m'%i)
#     else:
#         print('33[31m%s没买到票33[0m'%i)
#     time.sleep(0.1)
#     with open('ticket','w') as f:
#         json.dump(dic,f)
#     lock.release()      # 还钥匙
#
# if __name__ == '__main__':
#     for i in range(10):
#         p = Process(target=show,args=(i,))
#         p.start()
#     lock = Lock()
#     for i in range(10):
#         p = Process(target=buy_ticket, args=(i,lock))
#         p.start()


#           进程    补充
#同一台机器子进程不能使用input和主进程通话
# from multiprocessing import Process
# def func():
#     num = input('>>>')
#     print(num)
#
# if __name__ == '__main__':
#     Process(target=func).start()