update sqlalchemy in conccurent threads and tasks

Author: copdips

docs/posts/2019/2019-05-14-using-python-sqlalchemy-session-in-multithreading.md

@@ -4,89 +4,47 @@ authors:
 categories:
 - python
 - multithreading
+- asyncio
 - sqlalchemy
 comments: true
 date:
   created: 2019-05-14
-description: Using Python SQLAlchemy session in multithreading by using contextmanager
-  or scope_session.
+  updated: 2025-05-14
+description: Using Python SQLAlchemy session in multithreading and asyncio by using context manager
+  or scoped_session.
 ---
 
-# Using Python SQLAlchemy session in multithreading
+# Using Python SQLAlchemy session in concurrent threads or tasks
 
-SQLAlchemy DB session is [not thread safe](https://docs.sqlalchemy.org/en/13/orm/session_basics.html#is-the-session-thread-safe). In this post, I will show you 2 ways to use it in a multithreading context.
+SQLAlchemy DB session is [not thread safe](https://docs.sqlalchemy.org/en/20/orm/session_basics.html#is-the-session-thread-safe-is-asyncsession-safe-to-share-in-concurrent-tasks) for both sync or async session. [AsyncSession](https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html#sqlalchemy.ext.asyncio.AsyncSession) is only a thin proxy on top of a [Session](https://docs.sqlalchemy.org/en/20/orm/session_api.html#sqlalchemy.orm.Session)
 
-<!-- more -->
-
-## Way 1 - Using contextmanager to create a session per thread
-
-Below is an example given by the official doc to show how to use the [contextmanager](https://docs.sqlalchemy.org/en/13/orm/session_basics.html#when-do-i-construct-a-session-when-do-i-commit-it-and-when-do-i-close-it) to construct, commit and close a SQLAlchemy session.
-
-```python
-### another way (but again *not the only way*) to do it ###
-
-from contextlib import contextmanager
+> The concurrency model for SQLAlchemy's `Session` and `AsyncSession` is therefore Session per thread, AsyncSession per task.
+> The best way to ensure this use is by using the [standard context manager pattern](https://docs.sqlalchemy.org/en/20/orm/session_basics.html#session-getting) locally within the top level Python function that is inside the thread or task, which will ensure the lifespan of the `Session` or `AsyncSession` is maintained within a local scope.
+> For applications that benefit from having a "global" `Session` where it's not an option to pass the [Session](https://docs.sqlalchemy.org/en/20/orm/session_api.html#sqlalchemy.orm.Session) object to specific functions and methods which require it, the [scoped_session](https://docs.sqlalchemy.org/en/20/orm/contextual.html#sqlalchemy.orm.scoped_session) approach can provide for a "thread local" Session object; see the section [Contextual/Thread-local Sessions](https://docs.sqlalchemy.org/en/20/orm/contextual.html#unitofwork-contextual) for background. Within the asyncio context, the [async_scoped_session](https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html#sqlalchemy.ext.asyncio.async_scoped_session) object is the asyncio analogue for [scoped_session](https://docs.sqlalchemy.org/en/20/orm/contextual.html#sqlalchemy.orm.scoped_session), however is more challenging to configure as it requires a custom "context" function.
 
+<!-- more -->
 
-@contextmanager
-def session_scope():
-    """Provide a transactional scope around a series of operations."""
-    session = Session()
-    try:
-        yield session
-        session.commit()
-    except:
-        session.rollback()
-        raise
-    finally:
-        session.close()
-
-
-def run_my_program():
-    with session_scope() as session:
-        ThingOne().go(session)
-        ThingTwo().go(session)
-```
-
-Suppose we have a function called `f1` which does something with the session. And we need to call `f1` in a multithreading context.
-All we need to do is to add the `session_scope()` around the `f1`:
+## Way 1 - Using context manager to create a session per thread or task
 
 ```python
-from contextlib import contextmanager
 from multiprocessing.dummy import Pool as ThreadPool
 
-# db_utils is a python file that creats the Session by using the factory sessionmaker(),
-# not shown here.
-from db_utils import Session
-
-
-@contextmanager
-def session_scope():
-    """Provide a transactional scope around a series of operations."""
-    session = Session()
-    try:
-        yield session
-        session.commit()
-    except:
-        session.rollback()
-        raise
-    finally:
-        session.close()
-
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
 
-def f1(session, number):
-    # do something around the session and the number...
+engine = create_engine("postgresql+psycopg2://scott:tiger@localhost/")
+SessionFactory = sessionmaker(engine)
 
 
-def thread_worker(number):
-    # We're using the session context here.
-    with session_scope() as session:
-        f1(session, number)
+def thread_worker(session_factory, number):
+    with session_factory() as session:
+        # do something around the session and the number...
+        session.commit()
 
 
-def work_parallel(numbers, thread_number=4):
+def work_parallel(engine, numbers, thread_number=4):
     pool = ThreadPool(thread_number)
-    results = pool.map(thread_worker, numbers)
+    results = pool.map(thread_worker, SessionFactory, numbers)
     # If you don't care about the results, just comment the following 3 lines.
     # pool.close()
     # pool.join()
@@ -150,4 +108,4 @@ if __name__ == "__main__":
 
 ## Bonus - How the Python web frameworks work with SQLAlchemy thread local scope
 
-[https://docs.sqlalchemy.org/en/13/orm/contextual.html#using-thread-local-scope-with-web-applications](https://docs.sqlalchemy.org/en/13/orm/contextual.html#using-thread-local-scope-with-web-applications)
+https://docs.sqlalchemy.org/en/20/orm/contextual.html#using-thread-local-scope-with-web-applications