后端那些事

class: middle, inverse, center
#后端那些事
### yihaibo
2015年12月29日
---
# 后端研究什么
##总结:4个一
- 语言(python)
- 操作系统(linux)
- 存储(mysql)
- 领域(web, 数据分析,web安全,密码技术)
---
# 语言
一.静态语言,动态语言,弱类型语言,强类型语言
- 区别
- 举例
 Python是动态强类型语言
 Golang是静态强类型语言
 C是静态弱类型语言
- 反射(自省)
---
二.并发与并行
- 区别
- 举例
 Erlang, Golang是天生支持并行的
 Python由于GIL限制单进程只能并发
---
三.Python
- 数据类型, 数据结构
- 推导式与函数式
- 算法
- 反射
- 属性拦截
- 装饰器
- 描述符和属性
- 生成器
- 元类
- 垃圾回收
- 多线程与多进程
- 其它
---
###数据类型
所有数据类型都是对象
```
# 64位操作系统
In [40]: sys.getsizeof(1)
Out[40]: 24
In [41]: sys.getsizeof(1L)
Out[41]: 28
In [42]: sys.getsizeof("")
Out[42]: 37
In [43]: sys.getsizeof("hello")
Out[43]: 42
In [44]: sys.getsizeof([])
Out[44]: 72
In [45]: sys.getsizeof([1])
Out[45]: 80
```
---
class: middle
####什么时候2+2==5?
```
In [50]: 2+2
Out[50]: 4
In [51]: ctypes.memmove(id(4), id(5), 24)
Out[51]: 11637008
In [52]: 2+2
Out[52]: 5
In [53]: 4
Out[53]: 5
```
---
###数据结构
- list, tuple, dict, set
- collection.namedtuple, collection.deque, collection.OrderedDict, collections.defaultdict
- Queue.Queue
```
Person=collections.namedtuple('Person','name age gender')
p=Person("kehan", 2, "female")
p.name
Out[12]: 'kehan'
```
####思考 底层原理???
---
- 可变与不可变
```
In [1]: def test(gameids=[1,2]):
 ...: gameids.append(3)
 ...: print(gameids)
In [2]: test()
[1, 2, 3]
In [3]: test()
[1, 2, 3, 3]
In [4]: test.func_defaults
Out[4]: ([1, 2, 3, 3],)
```
```
In [18]: a={}
In [19]: b=[]
In [20]: a[b]=1
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-20-2bfc1dd9a880> in <module>()
----> 1 a[b]=1
TypeError: unhashable type: 'list'
```
---
class: middle
```
persons = {}
class Person(object):
 def __init__(self, name):
 self.name = name
 def __hash__(self):
 return hash(self.name)
persons[Person("kehan")] = 1
print(Person("kehan") in persons) #False
```
---
class: middle
```
persons = {}
class Person(object):
 def __init__(self, name):
 self.name = name
 def __hash__(self):
 return hash(self.name)
 def __eq__(self, r):
 return True if r.name == self.name else False
persons[Person("kehan")] = 1
print(Person("kehan") in persons) #True
```
---
### 推导式与函数式
comprehension: list, dict, set
函数式: map, filter, reduce等
```python
t_columns = filter(lambda x: x.endswith("_time"),
 model.FIELDS)
t_columns = [f for f in model.FIELDS
 if f.endswith("_time")]
# 小于0置为0
ages = [-1, 10, 20]
sum([age if age>=0 else 0 for age in ages ])
sum(age if age>=0 else 0 for age in ages) # 生成器
sum(map(lambda age: age if age>=0 else 0, ages))
```
---
###算法
####排序
```
peoples = [
 {"age": 1, "name": "kehan"},
 {"age": 24, "name": "lwy"},
 {"age": 25, "name": "skycrab"},
]
# age从小到大,
sorted(peoples, key=lambda p:p["age"])
# 从大到小
sorted(peoples, key=operator.itemgetter("age"),
 reverse=True)
operator.attrgetter # 属性
operator.itemgetter #元素
operator.methodcaller #方法
```
---
class: middle
```
#最大age
max(peoples, key=operator.itemgetter("age"))
{'age': 25, 'name': 'skycrab'}
min(peoples, key=operator.itemgetter("age"))
{'age': 25, 'name': 'skycrab'}
# operator模块是一个宝藏
a = [1, 2, 3]
reduce(operator.imul, a) # 6
reduce(lambda x, y: x+y, a) # 6
```
---
####二分查找
前提: 已排序数列
```
a=[1, 5, 10, 15,20]
# bisect.bisect_right(a, x) 返回a中插入x的序号
bisect.bisect_right(a, 11)
Out[11]: 3
bisect.insort_right(a,11)
In [13]: a
Out[13]: [1, 5, 10, 11, 15, 20]
```
---
###堆排序
解决TOP N问题
```
# heapq是最小堆
a=[1]
heapq.heappush(a, 10) # a=[1, 10]
heapq.heappop(a) #弹出1
heapq.nlargest(2, peoples,
 key=operator.itemgetter("age"))
[{'age': 25, 'name': 'skycrab'}, {'age': 24, 'name': 'lwy'}]
```
---
###反射(自省)
- getattr, setattr, hasattr, dir
- \_\_dict\_\_, \_\_slots\_\_
- callable, isinstance
- traceback
- inspect
好处是什么???
- orm
---
class:inverse
```
In [13]: class Person(object):
 ....: desc = "person object"
 ....: def __init__(self):
 ....: self.age = 100
 In [14]: Person.__dict__
 Out[14]:
 <dictproxy {'__dict__': <attribute '__dict__' of 'Person' objects>,
 '__doc__': None,
 '__init__': <function __main__.__init__>,
 '__module__': '__main__',
 '__weakref__': <attribute '__weakref__' of 'Person' objects>,
 'desc': 'person object'}>
 In [15]: p=Person()
 In [16]: p.__dict__
 Out[16]: {'age': 100}
 In [22]: hasattr(p, "age")
 Out[22]: True
 In [23]: getattr(p, "desc")
 Out[23]: 'person object'
 ```
---
class:inverse
```
class Point(object):
 def __init__(self, x, y):
 self.x = x
 self.y = y
In [24]: P=Point(1,1)
In [28]: P.__dict__
Out[28]: {'x': 1, 'y': 1}
In [38]: P.age=100
class EPoint(object):
 __slots__ = ("x","y")
 def __init__(self, x, y):
 self.x = x
 self.y = y
In [33]: Ep=EPoint(1,1)
In [35]: Ep.__dict__
AttributeError: 'EPoint' object has no attribute '__dict__'
In [39]: Ep.age=100
AttributeError: 'EPoint' object has no attribute 'age'
```
---
class:inverse
```
In [26]: isinstance(p, Person)
Out[26]: True
In [29]: callable(os.path.join)
Out[29]: True
In [33]: class FunCall(object):
 def __call__(self, *args, **kwargs):
 print(args, kwargs)
In [34]: f=FunCall()
In [35]: callable(f)
Out[35]: True
In [36]: f("hello", name="funcall")
(('hello',), {'name': 'funcall'})
In [10]: try:
 ....: 1/0
 ....: except Exception:
 ....: print(traceback.format_exc())
 ....:
 .........ZeroDivisionError: integer division or modulo by zero
```
---
###属性拦截
```
# dataeye/statistics/bi/sdkincome.py
class Merge(object):
 ""获取django多个结果""
 def __init__(self, query_set):
 self.query_set = query_set
 def __getattr__(self, name):
 return sum(getattr(q, name)
 for q in self.query_set)
class ObjectDict(dict):
 """字典当做对象使用"""
 def __getattr__(self, name):
 try:
 return self[name]
 except KeyError:
 raise AttributeError(name)
 def __setattr__(self, name, value):
 self[name] = value
```
---
```
# dataeye/statistics/context_processors.py
class PermWrapper(object):
 def __init__(self, user):
 self.user = user
 self.superuser = user.is_superuser
 self.perms = set(["101", "102"])
 def __getitem__(self, module_name):
 if hasattr(self, module_name):
 return getattr(self, module_name)
 return module_name in self.perms
perm = PermWrapper()
perm["superuser"]
perm["101"]
```
---
###装饰器
- 闭包
- 好处, 解耦
- 面向切面编程(aop)
- 用处(日志记录,权限控制,事物处理等)
- 分类(不带参数,带参数,类装饰器)
```
cf = ConfigParser.ConfigParser()
cf.read("config.ini")
get = functools.partial(cf.get, "analyse")
cf.get("analyse", "host")
print(get("host"), get("db"), get("user"))
```
---
```
def XXX(func):
 @wraps(func)
 def wrapper(*args, **kwargs):
 # before hook
 return func(*args, **kwargs)
 # after hook
 return wrapper
def super_required(view_func):
 """超级用户控制"""
 @wraps(view_func)
 def decorator(request, *args, **kwargs):
 if request.user.is_authenticated()
 and request.user.is_superuser:
 return view_func(request,*args,**kwargs)
 else:
 return HttpResponseRedirect("/login/
 ?next= {0}".format(request.path))
 return decorator
```
---
需求:使用torndb,记录执行的sql语句和执行时间
属性拦截与装饰器结合
```
# analyse/script/fabfile.py 简化
def log(level):
 """记录日志"""
 assert level in ("debug", "info", "warn", "error")
 def decorator(func):
 @wraps(func)
 def wrapper(*args, **kwargs):
 start = time.time()
 result = func(*args, **kwargs)
 write = getattr(logger, level)
 write("sql: %s\nrun time: %s seconds",
 args, time.time()-start)
 return result
 return wrapper
 return decorator
```
---
```
# analyse/script/fabfile.py
class Connection(object):
 def __init__(self):
 self.conn = torndb.Connection(HOST, DB, USER, PASSWORED)
 def __getattr__(self, name):
 func = getattr(self.conn, name)
 return log("info")(func)
conn = Connection()
conn.get("select * from manage_ana_app where id=7")
conn.execute("delete * from manage_ana_app")
sql: select * from manage_ana_app where id=7
run time: 0.5111111 seconds
```
---
### 描述符和属性
- 作用: 覆盖默认属性查找方式
 a.x -> a.\_\_dict\_\_['x'] ->type(a).\_\_dict\_\_['x'] -> baseclass(type(a)).\_\_dict\_\_['x']
- \_\_get\_\_, \_\_set\_\_, \_\_delete\_\_
 数据描述符: \_\_get\_\_, \_\_set\_\_ (描述符优先)
 非数据描述符: \_\_get\_\_ (\_\_dict\_\_优先)
- 只支持new style objects
 描述符是由\_\_getattribute\_\_调用,只在新式类中才有
- properties, methods, statis methods, class methods, super
- classmethod实现原理
详细参考: https://docs.python.org/2/howto/descriptor.html?highlight=descriptor
---
class: middle
```
#非数据描述符
class descriptor(object):
 def __init__(self, value):
 self.value = value
 def __get__(self, obj, type=None):
 print obj, type
 return self.value
class Test(object):
 def __init__(self):
 self.age = 100
 age = descriptor(200)
t= Test()
print(t.age) # 100
```
---
```
#数据描述符
class descriptor(object):
 def __init__(self, value):
 self.value = value
 def __get__(self, obj, type=None):
 return self.value
 def __set__(self, obj, value):
 pass
class Test(object):
 def __init__(self):
 self.age = 100
 age = descriptor(200)
t= Test()
print(t.age) # 200
```
---
class: middle
ClassMethod实现原理
```
class ClassMethod(object):
 "Emulate PyClassMethod_Type() in Objects/funcobject.c"
 def __init__(self, f):
 self.f = f
 def __get__(self, obj, klass=None):
 if klass is None:
 klass = type(obj)
 def newfunc(*args):
 return self.f(klass, *args)
 return newfunc
```
---
```
# analyse/bi/util.py
class class_property(object):
 """ A property can decorator class or instance
 class Foo(object):
 @class_property
 def foo(cls):
 return 42
 print(Foo.foo)
 print(Foo().foo)
 """
 def __init__(self, func, name=None, doc=None):
 self.__name__ = name or func.__name__
 self.__module__ = func.__module__
 self.__doc__ == doc or func.__doc__
 self.func = func
 def __get__(self, obj, type=None):
 value = self.func(type)
 return value
```
---
class:middle, inverse
```
class cached_property(object):
 """ A property that is only computed once per instance and
 then replaces itself with an ordinary attribute.
 Deleting the attribute resets the property.
 class Foo(object):
 @cached_property
 def foo(self):
 return 42*100*100
 print(Foo().foo)
 """
 def __init__(self, func):
 self.__doc__ = getattr(func, '__doc__')
 self.func = func
 def __get__(self, obj, cls):
 if obj is None: return self
 value = obj.__dict__[self.func.__name__] =
 self.func(obj)
 return value
```
---
class:middle
```
class class_cached_property(object):
 def __init__(self, func):
 self.__doc__ = getattr(func, '__doc__')
 self.func = func
 def __get__(self, obj, cls):
 if cls is None:
 return self
 value = self.func(cls)
 setattr(cls, self.func.__name__, value)
 return value
```
---
###生成器
```
In [2]: g=(2*x for x in range(2))
In [3]: g
Out[3]: <generator object <genexpr> at 0x00000000043E6630>
In [4]: g.next()
Out[4]: 0
In [5]: g.next()
Out[5]: 2
In [6]: g.next()
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
<ipython-input-6-d7e53364a9a7> in <module>()
----> 1 g.next()
StopIteration:
```
---
```
In [12]: def task():
 ....: for x in range(2):
 ....: yield x
 ....:
In [13]: t=task()
In [14]: t
Out[14]: <generator object task at 0x00000000035F9558>
In [15]: print(t.next())
0
In [16]: print(t.next())
1
In [17]: print(t.next())
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
<ipython-input-19-487d3bab2781> in <module>()
----> 1 print(t.next())
StopIteration:
```
---
class: middle
```
def task():
 begin = yield
 print("begin",begin)
 yield
 for x in range(begin):
 yield x
t = task()
t.send(None)
t.send(2)
print([x for x in t])
result:
('begin', 2)
[0, 1]
```
---
```
def thread1():
 for x in range(4):
 yield x
def thread2():
 for x in range(4,8):
 yield x
threads=[]
threads.append(thread1())
threads.append(thread2())
def run(threads): #写这个函数,模拟线程并发
 pass
run(threads)
```
---
class:middle
```
def run(threads): #写这个函数,模拟线程并发
 for t in threads:
 try:
 print t.next()
 except StopIteration:
 pass
 else:
 threads.append(t)
结果:
0
4
1
5
2
6
3
7
```
---
class:inverse
```
class Task(object):
 def __init__(self):
 self._queue = collections.deque()
 self.work = 0
 def add(self, gen):
 self._queue.append(gen)
 self.work += 1
 def finish(self):
 return self.work <= 0 def run(self): while not self.finish(): try: gen = self._queue.popleft() gen.send(None) except StopIteration: self.work -= 1 else: self._queue.append(gen) t=Task() t.add(thread1()) t.add(thread2()) t.run() ``` --- ###上下文管理器 ####with 协议 ``` class cd(object): def __init__(self, path): self.src = os.getcwd() self.dest = path def __enter__(self): os.chdir(self.dest) def __exit__(self, exc_type, exc_val, exc_tb): """返回True忽略异常""" os.chdir(self.src) ``` --- class: middle ``` from contextlib import contextmanager @contextmanager def cd(path): cwd = os.getcwd() try: os.chdir(path) yield finally: os.chdir(cwd) ``` --- ###元类 - type ``` In [25]: class A(object): ....: pass ....: In [26]: type(A) Out[26]: type In [27]: B = type("B", (object,), {"name":"BBB"}) In [28]: B Out[28]: __main__.B In [30]: B.name Out[30]: 'BBB' ``` --- - \_\_new\_\_(cls, classname, bases, dict_attr) - \_\_init\_\_(cls, classname, bases, dict_attr) 注意: - \_\_new\_\_的cls参数是元类自己 - \_\_init\_\_的cls参数是元类创建的那个类 ``` _extract = {} _site = re.compile(r".*\.(?P<site>.+?)\.com")
def parse(url):
 """解析视频真实地址"""
 site = _site.search(url).group('site')
 parser = _extract[site]
 return parser.parse(url)
parse("http://www.letv.com/ptv/vplay/1111.html")
```
---
```
class VideoMeta(type):
 def __init__(cls, classname, bases, dict_attr):
 """注意这里是cls, 如Video, LeTv"""
 assert hasattr(cls, "parse")
 assert hasattr(cls, "NAME")
 _extract[dict_attr["NAME"]] = cls()
 return type.__init__(cls, classname, bases, dict_attr)
class Video(object):
 __metaclass__ = VideoMeta
 NAME = "BASE"
 def parse(self, url):
 raise NotImplementedError
class LeTv(Video):
 """乐视TV"""
 NAME = "letv"
 def parse(self, url):
 pass
```
---
class: middle
```
class UpperMeta(type):
 """将属性修改为大写, 只能是__new__"""
 def __new__(cls, classname, bases, dict_attr):
 attr = {k.upper() if not k.startswith("__") else
 k : v for k,v in dict_attr.items()}
 return type.__new__(cls, classname, bases, attr)
class Person(object):
 __metaclass__ = UpperMeta
 name = "lwy"
 age = 24
print( "name" in Person.__dict__) #False
print( "NAME" in Person.__dict__) #True
```
---
###垃圾回收
引用计数为主,标记-清除和分代收集为辅
```
In [33]: class A(object):
 ....: pass
 ....:
In [34]: a=A()
In [36]: sys.getrefcount(a)
Out[36]: 2
In [37]: sys.getrefcount?
Return the reference count of object. The count returned is generally
one higher than you might expect, because it includes the (temporary)
reference as an argument to getrefcount().
In [38]: b=a
In [39]: sys.getrefcount(a)
Out[39]: 3
```
---
引用计数
- 优点
 简单, 实时
- 缺点
 吞吐量不高, 循环引用
标记-清除:
```
gc.set_debug(gc.DEBUG_STATS)
a = []
b = []
a.append(b)
b.append(a)
del a
del b
print("unreachable:", gc.collect())
gc: collecting generation 2...
gc: objects in each generation: 504 3398 0
gc: done, 2 unreachable, 0 uncollectable, 0.0010s elapsed.
('unreachable:', 2)
```
---
class:middle
```
# 没有不可达对象,靠引用计数就可以
gc.set_debug(gc.DEBUG_STATS)
a = []
b = []
a.append(b)
b.append(a)
del a
print("unreachable:", gc.collect())
gc: collecting generation 2...
gc: objects in each generation: 504 3398 0
gc: done, 0.0010s elapsed.
('unreachable:', 0)
```
---
- gc.enable()
- gc.disable()
- gc.get_threshold() (700, 10, 10)
- gc.collect([generation]) 返回不可达对象数量
- gc.is_tracked()
```
In [62]: gc.is_tracked(1)
Out[62]: False
In [63]: gc.is_tracked("")
Out[63]: False
In [64]: gc.is_tracked([])
Out[64]: True
In [67]: gc.is_tracked((1,))
Out[67]: True
In [68]: gc.is_tracked({})
Out[68]: False
In [69]: gc.is_tracked({'a':1})
Out[69]: False
In [70]: gc.is_tracked({'a':[]})
Out[70]: True
```
---
### 当循环引用遇到\_\_del\_\_
```
# gc确定不了回收a,b的顺序,先回收b,a中__del__可能引用b
gc.set_debug(gc.DEBUG_STATS)
class A(object):
 def __del__(self):
 pass
class B(object):
 def __del__(self):
 pass
a = A()
b= B()
a.b = b
b.a = a
del a
del b
gc: collecting generation 2...
gc: objects in each generation: 522 3398 0
gc: done, 4 unreachable, 4 uncollectable, 0.0010s elapsed.
```
---
###\_\_del\_\_操作最好是无害的
```
# socket.py
class _fileobject(object):
 """Faux file object attached to a socket object."""
 def close(self):
 try:
 if self._sock:
 self.flush()
 finally:
 if self._close:
 self._sock.close()
 self._sock = None
 def __del__(self):
 try:
 self.close()
 except:
 # close() may fail if __init__ didn't complete
 pass
```
---
###多线程与多进程
- 并发模型:
 多线程
 异步IO ->以回调为主(tornado, nodejs)
 协程 ->gevent, golang
- GIL
 每执行100(sys.getcheckinterval())条指令,将切换线程
- 策略
 ctypes调用c库
 使用多进程
---
#操作系统
- top
 ![](img/top.png)
- 查看哪个进程占了6666端口
 ![](img/netstat.png)
- grep, sort, uniq
 grep -l, grep -h, sort -r, uniq -u, uniq -d
---
class: middle
 dau
 grep -h 2015年12月28日 * | grep BI_login | awk -F'|' '{print 3ドル}' | sort | uniq | wc -l
 付费
 grep -h payment * | awk -F'|' '{print 10ドル}' | awk '{r=index(0,ドル"}"); sum+=substr(0,8,ドルr-8)} END {print sum}'
---
- 网络
 tcp与udp的区别
 time wait与close wait
```
tcp:面向连接,粘包问题
udp:无连接, 没有粘包问题
```
没有server bind 9999端口的进程,send一样返回
```
In [2]: from socket import *
In [3]: s=socket(AF_INET,SOCK_DGRAM)
In [4]: s.connect(("localhost",9999))
In [5]: s.send("1111")
Out[5]: 4
```
---
### epoll与select, poll比较
- 区别
- 水平触发与边缘触发
 边缘触发防止饥饿问题
- 举例
 水平触发: tornado, skynet
 边缘触发: nginx, golang
---
#数据库
- mysql字符集和排序规则
 utf8 utfu_general_ci
- varchar与char的区别?
 char最大255个字符,varchar最大65535字节(略小)
- myisam与innodb区别?
 事务支持,锁级别, innodb两阶段锁定协议
- 索引
 原理,前缀索引, unique key, primary key
 unique key与primary key区别
---
class:middle
###B+数
![](img/b.jpg)
---
###Innodb 主键
- 为什么使用innodb主键大多数是自增的整形???
 Innodb 是聚簇索引
```
CREATE TABLE all_role (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `openid` varchar(100) NOT NULL,
 `clientid` int(11) NOT NULL,
 `roleid` varchar(64) NOT NULL,
 PRIMARY KEY (`id`),
 UNIQUE KEY `openid_clientid` (`openid`, `clientid`),
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8
select * from all_role where openid="xxxx" and
 clientid="xxxx";
第一步: 通过索引openid_clientid获取主键id
第二部: 通过主键id获取其它字段
```
---
class:middle
- 为什么django_session不是这样?
```
CREATE TABLE `django_session` (
`session_key` varchar(40) NOT NULL,
`session_data` longtext NOT NULL,
`expire_date` datetime NOT NULL,
PRIMARY KEY (`session_key`),
KEY `django_session_c25c2c28` (`expire_date`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```
---
#领域
---
##高性能网络库Gevent
 ![](img/net.png)
http://nichol.as/benchmark-of-python-web-servers
https://github.com/gevent/gevent/wiki/Projects(goagent,openstack)
---
##起源
- 多进程/多线程 以linux fork为代表,如早期的apache
- select/poll 多路复用
- epoll/kqueue/iocp 以异步回调为主, 以nodejs为代表
- 协程 以lua coroutine/golang goroutine为代表
---
##简单Tcp Server
```
# On Unix: Access with ``$ nc 127.0.0.1 5000``
# On Window: Access with ``$ telnet 127.0.0.1 5000``
from gevent.server import StreamServer
def handle(socket, address):
 socket.send("Hello from a telnet!\n")
 for i in range(5):
 socket.send(str(i) + '\n')
 socket.close()
server = StreamServer(('127.0.0.1', 5000), handle)
server.serve_forever()
```
---
##原理 coroutine
 ![](img/coroutine.jpeg)
---
##背后的力量
- libev C写的高性能网络库(对比memcache使用libevent)
- greenlet Python协程实现(对比lua coroutine/golang goroutine)
- c-ares 异步DNS请求
- cython
##现实世界应用
- 借助gevent让flask(django)拥有实时推送能力(对比tornado)
(http://xlambda.com/gevent-tutorial/#server_2)
- 游戏后端框架(https://github.com/9miao/Firefly)
- 爬虫
。。。
---
定时任务
```
def f():
 print time.time()
 print 'eeeee'
from gevent.core import loop
l = loop()
timer = l.timer(2,3) #2秒后启动,3秒后再次启动
print time.time()
timer.start(f)
l.run()
```
---
##借助greenlet自己写一个gevent
```
def accept(self):
 while True:
 try:
 print("accept")
 client_sock, address = self.sock.accept()
 break
 except socket.error as e:
 print(e)
 if e.args[0] != errno.EAGAIN:
 raise
 # switch是回调函数,当loop回调时会再次回到这里
 switch = rawgreenlet.getcurrent().switch
 # 注册读事件,当sock可读时调用回调函数
 ioloop.wait(self.sock, switch, ioloop.READ)
```
参考:
https://github.com/Skycrab/code/blob/master/Python/mygevent.py
---
class: center, middle, inverse
# 谢谢大家