并发编程,多进程,僵尸进程

# 目录:
#     1,子进程开启的两种方式
#     2,进程内存对象空间彼此隔离
#     3,进程对象的方法或属性详解

# >>>>>>>>>>>>>>>>>>>>>>>>>>>>子进程开启的两种方式>>>>>>>>>>>>>
# 方式一:
#multiprocessing多进程的意思  ,process是他里面的一个类
from multiprocessing import Process
import time

def task(x):
    print('%s is running '%x )
    time.sleep(3)
    print('%s is done '%x)


if __name__ == '__main__':
    # Process(target=task,kwargs={'x':'子进程'})
    # target为开启子进程执行的内容,args为task的传值,一定要是元组的形式,如果是一个参数一定要加逗号
    # P 是process实例化出来的一个对象
    p=Process(target=task,args=('子进程'))
    p.start()#只是在操作系统发送了一个开启子进程的信号,什么时候开启操作系统说了算,管不了
    print('主')



# 方式二:
from multiprocessing import Process

import time
class Myprocess (Process):
    def __init__(self,x):
        super().__init__()#继承父类的__init方法
        # self.name是父类,进程的名字,父类的init方法里面默认有
        self.name=x

    def run(self):#额,自定义子进程的内容,这个run有固定的内部开启方式,不能改
        print('%s is running '%self.name)
        time.sleep(3)
        print('%s is done '% self.name)


if __name__ == '__main__':
    p=Myprocess('子进程1')#修改子进程的名字,不传参数沿用父类
    p.start()  #==p.run()
    print('主')



# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>


from multiprocessing import Process
import time


def task (x,n):
    print('%s is running '%x)
    time.sleep(n)
    print('%s is done '%x )


if __name__ == '__main__':
    # Process(target=task,kwargs={'x':'子进程 '})
    p1=Process(target=task,args=('子进程1',3))#如果args=(),括号内只有一个参数,一定要记住加逗号
    p2=Process(target=task,args=('子进程2',3))#如果args=(),括号内只有一个参数,一定要记住加逗号
    p3=Process(target=task,args=('子进程3',5))
    p1.start()  #只是在操作系统发送一个开启子进程的信号
    p2.start()
    p3.start()


>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>进程的空间彼此隔离

from multiprocessing import Process
import time

x=100
def task():
    global x #由于父进程和子进程的内存空间是物理意义上的隔离,无法修改父进程的全局变量
    x=0
    print('done')

if __name__ == '__main__':
    p=Process(target=task)
    p.start()
    time.sleep(1)#让父进程在原地等待,500秒后才执行下一行代码
    print(x)    #打印父进程的x验证子父进程是否隔离


>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>join 和僵尸进程,孤儿进程

# 1,join 父进程等待子进程结束,子进程结束会保留id 号码,父进程结束时会对子进程的id
# 统一进行回收,如果父进程被强行关闭,子进程还没结束或者说子进程的i


# from multiprocessing import Process
# import time
#
# def task(name):
#     print('%s is running '%name)
#     time.sleep(3)
#     print('%s is done '%name)
#
# if __name__ == '__main__':
#     p=Process(target=task,args=('子进程1',))
#     p.start()
#     p.join()#让父进程在原地等待,等到子进程运行完毕后,才执行下一行代码
#     print('主')


from multiprocessing import Process
import time

# def task(name,n):
#     print('%s is running '%name)
#     time.sleep(n)
#     print('%s is done '%name)
#
# if __name__ == '__main__':
#     p1=Process(target=task,args=('子进程1',1))
#     p2=Process(target=task,args=('子进程2',2))
#     p3=Process(target=task,args=('子进程3',3))
#
#     start=time.time()
#     p1.start()
#     p1.join()   #只有走完了了才会往下走,开启下一个子进程,只是真正意义上的串行
#     p2.start()
#     p2.join()
#     p3.start()
#     p3.join()
#
#     stop=time.time()
#     print('主',(stop-start))

# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
'''
from multiprocessing import Process
import time

def task(name,n):
    print('%s is running '%name)
    time.sleep(n)
    print('%s is done '%name)

if __name__ == '__main__':
    p1=Process(target=task,args=('子进程1',1))
    p1.start()
    p2=Process(target=task,args=('子进程2',2))
    p2.start()
    p3=Process(target=task,args=('子进程3',3))
    p3.start()

    p_l=[]
    start=time.time()
    for i in range(1,4):
        p=Process(target=task,args=('子进程%s'%i,i))
        p_l.append(p)
        p.start()

    print(p_l)
    for p in p_l:
        p.join()  #因为join放在全部的start后面,但第一个join时,其他两个都在计算运行啊

    stop=time.time()
    print('主,',(stop-start))

join
'''

# >>>>>>>>>>>>>>>>>>>>>>>>>>

# from multiprocessing import Process
# import time
# import os
# def task(n):
#     print('%s is running '%os.getpid())
#     time.sleep(n)
#     print('%s is done '%os.getpid())
#
#
# if __name__ == '__main__':
#     p1=Process(target=task,args=(10,))
#     print(p1.pid)
#     p1.start()
#     print(p1.pid)   #父进程内查看子pid的方式
#     print('主')

#
# from multiprocessing import Process
# import time,os
#
# def  task():
#     #os.getpid()拿到的是子进程的id,os.getppid()拿到的是父进程的id
#     print('自己的id :%s 父进程的id :%s '%(os.getpid(),os.getppid()))
#     time.sleep(10)
#
# if __name__ == '__main__':
#     p1=Process(target=task)
#     p1.start()
#     print('主',os.getpid(),os.getppid())



# 了解的知识点
#current_process拿到的是Process类的名字
# from multiprocessing import Process ,current_process
# import time
#
# def task():
#     print('子进程[%s]运行....'%current_process().name)
#     time.sleep(200)
#
# if __name__ == '__main__':
#     p1=Process(target=task,name='子进程1')
#     p1.start()
#     print(p1.name)
#     print('主')


# from multiprocessing import Process,current_process



from multiprocessing import Process,current_process
import time
def task():
    print('子进程[%s]运行....'%current_process().name)
    time.sleep(2)

if __name__ == '__main__':
    p1=Process(target=task,name='子进程1')
    p1.start()

    print(p1.is_alive())
    p1.join()  #想操作系统发请求问p1死了没有,死了会回收操作系统的pid
    print(p1.pid)  #这里的pid已经没有意义了,存在于应用软件的死亡pid
    print(p1.is_alive())

    p1.terminate()
    time.sleep(5)
    print(p1.is_alive())#判断子进程是否存活
    print('主')
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>多进程的真正意义上的并发
自己写的方案

from socket import *
from multiprocessing import Process

phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
phone.bind(('127.0.0.1',8080))

phone.listen(5)



print('m,l,l,l')
class Myprocess(Process):
    def __init__(self,conn):
        super().__init__()
        self.conn=conn


    def run(self):
        while True:
            a=self.conn.recv(1024)
            self.conn.send(a.upper())
        self.conn.close()
        phone.close()

if __name__ == '__main__':
    while True:
        conn,addres=phone.accept()
        p=Myprocess(conn)
        p.start()
        print('完成一次进程')

------------------------------------------------------------------------

六、僵尸进程与孤儿进程

在unix系统中init是所有进程的爹；创建进程用fork，回收进程用waitpid

僵尸进程（有害：占用pid）：子代先于父代终结，其部分信息（pid等）没有从系统中删除，需要父代回收。join中含有回收子代信息的功能。

孤儿进程（无害）：父代先于子代终结，子代终结后的部分信息由init代收。

from multiprocessing import Process                      

import time,os                                           

def task(n):                                             

    print('%s is running' %n)                            

    time.sleep(n)                                        

if __name__ == '__main__':                               

    p1=Process(target=task,args=(1,))                    

    p1.start()                                           

    p1.join()     # join中含有回收子代信息的功能（wait）                                       

    print('======主',os.getpid())                         

    time.sleep(10000)