Python之路，day11-Python基础

回顾：
进程
一个程序需要运行所需的资源的集合
每个进程数据是独立的
每个进程里至少有一个线程
进程里可以有多个线程
线程数据是共享的

一个进程的多个线 6程可以充分利用多核cpu


multiprocessing
    pipe
    queue
        实现的是进程间的数据传递，通信

    manager 实现了多进程间的数据共享

        进程间共享数据的代价是高昂的，所以要尽量避免进程间的数据共享

        线程间的数据本来就是共享的
        线程要修改同一份数据，必须加锁，互斥锁mutex
    event
        线程间交互

生产者消费者模型
    解耦 （降低进程间的依赖性）
    提高程序运行效率

    queue
        FIFO
        LIFO
        优先级queue
适用场景：
    线程：
        I/O密集型（I/O不占用cpu)，socket 爬虫 web
    进程：cpu运算密集型，金融分析

1. Gevent协程

   1. 协程

      协程，又称微线程，纤程。英文名Coroutine。一句话说明什么是线程：协程是一种用户态的轻量级线程。

      协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：

      协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态，换种说法：进入上一次离开时所处逻辑流的位置。

      协程的好处：

      • 无需线程上下文切换的开销
      • 无需原子操作锁定及同步的开销
        • 　　"原子操作(atomic operation)是不需要synchronized"，所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）。原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序是不可以被打乱，或者切割掉只执行部分。视作整体是原子性的核心。
      • 方便切换控制流，简化编程模型
      • 高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。

      缺点：

      • 无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
      • 进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序

   2. 协程标准定义，即符合什么条件就能称之为协程：

      1. 必须在只有一个单线程里实现并发
      2. 修改共享数据不需加锁
      3. 用户程序里自己保存多个控制流的上下文栈
      4. 一个协程遇到IO操作自动切换到其它协程

       

   3. Greenlet

   1. greenlet是一个用C实现的协程模块，相比与python自带的yield，它可以使你在任意函数之间随意切换，而不需把这个函数先声明为generator

      # -*- coding:utf-8 -*-
       
       
      from greenlet import greenlet
       
       
      def test1():
          print(12)
          gr2.switch()
          print(34)
          gr2.switch()
       
       
      def test2():
          print(56)
          gr1.switch()
          print(78)
       
       
      gr1 = greenlet(test1)
      gr2 = greenlet(test2)
      gr1.switch()
      
      

   4. Gevent

      1. Gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。

         import gevent
          
         def func1():
             print('33[31;1m李闯在跟海涛搞...33[0m')
             gevent.sleep(2)
             print('33[31;1m李闯又回去跟继续跟海涛搞...33[0m')
          
         def func2():
             print('33[32;1m李闯切换到了跟海龙搞...33[0m')
             gevent.sleep(1)
             print('33[32;1m李闯搞完了海涛，回来继续跟海龙搞...33[0m')
          
          
         gevent.joinall([
             gevent.spawn(func1),
             gevent.spawn(func2),
             #gevent.spawn(func3),
         ])

      2. 同步与异步的性能区别

         import gevent
          
         def task(pid):
             """
             Some non-deterministic task
             """
             gevent.sleep(0.5)
             print('Task %s done' % pid)
          
         def synchronous():
             for i in range(1,10):
                 task(i)
          
         def asynchronous():
             threads = [gevent.spawn(task, i) for i in range(10)]
             gevent.joinall(threads)
          
         print('Synchronous:')
         synchronous()
          
         print('Asynchronous:')
         asynchronous()

2. SelectPollEpoll异步IO与事件驱动

　　　　select 多并发socket 例子

　　　　server

　　　　

#_*_coding:utf-8_*_
__author__ = 'Alex Li'

import select
import socket
import sys
import queue


server = socket.socket()
server.setblocking(0)

server_addr = ('localhost',10000)

print('starting up on %s port %s' % server_addr)
server.bind(server_addr)

server.listen(5)


inputs = [server, ] #自己也要监测呀,因为server本身也是个fd
outputs = []

message_queues = {}

while True:
    print("waiting for next event...")

    readable, writeable, exeptional = select.select(inputs,outputs,inputs) #如果没有任何fd就绪,那程序就会一直阻塞在这里

    for s in readable: #每个s就是一个socket

        if s is server: #别忘记,上面我们server自己也当做一个fd放在了inputs列表里,传给了select,如果这个s是server,代表server这个fd就绪了,
            #就是有活动了, 什么情况下它才有活动? 当然 是有新连接进来的时候 呀
            #新连接进来了,接受这个连接
            conn, client_addr = s.accept()
            print("new connection from",client_addr)
            conn.setblocking(0)
            inputs.append(conn) #为了不阻塞整个程序,我们不会立刻在这里开始接收客户端发来的数据, 把它放到inputs里, 下一次loop时,这个新连接
            #就会被交给select去监听,如果这个连接的客户端发来了数据 ,那这个连接的fd在server端就会变成就续的,select就会把这个连接返回,返回到
            #readable 列表里,然后你就可以loop readable列表,取出这个连接,开始接收数据了, 下面就是这么干 的

            message_queues[conn] = queue.Queue() #接收到客户端的数据后,不立刻返回 ,暂存在队列里,以后发送

        else: #s不是server的话,那就只能是一个 与客户端建立的连接的fd了
            #客户端的数据过来了,在这接收
            data = s.recv(1024)
            if data:
                print("收到来自[%s]的数据:" % s.getpeername()[0], data)
                message_queues[s].put(data) #收到的数据先放到queue里,一会返回给客户端
                if s not  in outputs:
                    outputs.append(s) #为了不影响处理与其它客户端的连接 , 这里不立刻返回数据给客户端


            else:#如果收不到data代表什么呢? 代表客户端断开了呀
                print("客户端断开了",s)

                if s in outputs:
                    outputs.remove(s) #清理已断开的连接

                inputs.remove(s) #清理已断开的连接

                del message_queues[s] ##清理已断开的连接


    for s in writeable:
        try :
            next_msg = message_queues[s].get_nowait()

        except queue.Empty:
            print("client [%s]" %s.getpeername()[0], "queue is empty..")
            outputs.remove(s)

        else:
            print("sending msg to [%s]"%s.getpeername()[0], next_msg)
            s.send(next_msg.upper())


    for s in exeptional:
        print("handling exception for ",s.getpeername())
        inputs.remove(s)
        if s in outputs:
            outputs.remove(s)
        s.close()

        del message_queues[s]

client

#_*_coding:utf-8_*_
__author__ = 'Alex Li'


import socket
import sys

messages = [ b'This is the message. ',
             b'It will be sent ',
             b'in parts.',
             ]
server_address = ('localhost', 10000)

# Create a TCP/IP socket
socks = [ socket.socket(socket.AF_INET, socket.SOCK_STREAM),
          socket.socket(socket.AF_INET, socket.SOCK_STREAM),
          ]

# Connect the socket to the port where the server is listening
print('connecting to %s port %s' % server_address)
for s in socks:
    s.connect(server_address)

for message in messages:

    # Send messages on both sockets
    for s in socks:
        print('%s: sending "%s"' % (s.getsockname(), message) )
        s.send(message)

    # Read responses on both sockets
    for s in socks:
        data = s.recv(1024)
        print( '%s: received "%s"' % (s.getsockname(), data) )
        if not data:
            print(sys.stderr, 'closing socket', s.getsockname() )
复制代码

selectors模块

import selectors
import socket
 
sel = selectors.DefaultSelector()
 
def accept(sock, mask):
    conn, addr = sock.accept()  # Should be ready
    print('accepted', conn, 'from', addr)
    conn.setblocking(False)
    sel.register(conn, selectors.EVENT_READ, read)
 
def read(conn, mask):
    data = conn.recv(1000)  # Should be ready
    if data:
        print('echoing', repr(data), 'to', conn)
        conn.send(data)  # Hope it won't block
    else:
        print('closing', conn)
        sel.unregister(conn)
        conn.close()
 
sock = socket.socket()
sock.bind(('localhost', 10000))
sock.listen(100)
sock.setblocking(False)
sel.register(sock, selectors.EVENT_READ, accept)
 
while True:
    events = sel.select()
    for key, mask in events:
        callback = key.data
        callback(key.fileobj, mask)