python自学-class23(up)-python进程基础学习

python进程基础学习

Linux进程

虽然也安装了Linux但是对Linux不大熟悉，Linux环境下python进程的体现只有如下寥寥几行代码：

import subprocess
pingP=subprocess.Popen(args=["data"],shell=True)  #执行Linux指令，打开外部程序
pingP.wait()
print(pingP.Pid) #打印编号
print(pingP.returncode)  #打印返回值

Windows进程

1. multiprocessing
2. join
3. Lock
4. share
5. pipe
6. queue
7. queueplus
8. 进程数据共享
9. 进程共享数组
10.进程共享list与dict
+++++++++++++++++++++++++++++++++++++++++
1.multiprocessing
使用multiprocessing.Process(target=info,args=(“小明”,))创建一个进程，target是方法，args是参数；

import os
import multiprocessing
def info(title):
    print(title)
    print(__name__)
    print("father ppid",os.getppid())
    print("self pid",os.getpid())
    print("-------")

if __name__=="__main__":
    info("hello")
    #多进程,创建进程
    p=multiprocessing.Process(target=info,args=("小明",))
    p.start()
    #p.join()  #join父亲进程必须等待子线程干完活才能执行后续代码
    print("在哪儿")

2.join
使用join使进程按顺序轮流干活，这与线程是类似的

import os
import multiprocessing
import time
def info(title):
    print(title)
    time.sleep(2)
    print(__name__)
    print("father ppid",os.getppid())
    print("self pid",os.getpid())
    print("-------")

if __name__=="__main__":
    p1=multiprocessing.Process(target=info,args=("A",))
    p2=multiprocessing.Process(target=info,args=("B",))
    p3=multiprocessing.Process(target=info,args=("C",))
    #进程并发干活
    p1.start()
    p2.start()
    p3.start()
    print("over")
    '''
        #join使进程轮流干活
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()
    '''

3.Lock
#多进程，并发，乱序并发执行
#多进程加锁可以挨个执行，但是还是乱序

import os
import multiprocessing
import time
#多进程，并发，乱序并发执行
#多进程加锁可以挨个执行，但是还是乱序
def showdata(lock,i):
    with lock:
        time.sleep(2)
        print(i)

if __name__=="__main__":
    lock=multiprocessing.RLock()#创建锁
    for num in range(10):
        multiprocessing.Process(target=showdata,args=(lock,num)).start()

4.share
进程共享需要定义一个全局变量，然后使用global调用全局变量

import multiprocessing
import time
import os

datalist=[]#全局变量
def adddata():   #子进程
    global datalist #引用全局变量
    datalist.append(1)
    datalist.append(2)
    datalist.append(3)
    print(os.getpid(),datalist)

if __name__=="__main__":  #主进程
    p=multiprocessing.Process(target=adddata,args=())
    p.start()
    datalist.append("a")
    datalist.append("b")
    datalist.append("c")
    print(os.getpid(),datalist)

5.pipe
管道模式，一个管道俩个口，一进一出

#a,b=(1,2)
#print(a,b)
import multiprocessing
import os
def func(conn):  #conn是管道类型
    conn.send(["a","b","c","d","e"]) #发送数据
    print(os.getpid(),conn.recv()) #收到数据
    conn.close()

if __name__=="__main__":
    conn_a,conn_b=multiprocessing.Pipe() #创建一个管道，俩个口
    #print(id(conn_a),id(conn_b))
    #print(type(conn_a),type(conn_b))
    p=multiprocessing.Process(target=func,args=(conn_a,))
    p.start()
    conn_b.send([1,2,3,4,5,6,7])
    print(os.getpid(),conn_b.recv())
    p.join()

6.queue队列
队列可以实现共享，但是只能单向通信
#父进程插入，子进程读取
#子进程写入，父进程读取

import multiprocessing
queue=multiprocessing.Queue()  #队列可以实现共享

def func(myq):
    print(id(myq))   #子进程读取
    #myq.put([1,2,3,4,5])  #子进程插入
    print(myq.get())

if __name__=="__main__":
    print(id(queue))
    queue.put([1,2,3,4,5,6])#父进程插入
    p=multiprocessing.Process(target=func,args=(queue,))
    p.start()
    #print("futher",queue.get())  #父进程取出

7.queueplus

import multiprocessing
import os
queue=multiprocessing.Queue()  #队列可以实现共享

def adddata(queue,i):
    queue.put(i)
    print("put",os.getppid(),os.getpid(),i)

if __name__=="__main__":
    mylist=[]
    for i in range(10):
        p=multiprocessing.Process(target=adddata,args=(queue,i))
        p.start()
        #print(queue.get())
        mylist.append(queue.get())
    print(mylist)

8.进程数据共享
使用multiprocessing.Value(“d”,0.0) 实现多个进程之间数据的共享

import multiprocessing
def func(num):
    num.value=10.9
if __name__=="__main__":
    num=multiprocessing.Value("d",0.0) #d数据，多个进程之间共享
    print(num.value)
    p=multiprocessing.Process(target=func,args=(num,))
    p.start()
    p.join()
    print(num.value)

9.进程之间共享数组
使用multiprocessing.Array(“i”,[1,2,3,4,5])实现多个进程之间数组的共享；

import multiprocessing
def func(num):
    num[3]=10
if __name__=="__main__":
    num=multiprocessing.Array("i",[1,2,3,4,5]) #i代表int
    print(num[:])
    p=multiprocessing.Process(target=func,args=(num,))
    p.start()  #进程之间数据共享
    p.join()
    print(num[:])

10.进程之间共享list与dict
使用multiprocessing.Manager()实现

import multiprocessing
def func(mydict,mylist):
    mydict["txm"]="love sleep"
    mydict["tmy"]="love study"
    mylist.append(11)
    mylist.append(22)
    mylist.append(33)

if __name__=="__main__":
    with multiprocessing.Manager() as MG:
        mydict=MG.dict()
        mylist=MG.list(range(5))

        p=multiprocessing.Process(target=func,args=(mydict,mylist))
        p.start()
        p.join()
        print(mylist)
        print(mydict)

总结

python中多线程是伪多线程，即比如0.001s执行某个操作，0.002s执行某个操作。。。，不是真正意义的并发
因此对于网络等待检查这种事件，可以使用多线程，而对于计算密集类型的事件需要使用多进程
CPU密集型：（多进程才是真正意义的并发）
计算，深度学习训练，科学计算，检索数据，内存中
IO密集型：（多线程）
网络下载，网络等待，文件操作