Database Access

The Django ORM is a synchronous piece of code, and so if you want to access it from asynchronous code you need to do special handling to make sure its connections are closed properly.

If you’re using SyncConsumer, or anything based on it - like JsonWebsocketConsumer - you don’t need to do anything special, as all your code is already run in a synchronous mode and Channels will do the cleanup for you as part of the SyncConsumer code.

If you are writing asynchronous code, however, you will need to call database methods in a safe, synchronous context, using database_sync_to_async or by using the asynchronous methods prefixed with a like Model.objects.aget().

Database Connections

Channels can potentially open a lot more database connections than you may be used to if you are using threaded consumers (synchronous ones) - it can open up to one connection per thread.

If you wish to control the maximum number of threads used, set the ASGI_THREADS environment variable to the maximum number you wish to allow. By default, the number of threads is set to “the number of CPUs * 5” for Python 3.7 and below, and min(32, os.cpu_count() + 4) for Python 3.8+.

To avoid having too many threads idling in connections, you can instead rewrite your code to use async consumers and only dip into threads when you need to use Django’s ORM (using database_sync_to_async).

When using async consumers Channels will automatically call Django’s close_old_connections method when a new connection is started, when a connection is closed, and whenever anything is received from the client. This mirrors Django’s logic for closing old connections at the start and end of a request, to the extent possible. Connections are not automatically closed when sending data from a consumer since Channels has no way to determine if this is a one-off send (and connections could be closed) or a series of sends (in which closing connections would kill performance). Instead, if you have a long-lived async consumer you should periodically call aclose_old_connections (see below).

database_sync_to_async

channels.db.database_sync_to_async is a version of asgiref.sync.sync_to_async that also cleans up database connections on exit.

To use it, write your ORM queries in a separate function or method, and then call it with database_sync_to_async like so:

from channels.db import database_sync_to_async

async def connect(self):
    self.username = await database_sync_to_async(get_name)()

def get_name(self):
    return User.objects.all()[0].name

You can also use it as a decorator:

from channels.db import database_sync_to_async

async def connect(self):
    self.username = await get_name()

@database_sync_to_async
def get_name(self):
    return User.objects.all()[0].name

aclose_old_connections

channels.db.aclose_old_connections is an async wrapper around Django’s close_old_connections. When using a long-lived AsyncConsumer that calls the Django ORM it is important to call this function periodically.

Preferrably, this function should be called before making the first query in a while. For example, it should be called if the Consumer is woken up by a channels layer event and needs to make a few ORM queries to determine what to send to the client. This function should be called before making those queries. Calling this function more than necessary is not necessarily a bad thing, but it does require a context switch to synchronous code and so incurs a small penalty.