python之进程和线程3

1 multiprocessing模块

（1.）直接导入
from multiprocessing import Process
import os
import time
def info(name):
    print("name:",name)
    print('parent process:', os.getppid())
    print('process id:', os.getpid())
    print("------------------")
def foo(name):
    info(name)
    time.sleep(50)
if __name__ == '__main__':
    info('main process line')
    p1 = Process(target=info, args=('alvin',))
    p2 = Process(target=foo, args=('egon',))
    p1.start()
    p2.start()

    p1.join()
    p2.join()

    print("ending")
time.sleep(100)
>>
name: main process line
parent process: 16976
process id: 18456
------------------
name: alvin
parent process: 18456
process id: 19884
------------------
name: egon
parent process: 18456
process id: 19112
------------------
ending

　　

（2．）创建类的方法

构造方法：

Process([group [, target [, name [, args [, kwargs]]]]])

　　group: 线程组，目前还没有实现，库引用中提示必须是None；

　　target: 要执行的方法；

　　name: 进程名；

args/kwargs: 要传入方法的参数。

实例方法：

　　is_alive()：返回进程是否在运行。

　　join([timeout])：阻塞当前上下文环境的进程程，直到调用此方法的进程终止或到达指定的timeout（可选参数）。

　　start()：进程准备就绪，等待CPU调度

　　run()：strat()调用run方法，如果实例进程时未制定传入target，这star执行t默认run()方法。

　　terminate()：不管任务是否完成，立即停止工作进程

属性：

　　daemon：和线程的setDeamon功能一样

　　name：进程名字。

　　pid：进程号。

2 协程

协程的优点：

（1）     由于单线程不存在切换

（2）     不再有任何锁的概念

yield是最基本的携程函数
没有办法监听到IO，进行切换
可以保存到数据的状态通过send方法来运行
import time
# 注意到consumer函数是一个generator（生成器）:
# 任何包含yield关键字的函数都会自动成为生成器(generator)对象

def consumer():
    r = ''
    while True:
        n = yield r
        if not n:
            return
        print('[CONSUMER] ←← Consuming %s...' % n)
        time.sleep(1)
        r = '200 OK'
def produce(c):
    # 1、首先调用c.next()启动生成器
    next(c)
    n = 0
    while n < 5:
        n = n + 1
        print('[PRODUCER] →→ Producing %s...' % n)
        # 2、然后，一旦生产了东西，通过c.send(n)切换到consumer执行；
        cr = c.send(n)
        # 4、produce拿到consumer处理的结果，继续生产下一条消息；
        print('[PRODUCER] Consumer return: %s' % cr)
    # 5、produce决定不生产了，通过c.close()关闭consumer，整个过程结束。
    c.close()
if __name__=='__main__':
    # 6、整个流程无锁，由一个线程执行，produce和consumer协作完成任务，所以称为“协程”，而非线程的抢占式多任务。
    c = consumer()
    produce(c)

　　

greenlet模块

可以实现手动切换

调用属性swich

gevent可以实现IO的监听

gevent.joinall 开启所有程序

gevent.spawn 切换

 

3 IO模型

IO指input, output

IO发生时涉及的对象和步骤

会涉及到两个系统对象，一个是调用这个IO的process(or thread)，另一个就是系统内核(kernel)。当一个操作发生时，会经历两个阶段：

（1）     等待数据准备

（2）     将数据从内核拷贝到进程中

IO模型类型：

1. 1.      阻塞  IO

1. 1.      非阻塞 IO

非阻塞IO：发送多次系统调用

优点：wait for data无阻塞

缺点：系统调用太多

          不能及时拿到数据

两个阶段：wait for data非阻塞

               copy data 阻塞

非阻塞的recvform系统调用调用之后，进程并没有被阻塞，内核马上返回给进程，如果数据还没准备好，此时会返回一个error。进程在返回之后，可以干点别的事情，然后再发起recvform系统调用。重复上面的过程，循环往复的进行recvform系统调用。这个过程通常被称之为轮询。轮询检查内核数据，直到数据准备好，再拷贝数据到进程，进行数据处理。需要注意，拷贝数据整个过程，进程仍然是属于阻塞的状态。

1. 1.      IO多路复用（监听多个链接）

特点：（1）全程阻塞

能监听多个文件描述符  实现并发

#服务端

import select

import socket

sock=socket.socket()#产生一个套接字

sock.bind(("127.0.0.1",8080))

sock.listen(5)

sock.setblocking(False)

inputs=[sock,]

while 1:

    r,w,e=select.select(inputs,[],[])#监听有变化的套接字sock

    #wait for data

    for obj in r:

        if obj==sock:

            conn,addr=obj.accept()#从内核copy信息到用户态

            print("conn",conn)

            inputs.append(conn)#监听列表添加客户conn

        else:

            data=obj.recv(1024)#接收信息

            print(data.decode("utf8"))

            send_data=input(">>")#发送信息

            obj.send(send_data.encode("utf8"))

#客户端

import socket

sock=socket.socket()

sock.connect(("127.0.0.1",8080))

while 1:

    data=input("input>>")

    sock.send(data.encode("utf8"))

    recv_data=sock.recv(1024)

    print(recv_data.decode("utf8"))

 

sock.close()

　　

对于文件描述符（套接字对象）

(1)    是一个非零整数，不会变

(2)    收发数据的时候，对于接收端而言，数据先到内核空间，然后copy到用户空间，同时，内核空间数据清除

1. 1.      异步IO

全程无阻塞

5.驱动信号

小结：

有阻塞blocking

无阻塞non-blocking

调用blocking IO会一直block住对应的进程知道操作完成

non-blocking IO在kernel还准备数据的情况下会立刻返回

有阻塞是同步阻塞：阻塞  非阻塞  IO多路复用

无阻塞是异步阻塞：异步IO

4 selectors模块

IO多路复用实现机制

Win:select

Linux:select,poll,epoll

Select缺点：1.每次调用select都要将所有的fd(文件描述符)拷贝到内核空间，导致效率下降

           2.遍历所有的fd，是否有数据访问（最重要的问题）

           3.最大连接数（1024）

poll:最大连接数没有限制

epoll:1.第一个函数创建epoll句柄，将所有的fd(文件描述符)拷贝到内核空间

        只需要拷贝一次

      2.回调函数：某一个函数或者某一个动作成功完成之后会触发的函数

        为所有的fd绑定一个回调函数，但有数据访问触发该回调函数

        回调函数将fd放到列表中

import selectors
import socket
sock=socket.socket()
sock.bind(("127.0.0.1",8080))
sock.listen(5)
sock.setblocking(False)
sel=selectors.DefaultSelector()#根据具体平台选择最佳IO多路机制
def read(conn,mask):
    try:
        data=conn.recv(1024)
        print(data.decode("utf8"))
        data2=input(">>")
        conn.send(data2.encode("utf8"))
    except Exception:
        sel.unregister(conn)
def accept(sock,mask):
    sel.register(sock,selectors.EVENT_READ,accept)
    conn,addr=sock.accept()
    sel.register(conn,selectors.EVENT_READ,read)
sel.register(sock,selectors.EVENT_READ,accept)#注册功能
while 1:
    events=sel.select()
    for key,mask in events:
        print(key.data)#定义的函数
        print(key.fileobj)#socket对象
        func=key.data
        obj=key.fileobj
        func(obj,mask)

break


import socket
sock=socket.socket()
sock.connect(("127.0.0.1",8080))
while 1:
    data=input("input>>")
    sock.send(data.encode("utf8"))
    recv_data=sock.recv(1024)
    print(recv_data.decode("utf8"))

sock.close()

　　

5. 队列

队列用在多线程，多进程中，用来保护数据

队列是个数据类型

优点：线程安全

import queue
q=queue.Queue(3)#默认是先进先出
q.put(111)
q.put("hello")
q.put(222)
print(q.get())
print(q.get())
print(q.get())
>>
111
hello
222

import queue
q=queue.Queue(3)#默认是先进先出
q.put(111)
q.put("hello")
q.put(222)
q.put(223,False)#q=queue.Queue(3)队列定义只能放3个值，
# #超过限额时，返回错误信息
print(q.get())
print(q.get())
print(q.get())

q.get()#没有数据的时候不会报错，只会等待
q.get(False)#数据为空，报错

先进后出
import queue
q=queue.LifoQueue()
q.put(111)
q.put(5)
q.put(43)
print(q.get())

优先级
import queue
q=queue.PriorityQueue()
q.put([4,"hello"])
q.put([1,"hello5"])
print(q.get())