通过CONN_MAX_AGE优化Django的数据库连接

上周对我们用Django+Django-rest-framework提供的一套接口进行了压力测试。压测的过程中，收到DBA通知——数据库连接数过多，希望我们优化下程序。具体症状就是，如果设置mysql的最大连接数为1000，压测过程中，很快连接数就会达到上限，调整上限到2000，依然如此。

Django的数据库连接

Django对数据库的链接处理是这样的，Django程序接受到请求之后，在第一访问数据库的时候会创建一个数据库连接,直到请求结束，关闭连接。下次请求也是如此。因此，这种情况下，随着访问的并发数越来越高，就会产生大量的数据库连接。也就是我们在压测时出现的情况。

关于Django每次接受到请求和处理完请求时对数据库连接的操作，最后会从源码上来看看。

使用CONN_MAX_AGE减少数据库请求

上面说了，每次请求都会创建新的数据库连接，这对于高访问量的应用来说完全是不可接受的。因此在Django1.6时，提供了持久的数据库连接，通过DATABASE配置上添加CONN_MAX_AGE来控制每个连接的最大存活时间。具体使用可以参考最后的链接。

这个参数的原理就是在每次创建完数据库连接之后，把连接放到一个Theard.local的实例中。在request请求开始结束的时候，打算关闭连接时会判断是否超过CONN_MAX_AGE设置这个有效期。这是关闭。每次进行数据库请求的时候其实只是判断local中有没有已存在的连接，有则复用。

基于上述原因，Django中对于CONN_MAX_AGE的使用是有些限制的，使用不当，会事得其反。因为保存的连接是基于线程局部变量的，因此如果你部署方式采用多线程，必须要注意保证你的最大线程数不会多余数据库能支持的最大连接数。另外，如果使用开发模式运行程序（直接runserver的方式），建议不要设置CONN_MAX_AGE，因为这种情况下，每次请求都会创建一个Thread。同时如果你设置了CONN_MAX_AGE，将会导致你创建大量的不可复用的持久的连接。

CONN_MAX_AGE设置多久

CONN_MAX_AGE的时间怎么设置主要取决于数据库对空闲连接的管理，比如你的MySQL设置了空闲1分钟就关闭连接，那你的CONN_MAX_AGE就不能大于一分钟，不过DBA已经习惯了程序中的线程池的概念，会在数据库中设置一个较大的值。

优化结果

了解了上述过程之后，配置了CONN_MAX_AGE参数，再次测试，终于没有接到DBA通知，查看数据库连接数，最大700多。

最好的文档是代码

Django的文档上只是简单得介绍了原理和使用方式，对于好奇的同学来说，这个显然是不够的。于是我也好奇的看了下代码，把相关的片段贴到这里。

首先是一次请求开始和结束时对连接的处理

1. #### 请求开始
2. # django.core.handlers.wsgi.py
3. class WSGIHandler(base.BaseHandler):
4. initLock = Lock()
5. request_class = WSGIRequest
7. def __call__(self, environ, start_response):
8. # ..... 省略若干代码
9. # 触发request_started这个Signal
10. signals.request_started.send(sender=self.__class__, environ=environ)
11. try:
12. request = self.request_class(environ)
13. except UnicodeDecodeError:
14. logger.warning('Bad Request (UnicodeDecodeError)',
15. exc_info=sys.exc_info(),
16. extra={
17. 'status_code': 400,
18. }
19. )
21. # 请求结束
23. class HttpResponseBase(six.Iterator):
24. """
25. An HTTP response base class with dictionary-accessed headers.
27. This class doesn't handle content. It should not be used directly.
28. Use the HttpResponse and StreamingHttpResponse subclasses instead.
29. """
31. def close(self):
32. for closable in self._closable_objects:
33. try:
34. closable.close()
35. except Exception:
36. pass
37. # 请求结束时触发request_finished这个触发器
38. signals.request_finished.send(sender=self._handler_class)

这里只是触发，那么在哪对这些signal进行处理呢？

1. # django.db.__init__.py
2. from django.db.utils import ConnectionHandler
3. connections = ConnectionHandler()
5. # Register an event to reset saved queries when a Django request is started.
6. def reset_queries(**kwargs):
7. for conn in connections.all():
8. conn.queries_log.clear()
9. signals.request_started.connect(reset_queries)
11. # Register an event to reset transaction state and close connections past
12. # their lifetime.
13. def close_old_connections(**kwargs):
14. for conn in connections.all():
15. conn.close_if_unusable_or_obsolete()
16. signals.request_started.connect(close_old_connections)
17. signals.request_finished.connect(close_old_connections)

在这里对触发的signal进行了处理，从代码上看，逻辑就是，遍历所有已存在的链接，关闭不可用的连接。

再来看ConnectionHandler代码:

1. class ConnectionHandler(object):
3. def __init__(self, databases=None):
4. """
5. databases is an optional dictionary of database definitions (structured
6. like settings.DATABASES).
7. """
8. # databases来自settings对数据库的配置
9. self._databases = databases
10. self._connections = local()
12. @cached_property
13. def databases(self):
14. if self._databases is None:
15. self._databases = settings.DATABASES
16. if self._databases == {}:
17. self._databases = {
18. DEFAULT_DB_ALIAS: {
19. 'ENGINE': 'django.db.backends.dummy',
20. },
21. }
22. if DEFAULT_DB_ALIAS not in self._databases:
23. raise ImproperlyConfigured("You must define a '%s' database" % DEFAULT_DB_ALIAS)
24. return self._databases
26. def __iter__(self):
27. return iter(self.databases)
29. def all(self):
30. # 调用__iter__和__getitem__
31. return [self[alias] for alias in self]
33. def __getitem__(self, alias):
34. if hasattr(self._connections, alias):
35. return getattr(self._connections, alias)
37. self.ensure_defaults(alias)
38. self.prepare_test_settings(alias)
39. db = self.databases[alias]
40. backend = load_backend(db['ENGINE'])
41. # 关键在这了，这个就是conn
42. conn = backend.DatabaseWrapper(db, alias)
43. # 放到 local里
44. setattr(self._connections, alias, conn)
45. return conn

这个代码的关键就是生成对于backend的conn，并且放到local中。backend.DatabaseWrapper继承了db.backends.init.BaseDatabaseWrapper类的 close_if_unusable_or_obsolete() 的方法，来直接看下这个方法。

1. class BaseDatabaseWrapper(object):
2. """
3. Represents a database connection.
4. """
6. def connect(self):
7. """Connects to the database. Assumes that the connection is closed."""
8. # 连接数据库时读取配置中的CONN_MAX_AGE
9. max_age = self.settings_dict['CONN_MAX_AGE']
10. self.close_at = None if max_age is None else time.time() + max_age
12. def close_if_unusable_or_obsolete(self):
13. """
14. Closes the current connection if unrecoverable errors have occurred,
15. or if it outlived its maximum age.
16. """
17. if self.connection is not None:
18. # If the application didn't restore the original autocommit setting,
19. # don't take chances, drop the connection.
20. if self.get_autocommit() != self.settings_dict['AUTOCOMMIT']:
21. self.close()
22. return
24. # If an exception other than DataError or IntegrityError occurred
25. # since the last commit / rollback, check if the connection works.
26. if self.errors_occurred:
27. if self.is_usable():
28. self.errors_occurred = False
29. else:
30. self.close()
31. return
33. if self.close_at is not None and time.time() >= self.close_at:
34. self.close()
35. return

参考

https://docs.djangoproject.com/en/1.6/ref/databases/#persistent-database-connections https://github.com/django/django/blob/master/django/core/handlers/wsgi.py#L164 https://github.com/django/django/blob/master/django/http/response.py#L310 https://github.com/django/django/blob/master/django/db/init.py#L62 https://github.com/django/django/blob/master/django/db/utils.py#L252 https://github.com/django/django/blob/master/django/db/backends/init.py#L383