Can Django run in a threaded model? - django

Question

I was looking through the code base, particularly the database connectivity parts, and came accross this issue.
First, one gets a cursor to the database using the following stamentent:
from django.db import connection, transaction
cursor = connection.cursor()
connection is a module attribute, so in a threaded model, all threads would share that variable. Sounds a bit strange. Diving in further, the cursor() method belongs to django.db.backends.BaseDatabaseWrapper and looks like this:
def cursor(self):
self.validate_thread_sharing()
if (self.use_debug_cursor or
(self.use_debug_cursor is None and settings.DEBUG)):
cursor = self.make_debug_cursor(self._cursor())
else:
cursor = util.CursorWrapper(self._cursor(), self)
return cursor
The key is the call to _cursor(), which executes the backend code for whatever database is being used. In the case of MySQL, it executes the _cursor() method on django.db.backends.mysql.DatabaseWrapper, which looks like:
def _cursor(self):
new_connection = False
if not self._valid_connection():
new_connection = True
kwargs = {
'conv': django_conversions,
'charset': 'utf8',
'use_unicode': True,
}
settings_dict = self.settings_dict
if settings_dict['USER']:
kwargs['user'] = settings_dict['USER']
if settings_dict['NAME']:
kwargs['db'] = settings_dict['NAME']
if settings_dict['PASSWORD']:
kwargs['passwd'] = settings_dict['PASSWORD']
if settings_dict['HOST'].startswith('/'):
kwargs['unix_socket'] = settings_dict['HOST']
elif settings_dict['HOST']:
kwargs['host'] = settings_dict['HOST']
if settings_dict['PORT']:
kwargs['port'] = int(settings_dict['PORT'])
# We need the number of potentially affected rows after an
# "UPDATE", not the number of changed rows.
kwargs['client_flag'] = CLIENT.FOUND_ROWS
kwargs.update(settings_dict['OPTIONS'])
self.connection = Database.connect(**kwargs)
self.connection.encoders[SafeUnicode] = self.connection.encoders[unicode]
self.connection.encoders[SafeString] = self.connection.encoders[str]
connection_created.send(sender=self.__class__, connection=self)
cursor = self.connection.cursor()
if new_connection:
# SQL_AUTO_IS_NULL in MySQL controls whether an AUTO_INCREMENT column
# on a recently-inserted row will return when the field is tested for
# NULL. Disabling this value brings this aspect of MySQL in line with
# SQL standards.
cursor.execute('SET SQL_AUTO_IS_NULL = 0')
return CursorWrapper(cursor)
So a new cursor is not necessarily created. If a call to _cursor() had already been made, the previously used cursor would have been returned.
In a threaded model, that means multiple threads are possibly sharing the same database cursor, which seems like a no-no.
There are also other signs that indicate that threading is not allowed in Django. This module-level code from django/db/init.py, from for example:
def close_connection(**kwargs):
for conn in connections.all():
conn.close()
signals.request_finished.connect(close_connection)
So if any request finished, all database connections are closed. What if there are concurrent requests?
Seems like a lot of stuff is being shared, which indicates that threading is not allowed. I didn't see synchronization code anywhere.
Thanks!