python 进程的理解

前提：提起进程，就要提起操作系统，操作系统也是一个程序，它的亮点：
1.管理底层硬件的所有接口，使在操作系统之上的应用可以很好的调用他们
2.提出了进程管理的概念，调度进程
3.多道技术：单核实现并发的基础
4.多道复用：时间上的复用，空间上的复用

进程

进程就是运行起来的程序代码

并发和并行：

并发只是看起来同时执行，伪并行。单核下多道技术实现；并行，多个cpu同时运行，处理任务。

同步、异步及阻塞和非阻塞

1. 同步与异步针对的是函数/任务的调用方式：同步就是当一个进程发起一个函数（任务）调用的时候，一直等到函数（任务）完成，而进程继续处于激活状态。而异步情况下是当一个进程发起一个函数（任务）调用的时候，不会等函数返回，而是继续往下执行当，函数返回的时候通过状态、通知、事件等方式通知进程任务完成。
2. 阻塞与非阻塞针对的是进程或线程：阻塞是当请求不能满足的时候就将进程挂起，而非阻塞则不会阻塞当前进程

进程定义

import time,random,os
from multiprocessing import Process

####第一种定义
def  add_num(p):
     w = os.getpid()
     res = 0
     num = random.randrange(10,333)
     for  i in range(0,num):

          res = res + i
     print(res,p,w)

if __name__ == '__main__':

    p1 = Process(target=add_num,args=(os.getppid(),))
    p2 = Process(target=add_num,args=(os.getppid(),))
    p3 = Process(target=add_num,args=(os.getppid(),))
    p4 = Process(target=add_num,args=(os.getppid(),))
    p5 = Process(target=add_num, args=(os.getppid(),))
    p6 = Process(target=add_num, args=(os.getppid(),))

    p1.start()
    p2.start()
    p3.start()
    p4.start()
    p5.start()
    p6.start()
    print('主线程')

######第二种定义
class Myprocess(Process):
    def __init__(self,p):
        super().__init__()
        self.p = p
    def run(self):
        w = os.getpid()
        res = 0
        num = random.randrange(10, 333)
        for i in range(0, num):
            res = res + i
        print(res, self.p , w)


if __name__ == '__main__':

    p1 = Myprocess(os.getppid())
    p2 = Myprocess(os.getppid())
    p3 = Myprocess(os.getppid())
    p4 = Myprocess(os.getppid())
    p5 = Myprocess(os.getppid())
    p6 = Myprocess(os.getppid())

    p1.start()
    p2.start()
    p3.start()
    p4.start()
    p5.start()
    p6.start()
    print('主线程')

进程内存空间隔离

bing = 999
def num():
    w = os.getpid()

    bing = 3
    print(bing,w)


if __name__ == '__main__':
    p1 = Process(target=num)
    p2 = Process(target=num)
    p3 = Process(target=num)
    p4 = Process(target=num)
    p5 = Process(target=num)
    p6 = Process(target=num)


    p1.start()
    p2.start()
    p3.start()
    p4.start()
    p5.start()
    p6.start()
    print('主线程',bing)

基于对共享文件的修改实现进程之间的数据通信

# import json,time
# from multiprocessing import Process,Lock
# def search():
#     data = json.load(open('piao',encoding='utf-8'))
#     print(data['p'])
# def get():
#     data = json.load(open('piao', encoding='utf-8'))
#     print(data)
#     if data['p'] > 0:
#         time.sleep(2)
#         data['p']-=1
#         json.dump(data,open('piao','w'))
#         print('ok')
# def run(lock):
#     search()
#     lock.acquire()
#     get()
#     lock.release()
#
# if __name__ == '__main__':
#     lock = Lock()
#     for i in range(10):
#         p = Process(target=run,args=(lock,))
#         p.start()

通过队列实现进程间通信

Queue 可以实现通信但是，程序容易卡死等待

JoinableQueue 通过消费者发送消息，及守护进程的概念，解决Queue的问题

import json,time,random,os
from multiprocessing import Process,Lock,Queue,JoinableQueue

def producer(q):
    for i in range(10):
        time.sleep(random.randint(1,3))
        print('makeout >>',i)
        q.put(i)
    q.join()


    pass
def consumer(q):
    while True:
        res = q.get()
        time.sleep(random.randint(1, 3))
        print('get %s,by %s'%(res,os.getpid()))
        q.task_done()

if __name__ == '__main__':

    # q = Queue()
    q = JoinableQueue()
    p1 = Process(target=producer,args=(q,))
    c1 = Process(target=consumer,args=(q,))
    p1.start()
    c1.daemon =True
    c1.start()
    p1.join()
    print('zhu')