python_day10_IO多路复用
一、python小知识
1、python中无模块作用域
Java /c# 不可以， Python、javascript 可以
for i in range(10):
name = i
print(i) #输出9
2、python是以函数作为作用域
#2、python中是以函数作为作用域：
def foo():
name = "lcj"
print(name)
foo() #执行函数foo()
#输出lcj
小知识3：作用域链接，由内向外找，直到找不到就报错
#作用域链接，由内向外找，直到找不到就报错
name = 'lcj' #全局变量
def f1():
name = 'A'
def f2():
name = 'eric'
print(name) #输出eric
f2()
f1()
小知识4：在函数未执行前，作用域和作用域链已全部确定
小知识5：
li = [x+100 for x in range(10) if x > 6] #当x>6是每个元素自加100
print(li)
#输出：[107, 108, 109]
面试题：
#新浪面试题，X是变量名， lambda:函数
li = [lambda : x for x in range(10) ] #for 每次循环将数据存放至lambda函数中
#li[]列表中元素：为【函数，函数】，函数在没执行前，内部代码不执行
#li[0]为函数
ret = li[0]() #执行函数
print(ret) #输出9
二、python2.7和Python3.5多继承
1、python2.7中默认不继承object类为经典类，一条走到底（无object），继承object则是新式类，此新式类跟Python3.5中新式类一样
2、Python3.5中默认继承object类称为新式类，
三、IO多路复用
I/O多路复用指：通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读操作或则写操作。
1、socket处理多并发读写分离
socketserver:
import select
import socket
sk = socket.socket() #sokcet套接字
sk.bind(("127.0.0.1", 9998)) #绑定ip+端口
sk.listen(5) #监听链接数
input=[sk] #列表中可含多个元素
outpus = []
while True:
relist,wlist,e = select.select(input,outpus,[],1)
print(len(input),len(relist),len(outpus),len(wlist))
for r in relist: #重复连接客户端发来链接
if r == sk: #新客户来链接
conn,address = r.recv(1024) #获取链接
input.append(conn) #将接收信息添加至input列表
conn.sendall(bytes("hello",encoding="utf-8"))
else:
# 客户端发消息
print("--------------")
r.recv(1024) #接收1024字节长度的元素
try:
ret = r.recv(1024)
if not ret:#如果返回值为空则断开连接
raise Exception("断开链接")
else:
outpus.append(r) #将客户端发送信息添加至outpus列表
except Exception as e:
outpus.remove(r)
#所有发给服务器发消息客户端
for w in wlist:
w.sendall(bytes("response",encoding="utf-8"))
outpus.remove(w) #移除当前链接，不然服务器一致给客户端发response
socketclient:
import socket
#socket套接字
sk = socket.socket()
sk.connect(("127.0.0.1", 9998,)) #绑定IP+端口
data = sk.recv(1024)
print(data)
while True:
inp = input(">>>")
sk.sendall(bytes(inp,encoding='utf-8')) #发消息值服务器端
print(sk.recv(1024)) #打印服务器发送信息
sk.close()
2、socket删除服务器端消息队列
import socket
import select
sk = socket.socket()
sk.bind(('127.0.0.1', 9998,))
sk.listen(5)
inputs = [sk,]
outputs = []
messages = {}
# del messages[lcj]
while True:
rlist,wlist,elist, = select.select(inputs, outputs,[],1)
print(len(inputs),len(rlist),len(wlist), len(outputs))
# 监听sk（服务器端）对象，如果sk对象发生变化，表示有客户端来连接了，此时rlist值为【sk】
# 监听conn对象，如果conn发生变化，表示客户端有新消息发送过来了，此时rlist的之为 【客户端】
for r in rlist:
if r == sk: #链接客户端发来的新连接
# 新客户来连接
conn, address = r.accept()
# conn是什么？其实socket对象
inputs.append(conn)
messages[conn] = []
conn.sendall(bytes('hello', encoding='utf-8'))
else:
# 有人给我发消息了
print('=======')
try:
ret = r.recv(1024)
# r.sendall(ret)
if not ret: #如果返回值为空则断开连接
raise Exception('断开连接')
else:
outputs.append(r)
messages[r].append(ret) #将消息放至列表
except Exception as e:
inputs.remove(r)
del messages[r] #删除内存消息队列
# 所有给我发过消息的人
for w in wlist:
msg = messages[w].pop()#默认删除列表中最后一位元素
resp = msg+bytes('response', encoding='utf-8')
w.sendall(resp) #将信息发给客户端
outputs.remove(w)
socketclient:
import socket
#socket套接字
sk = socket.socket()
sk.connect(("127.0.0.1", 9998,)) #绑定IP+端口
data = sk.recv(1024)
print(data)
while True:
inp = input(">>>")
sk.sendall(bytes(inp,encoding='utf-8')) #发消息值服务器端
print(sk.recv(1024)) #打印服务器发送信息
sk.close()
Python提供select、poll、epoll三个方法，分别调用系统的 select，poll，epoll 从而实现IO多路复用。
Windows Python：
提供： select
Mac Python：
提供： select
Linux Python：
提供： select、poll、epoll
注意：网络操作、文件操作、终端操作等均属于IO操作，对于windows只支持Socket操作，其他系统支持其他IO操作，但是无法检测 普通文件操作 自动上次读取是否已经变化。
select方法
句柄列表11, 句柄列表22, 句柄列表33 = select.select(句柄序列1, 句柄序列2, 句柄序列3, 超时时间)
参数： 可接受四个参数（前三个必须）
返回值：三个列表
select方法用来监视文件句柄，如果句柄发生变化，则获取该句柄。
1、当 参数1 序列中的句柄发生可读时（accetp和read），则获取发生变化的句柄并添加到 返回值1 序列中
2、当 参数2 序列中含有句柄时，则将该序列中所有的句柄添加到 返回值2 序列中
3、当 参数3 序列中的句柄发生错误时，则将该发生错误的句柄添加到 返回值3 序列中
4、当 超时时间 未设置，则select会一直阻塞，直到监听的句柄发生变化
当 超时时间 ＝ 1时，那么如果监听的句柄均无任何变化，则select会阻塞 1 秒，之后返回三个空列表，如果监听的句柄有变化，则直接执行。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import select
import threading
import sys
while True:
readable, writeable, error = select.select([sys.stdin,],[],[],1)
if sys.stdin in readable:
print 'select get stdin',sys.stdin.readline()
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket
import select
sk1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk1.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sk1.bind(('127.0.0.1',8002))
sk1.listen(5)
sk1.setblocking(0)
inputs = [sk1,]
while True:
readable_list, writeable_list, error_list = select.select(inputs, [], inputs, 1)
for r in readable_list:
# 当客户端第一次连接服务端时
if sk1 == r:
print 'accept'
request, address = r.accept()
request.setblocking(0)
inputs.append(request)
# 当客户端连接上服务端之后，再次发送数据时
else:
received = r.recv(1024)
# 当正常接收客户端发送的数据时
if received:
print 'received data:', received
# 当客户端关闭程序时
else:
inputs.remove(r)
sk1.close()
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket
ip_port = ('127.0.0.1',8002)
sk = socket.socket()
sk.connect(ip_port)
while True:
inp = raw_input('please input:')
sk.sendall(inp)
sk.close()
此处的Socket服务端相比与原生的Socket，他支持当某一个请求不再发送数据时，服务器端不会等待而是可以去处理其他请求的数据。但是，如果每个请求的耗时比较长时，select版本的服务器端也无法完成同时操作。
基于select实现socketf服务端
Linux中的 select，poll，epoll 都是IO多路复用的机制
select
select最早于1983年出现在4.2BSD中，它通过一个select()系统调用来监视多个文件描述符的数组，当select()返回后，该数组中就绪的文件描述符便会被内核修改标志位，使得进程可以获得这些文件描述符从而进行后续的读写操作。
select目前几乎在所有的平台上支持，其良好跨平台支持也是它的一个优点，事实上从现在看来，这也是它所剩不多的优点之一。
select的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，不过可以通过修改宏定义甚至重新编译内核的方式提升这一限制。
另外，select()所维护的存储大量文件描述符的数据结构，随着文件描述符数量的增大，其复制的开销也线性增长。同时，由于网络响应时间的延迟使得大量TCP连接处于非活跃状态，但调用select()会对所有socket进行一次线性扫描，所以这也浪费了一定的开销。
poll
poll在1986年诞生于System V Release 3，它和select在本质上没有多大差别，但是poll没有最大文件描述符数量的限制。
poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。
另外，select()和poll()将就绪的文件描述符告诉进程后，如果进程没有对其进行IO操作，那么下次调用select()和poll()的时候将再次报告这些文件描述符，所以它们一般不会丢失就绪的消息，这种方式称为水平触发（Level Triggered）。
epoll
直到Linux2.6才出现了由内核直接支持的实现方法，那就是epoll，它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。
epoll可以同时支持水平触发和边缘触发（Edge Triggered，只告诉进程哪些文件描述符刚刚变为就绪状态，它只说一遍，如果我们没有采取行动，那么它将不会再次告知，这种方式称为边缘触发），理论上边缘触发的性能要更高一些，但是代码实现相当复杂。
epoll同样只告知那些就绪的文件描述符，而且当我们调用epoll_wait()获得就绪文件描述符时，返回的不是实际的描述符，而是一个代表就绪描述符数量的值，你只需要去epoll指定的一个数组中依次取得相应数量的文件描述符即可，这里也使用了内存映射（mmap）技术，这样便彻底省掉了这些文件描述符在系统调用时复制的开销。
另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而epoll事先通过epoll_ctl()来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知。
1）查找socket源码：
A：查找源码时快速定位__ini__构造方法及其下属包含哪些方法
内部调用流程为：
- 启动服务端程序
- 执行 TCPServer.__init__ 方法，创建服务端Socket对象并绑定 IP 和 端口
- 执行 BaseServer.__init__ 方法，将自定义的继承自SocketServer.BaseRequestHandler 的类 MyRequestHandle赋值给 self.RequestHandlerClass
- 执行 BaseServer.server_forever 方法，While 循环一直监听是否有客户端请求到达 ...
- 当客户端连接到达服务器
- 执行 ThreadingMixIn.process_request 方法，创建一个 “线程” 用来处理请求
- 执行 ThreadingMixIn.process_request_thread 方法
- 执行 BaseServer.finish_request 方法，执行 self.RequestHandlerClass() 即：执行 自定义 MyRequestHandler 的构造方法（自动调用基类BaseRequestHandler的构造方法，在该构造方法中又会调用 MyRequestHandler的handle方法）
四、多线程、多进程
定义：
进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必 不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.
关系：
一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行.
相对进程而言，线程是一个更加接近于执行体的概念，它可以与同进程中的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。
区别：
1) 简而言之,一个程序至少有一个进程,一个进程至少有一个线程.
2) 线程的划分尺度小于进程，使得多线程程序的并发性高。
3) 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
4) 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
5) 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
优缺点：
线程执行开销小，但不利于资源的管理和保护；而进程正相反。同时，线程适合于在SMP机器上运行，而进程则可以跨机器迁移
1、一个应用程序，可以有多个进程和多线程
2、默认：单进程，单线程
3、单进程，多线程：IP操作 不占用CPU
4、GIL，全局解释器锁
线程常用方法：
setDaemon（True）方法：设置true，表示主进程在不等待子线程执行完就终止，比如：子线程运行时间为2秒，程序运行时，从行之下运行，先执行主线程
join（2）方法：表示主线程运行到此，等待子线程运行完在接着执行join下面的代码，如join参数设置2，表示主线程最多等待子线程2秒。就直接运行join下面的代码，不等待子线程运行完了
import threading
import time
#单进程、单线程的应用程序
def f1(arg): #子线程
time.sleep(2)
print(arg)
#创建主线程
t =threading.Thread(target=f1,args=(123,))
t.setDaemon(True) #true:主线程不等子线程
t.start() #不代表当前线程会被立即会被立即执行
t.join(3) #join方法：表示主线程到此，等待、、直到子线程呢过执行完毕。
#参数3：表示主线程再次最多等待几秒
print("end")
print("end")
print("end")
