网络编程之进程2

寄存器：运行时间快，但是容量比较小

一守护进程

　1 什么是守护进程：

　　守护进程就是辅助主进程的代码的执行，守护进程会伴随着主进程的代码的运行周期的。主进程的代码执行完毕之后，守护进程就没有存在的必要，所以守护进程会在主进程代码执行完毕之后自动终止。

　　守护进程中是无法在开启其他的子进程，否则就会抛出异常。

　2 创建一个守护进程：

　　daemon=True：创建守护进程，daemon默认等于False。

　实例1：

# import multiprocessing
# import time
# def walk(n):
#     print('>>>>>>start',n)
#     time.sleep(3)
#     print('>>>>>>end',n)
# if __name__=='__main__':
#     p1=multiprocessing.Process(target=walk,args=(2,))
#     p2=multiprocessing.Process(target=walk,args=(4,))
#     p1.daemon=True
#     p1.start()
#     p2.start()
#     print('执行完毕')

实例2：

# import multiprocessing
# import time
# def walk(n):
#     print('>>>>>>start',n)
#     time.sleep(3)
#     print('>>>>>>end',n)
# if __name__=='__main__':
#     p1=multiprocessing.Process(target=walk,args=(2,))
#     p2=multiprocessing.Process(target=walk,args=(4,))
#     p1.daemon=True
#     p1.start()
#     p2.start()
#     time.sleep(2)
#     print('执行完毕')

实例3 ：

# import multiprocessing
# import time
# def walk(n):
#     print('>>>>>>start',n)
#     time.sleep(3)
#     print('>>>>>>end',n)
# if __name__=='__main__':
#     p1=multiprocessing.Process(target=walk,args=(2,))
#     p2=multiprocessing.Process(target=walk,args=(4,))
#     p1.daemon=True
#     p1.start()
#     p2.start()
#     print('执行完毕')
#     time.sleep(0.1)

注意：进程和进程之间是相互独立的，只要主进程中的代码没有执行完，守护进程中的代码还是会被执行的。

二同步锁也叫互斥锁

　同步锁的作用是：把并发变成串行，将竞争变得有序化

　　Lock：锁

　　acquire：加上锁

　　release：解锁

如下：

import multiprocessing
import json
import random
import time
json.dump({'count':10},open('a.txt','w'))
time.sleep(1)
def wolk(n):
    ret=json.load(open('a.txt'))
    print('<%s>  查看还剩%s张票'%(n,ret['count']))
def foo(n):
    ret=json.load(open('a.txt'))
    if ret['count']>0:
        x=random.randint(1,5)
        if x>ret['count']:
            x = ret['count']
        ret['count'] -= x
        time.sleep(0.2)
        json.dump(ret, open('a.txt', 'w'))
        print('%s 购买了%s张票' % (n, x))

def wolk_foo(n,lock):
    wolk(n)
    lock.acquire()
    foo(n)
    lock.release()
if __name__=='__main__':
    lock=multiprocessing.Lock()
    for j in range(20):
            p=multiprocessing.Process(target=wolk_foo,args=(j,lock))
            p.start()

　　with 锁：自动加上锁，执行完毕过后自动解开锁。如下：

# import multiprocessing
# import json
# import random
# import time
# json.dump({'count':10},open('a.txt','w'))
# time.sleep(1)
# def wolk(n):
#     ret=json.load(open('a.txt'))
#     print('<%s>  查看还剩%s张票'%(n,ret['count']))
# def foo(n):
#     ret=json.load(open('a.txt'))
#     if ret['count']>0:
#         x=random.randint(1,5)
#         if x>ret['count']:
#             x = ret['count']
#         ret['count'] -= x
#         time.sleep(0.2)
#         json.dump(ret, open('a.txt', 'w'))
#         print('%s 购买了%s张票' % (n, x))
#
# def wolk_foo(n,lock):
#     wolk(n)
#     with lock:
#         foo(n)
# if __name__=='__main__':
#     lock=multiprocessing.Lock()
#     for j in range(20):
#             p=multiprocessing.Process(target=wolk_foo,args=(j,lock))
#             p.start()

加上锁是为了实现串行，保证代码的安全性，但是减低了代码的执行效率

　　注意：在这两个实例中，最开始dump文件的时候是需要一段时间的（也就是I/O阻塞），所以在dump文件的后睡上一段时间，假如不加上睡眠时间，文件数据就会错乱或者报错。

三 IPC机制

　IPC机制就是进程之间的相互通信，分别有两种方式：一种是队列，另一种是管道

　　队列的原理是：先进先出，只能是一头传入数据，另一头读取数据。管道+锁就能实现队列。

　　管道的原理是：

　　队列和管道实现了多个进程之间的共享内存空间。

　Queue：指定队列中存放的数据个数。

　put：写入数据

　get：读取数据

import multiprocessing
q=multiprocessing.Queue(5)
q.put(111)
q.put(222)
q.put(333)
q.put(444)
q.put(555)

print(q.get())
print(q.get())
print(q.get())
print(q.get())
print(q.get())

注意：如果put 和 get 超出了定义存放的个数，就会阻塞

　put_nowait：上传数据，如果超出了存放数据的个数就会抛出异常

　get_nowait：读取数据，如果超出了存放数据的个数就会抛出异常

import multiprocessing
q=multiprocessing.Queue(5)
q.put_nowait(1)
q.put_nowait(2)
q.put_nowait(3)
q.put_nowait(4)
q.put_nowait(5)
print(q.get_nowait())
print(q.get_nowait())
print(q.get_nowait())
print(q.get_nowait())
print(q.get_nowait())

四生产者和消费者

　生产者：创建数据

　消费者：读取（处理）数据

　　生产者和消费者都是由都列分离开的。

　　　生产者创建数据，然后存放到队列里面，接着消费者在队列里面读取数据

import multiprocessing
import random
import time
def producer(q):
    for i in range(1,30):
        time.sleep(random.random())
        q.put('包子%s'%i)
        print('厨师%s创建了包子%s'%('egon'+str(random.randint(1,5)),i))
def consumer(q):
    while True:
        ret=q.get()
        if ret is None:break
        time.sleep(random.random())
        print('%s吃了包子%s'%('alex'+str(random.randint(1,5)),ret))
if __name__=='__main__':
    q = multiprocessing.Queue()
    c_s=multiprocessing.Process(target=producer,args=(q,))
    x_f=multiprocessing.Process(target=consumer,args=(q,))
    c_s.start()
    x_f.start()
    c_s.join()
    q.put(None)

注意：在消费者执行完过后需要加上一个终止条件，不然代码就会一直在那里等待着。

　处理生产者和消费者直接的数据平衡的速度差

　　如何平衡：生产者--------》队列-------》消费者（生产者和消费者解耦）