目錄

一、關(guān)于 Session1. Session是緩存嗎？2. Session作用：3. Session生命周期：4. Session什么時候創(chuàng)建，提交，關(guān)閉？4. 獲取一個session：5. 關(guān)于SQLAlchemy 的 create_engine：6. 關(guān)于線程安全：二、單線程下 scoped_session 對創(chuàng)建 Session 的影響1. 兩個 Session 添加同一個對象1.1 在 commit 之前添加：1.2 在 commit 之后添加：1.3 再 close 之后添加：2. 不同的 Session 添加不同的對象3. 用 scoped_session 創(chuàng)建 Session三、多線程下 scoped_session 對創(chuàng)建 Session 的影響1. 當(dāng)不用 scoped_session 時：1.1 多線程下不設(shè)置 Session 為全局變量1.2 在多線程下用全局 Session2. 當(dāng)使用 scoped_session 時：2.1 多線程下不設(shè)置 Session 為全局變量2.2 多線程下設(shè)置 Session 為全局變量

一、關(guān)于 Session

Session 其實 就是一個會話, 可以和數(shù)據(jù)庫打交道的一個會話

在一般的意義上， 會話建立與數(shù)據(jù)庫的所有對話，并為你在其生命周期中加載或關(guān)聯(lián)的所有對象表示一個“等待區(qū)”。他提供了一個入口點獲得查詢對象， 向數(shù)據(jù)庫發(fā)送查詢，使用會話對象的當(dāng)前數(shù)據(jù)庫連接， 將結(jié)果行填充在對象中， 然后存儲在會話中， 在這種結(jié)構(gòu)中稱為身份映射 – 這種數(shù)據(jù)結(jié)構(gòu)維護(hù)了每一個副本的唯一， 這種唯一意味著一個對象只能有一個特殊的唯一主鍵。

會話以基本無狀態(tài)的形式開始，一旦發(fā)出查詢或其他對象被持久化，它就會從一個引擎申請連接資源，該引擎要么與會話本身相關(guān)聯(lián)，要么與正在操作的映射對象相關(guān)聯(lián)。此連接標(biāo)識正在進(jìn)行的事務(wù)， 在會話提交或回滾其掛起狀態(tài)之前，該事務(wù)一直有效。

會話中維護(hù)的所有變化的對象都會被跟蹤 – 在再次查詢數(shù)據(jù)庫或提交當(dāng)前事務(wù)之前， 它將刷新對數(shù)據(jù)庫的所有更改， 這被稱為工作模式單元。

在使用會話時候，最重要的是要注意與它相關(guān)聯(lián)的對象是會話所持有的事務(wù)的代理對象 – 為了保持同步，有各種各樣的事件會導(dǎo)致對象重新訪問數(shù)據(jù)庫。可能從會話中分離對象并繼續(xù)使用他們，盡管這種做法有其局限性。但是通常來說，當(dāng)你希望再次使用分離的對象時候，你會將他們與另一個會話重新關(guān)聯(lián)起來， 以便他們能夠恢復(fù)表示數(shù)據(jù)庫狀態(tài)的正常任務(wù)。

1. Session是緩存嗎？

可能會將這里的session與http中的session搞混，需要注意的是，它有點用作緩存，因為它實現(xiàn)了 身份映射 模式，并存儲了鍵入其主鍵的對象。但是，它不執(zhí)行任何類型的查詢緩存。 此外，默認(rèn)情況下，Session使用弱引用存儲對象實例。這也違背了將Session用作緩存的目的。關(guān)于session強應(yīng)用下次再討論。

2. Session作用：

1. session創(chuàng)建和管理數(shù)據(jù)庫連接的會話 2. model object 通過session對象訪問數(shù)據(jù)庫，并把訪問到的數(shù)據(jù)以 Identity Map的方式，映射到Model object中

3. Session生命周期：

1. session在剛被創(chuàng)建的時候，還沒有和任何model object 綁定，可認(rèn)為是無狀態(tài)的 2. session 接受到query查詢語句, 執(zhí)行的結(jié)果或保持或者關(guān)聯(lián)到session中 3. 任意數(shù)量的model object被創(chuàng)建，并綁定到session中，session會管理這些對象 4. 一旦session 里面的objects 有變化，那可是要commit/rollback提交或者放棄changs

4. Session什么時候創(chuàng)建，提交，關(guān)閉？

一般來說，session在需要訪問數(shù)據(jù)庫的時候創(chuàng)建，在session訪問數(shù)據(jù)庫的時候，準(zhǔn)確來說，應(yīng)該是“add/update/delete”數(shù)據(jù)庫的時候，會開啟database transaction。 假設(shè)沒有修改autocommit的默認(rèn)值(False), 那么，database transaction 一直會保持，只有等到session發(fā)生rolled back、committed、或者closed的時候才結(jié)束，一般建議，當(dāng)database transaction結(jié)束的時候，同時close session,以保證，每次發(fā)起請求，都會創(chuàng)建一個新的session 特別是對web應(yīng)用來說，發(fā)起一個請求，若請求使用到Session訪問數(shù)據(jù)庫，則創(chuàng)建session，處理完這個請求后，關(guān)閉session

4. 獲取一個Session：

Session 是一個直接實例化的常規(guī)的Python 類。然而， 為了標(biāo)準(zhǔn)會會話的配置和獲取方式， sessionmaker 類通常用于創(chuàng)建頂級會話配置， 然后可以在整個應(yīng)用程序中使用它， 就不需要重復(fù)配置參數(shù)。

下面是sessionmaker 的使用方式

from sqlalchemy import create_enginefrom sqlalchemy.orm import sessionmaker# 創(chuàng)建連接數(shù)據(jù)庫的引擎，session連接數(shù)據(jù)庫需要my_engine = create_engine('mysql+pymysql://root:[email protected]/my_db')# 創(chuàng)建一個配置過的Session類Session = sessionmaker(bind=my_engine)# 實例化一個sessiondb_session = Session()# 使用sessionmyobject = MyObject('foo', 'bar')db_session.add(myobject)db_session.commit()

在上面，該sessionmaker()創(chuàng)建了一個工廠類，在創(chuàng)建這個工廠類時我們配置了參數(shù)綁定了引擎。將其賦值給Session。每次實例化Session都會創(chuàng)建一個綁定了引擎的Session。這樣這個session在訪問數(shù)據(jù)庫時都會通過這個綁定好的引擎來獲取連接資源當(dāng)你編寫應(yīng)用程序時， 請將sessionmaker 工廠放在全局級別，視作應(yīng)用程序配置的一部分。例如：應(yīng)用程序包中有三個.py文件，您可以將該sessionmaker行放在__init__.py文件中; 在其他模塊“from mypackage import Session”。這樣，所有的Session()的配置都由該配置中心控制。

5. 關(guān)于SQLAlchemy 的 create_engine：

直接只用 create_engine 時，就會創(chuàng)建一個帶連接池的引擎：

my_engine = create_engine('mysql+pymysql://root:[email protected]/my_db')

創(chuàng)建一個session，連接池會分配一個connection。當(dāng)session在使用后顯示地調(diào)用 session.close()，也不能把這個連接關(guān)閉，而是由由QueuePool連接池管理并復(fù)用連接。

確保 session 在使用完成后用 session.close、session.commit 或 session.rollback 把連接還回 pool，這是一個必須在意的習(xí)慣。

關(guān)于SQLAlchemy 數(shù)據(jù)庫連接池：

session 和 connection 不是相同的東西， session 使用連接來操作數(shù)據(jù)庫，一旦任務(wù)完成 session 會將數(shù)據(jù)庫 connection 交還給 pool。 在使用 create_engine 創(chuàng)建引擎時，如果默認(rèn)不指定連接池設(shè)置的話，一般情況下，SQLAlchemy 會使用一個 QueuePool 綁定在新創(chuàng)建的引擎上。并附上合適的連接池參數(shù)

create_engine() 函數(shù)和連接池相關(guān)的參數(shù)有：

pool_recycle, 默認(rèn)為 -1, 推薦設(shè)置為 7200, 即如果 connection 空閑了 7200 秒，自動重新獲取，以防止 connection 被 db server 關(guān)閉。pool_size=5, 連接數(shù)大小，默認(rèn)為 5，正式環(huán)境該數(shù)值太小，需根據(jù)實際情況調(diào)大max_overflow=10, 超出 pool_size 后可允許的最大連接數(shù)，默認(rèn)為 10, 這 10 個連接在使用過后，不放在 pool 中，而是被真正關(guān)閉的。pool_timeout=30, 獲取連接的超時閾值，默認(rèn)為 30 秒

SQLAlchemy不使用連接池：在創(chuàng)建引擎時指定參數(shù) poolclass=NullPool 即禁用了SQLAlchemy提供的數(shù)據(jù)庫連接池。SQLAlchemy 就會在執(zhí)行 session.close() 后立刻斷開數(shù)據(jù)庫連接。當(dāng)然，如果沒有被調(diào)用 session.close()，則數(shù)據(jù)庫連接不會被斷開，直到程序終止。

my_engine = create_engine('mysql+pymysql://root:[email protected]/my_db'，poolclass=NullPool)

關(guān)于 SQLAlchemy 的 engine ,這里有一篇文章寫的很好：http://sunnyingit.github.io/book/section_python/SQLalchemy-engine.html

6. 關(guān)于線程安全：

session不是線程安全的，在多線程的環(huán)境中，默認(rèn)情況下，多個線程將會共享同一個session。試想一下，假設(shè)A線程正在使用session處理數(shù)據(jù)庫，B線程已經(jīng)執(zhí)行完成，把session給close了，那么此時A在使用session就會報錯，怎么避免這個問題？

1. 可以考慮在這些線程之間共享Session及其對象。但是應(yīng)用程序需要確保實現(xiàn)正確的鎖定方案，以便多個線程不會同時訪問Session或其狀態(tài)。SQLAlchemy 中的 scoped_session 就可以證線程安全，下面會有討論。2. 為每個并發(fā)線程維護(hù)一個會話，而不是將對象從一個Session復(fù)制到另一個Session，通常使用Session.merge()方法將對象的狀態(tài)復(fù)制到一個不同Session的新的本地對象中。

二、單線程下 scoped_session 對創(chuàng)建 Session 的影響

上面簡單介紹了sessionmaker的作用，下面開始探討 scoped_session 對創(chuàng)建 Session 的影響?，F(xiàn)在先探討單線程情況。

先聲明待會實驗用的模型：

from sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, Stringfrom sqlalchemy import create_engineBase = declarative_baseengine = create_engine("mysql+pymysql://root:[email protected]:3306/my_db?charset=utf8mb4")class Person(Base): __tablename__ = 'Person' id = Column(Integer, primary_key=True, autoincrement=True) name = Column(String(length=64), comment='姓名') mobile = Column(String(length=13), comment='手機號') id_card_number = Column(String(length=64), comment='身份證') def __str__(self): return '%s(name=%r,mobile=%r,id_card_number=%r)' % ( self.__class__.__name__, self.name, self.mobile, self.id_card_number )# 在數(shù)據(jù)庫中創(chuàng)建模型對象的表Base.metadata.create_all(engine)

1. 兩個 Session 添加同一個對象

1.1 在 commit 之前添加：

from sqlalchemy.orm import sessionmaker, scoped_sessionsession_factory = sessionmaker(bind=engine)# engine 在上面已經(jīng)創(chuàng)建好了person = Person(name='frank-' + 'job3', mobile='111111', id_card_number='123456789')Session= session_factory()s1= session_factory()# s1 : <sqlalchemy.orm.session.Session object at 0x107ec8c18>s2 = session_factory() # s2 : <sqlalchemy.orm.session.Session object at 0x107ee3ac8>print(s1 is s2)# Falseid(s1),id(s2)# 4427910168, 4428020424s1.add(person)s2.add(person)# 會報錯！# sqlalchemy.exc.InvalidRequestError: Object '<Person at 0x22beb14bf60>' is already attached to session '2' (this is '3')

結(jié)論：

通過 sessionmaker 工廠創(chuàng)建了兩個 Session ，而且可以看到 s1 s2 是兩個不同的 Session 。 在 s1 添加 person 后，繼續(xù)使用 s2 添加 person 報錯. 說 person 這個對象 已經(jīng)和 另一個 Session 關(guān)聯(lián)一起來了, 所以再次關(guān)聯(lián)另一個 Session 就會報錯。

1.2 在 commit 之后添加：

即在上面代碼的 s1.add(person) 之后， s1.commit() ,然后再 s2.add(persion)這里就沒帖代碼了。

結(jié)論：

即使在 s1 提交之后，s2 再去添加 person 也會發(fā)生錯誤,但 s1 的提交是成功了的，數(shù)據(jù) person 已經(jīng)存放在數(shù)據(jù)庫了。 當(dāng) s1 添加 person 并提交，然后關(guān)閉 s1 ,s2再去添加并提交 person 數(shù)據(jù)庫,這不會報錯，但是數(shù)據(jù)庫也不會出現(xiàn)兩條 person 數(shù)據(jù)。

1.3 再 close 之后添加：

p = Person(name='frank', mobile='11111111', id_card_number='123456789')s1.add(p)s1.commit()s2.add(p)s2.commit()# 也會報錯?。。? sqlalchemy.exc.InvalidRequestError: Object '<Person at 0x21207e3e128>' is already attached to session '2' (this is '3')p = Person(name='frankcc', mobile='1111111122', id_card_number='1234567890')s1.add(p)s1.commit()s1.close()s2.add(p)s2.commit()# 不會報錯

結(jié)論：

s1 關(guān)閉之后， s2再去添加提交同一個對象，不會報錯，但是數(shù)據(jù)庫值有一條 person 數(shù)據(jù)。

2. 不同的 Session 添加不同的對象

person4 = Person(name='frank-' + 'job4', mobile='4444444444', id_card_number='123456789')person1 = Person(name='frank-' + 'job1', mobile='111111', id_card_number='123456789')s1.add(person1)s2.add(person4)s1.commit() # 提交數(shù)據(jù)s2.commit() # 提交數(shù)據(jù), 寫入數(shù)據(jù)庫

結(jié)論：

當(dāng)然，s1 ,s2 添加提交不同的對象，不會出錯。在數(shù)據(jù)庫成功新增數(shù)據(jù)。

mysql> select * from person;+----+------------+------------+----------------+| id | name | mobile | id_card_number |+----+------------+------------+----------------+| 1 | frank-job1 | 111111 | 123456789 || 2 | frank-job4 | 4444444444 | 123456789 |+----+------------+------------+----------------+2 rows in set (0.00 sec)

以上說明：

一個對象一旦被一個 Session 添加，除非關(guān)閉這個 Session ，不然其他的 Session 無法添加這個對象。 一個 Session 添加并提交一個對象，然后關(guān)閉該 Session ，其他的 Session 可以添加并提交這個對象，但是數(shù)據(jù)庫并不會有這條數(shù)據(jù)。

3. 用 scoped_session 創(chuàng)建 Session

session_factory = sessionmaker(bind=engine)Session = scoped_session(session_factory)s1 = Session()# <sqlalchemy.orm.session.Session object at 0x0000020E58690240>s2 = Session()# <sqlalchemy.orm.session.Session object at 0x0000020E58690240>print(s1 is s2)# Truep = Person(name='frankaaabb', mobile='1111111122233', id_card_number='12345678900099')s1.add(p)s2.add(p)s2.commit()

結(jié)論：

可以看到，通過scoped_session再去創(chuàng)建 Session ，返回的是同一個 Session 。 scoped_session類似單例模式，當(dāng)我們調(diào)用使用的時候，會先在Registry里找找之前是否已經(jīng)創(chuàng)建Session，未創(chuàng)建則創(chuàng)建 Session ，已創(chuàng)建則直接返回。

三、多線程下 scoped_session 對創(chuàng)建 Session 的影響

這里探討在多線程下使用 scoped_session 與不使用 scoped_session 的情況

1. 當(dāng)不用 scoped_session 時：

當(dāng)不使用 scoped_session 時，也分兩種情況，是否創(chuàng)建全局性 Session

1.1 多線程下不設(shè)置 Session 為全局變量

session_factory = sessionmaker(bind=engine)Session = session_factorydef job(name): session = Session() print(f"id session:{id(session)}") person = Person(name='frank-' + name, mobile='111111', id_card_number='123456789') print(f"{name} person is add..") session.add(person) time.sleep(1) if name == 'job3': # 線程3 提交, 其他線程不提交. session.commit() session.close()if __name__ == '__main__': thread_list = [] # 創(chuàng)建5個線程 for i in range(5): name = 'job' + str(i) t = threading.Thread(target=job, name=name, args=(name,)) thread_list.append(t) for t in thread_list: t.start() for t in thread_list: t.join()

結(jié)論：

每個線程下的 Session 都是不同的 Session 數(shù)據(jù)庫成功新增了線程3提交的數(shù)據(jù)，其他的線程中的數(shù)據(jù)并沒有提交到數(shù)據(jù)庫中去。

id session:2557871997392job0 person is add..id session:2557871998064job1 person is add..id session:2557871998568job2 person is add..id session:2557871999072job3 person is add..id session:2557871999688job4 person is add..mysql> select * from person;+----+------------+--------+----------------+| id | name | mobile | id_card_number |+----+------------+--------+----------------+| 14 | frank-job3 | 111111 | 123456789 |+----+------------+--------+----------------+1 row in set (0.00 sec)

1.2 在多線程下用全局 Session

session_factory = sessionmaker(bind=engine)Session = session_factorysession = Session()def job(name): global session print(f"id session:{id(session)}") person = Person(name='frank-' + name, mobile='111111', id_card_number='123456789') print(f"{name} person is add..") session.add(person) time.sleep(1) if name == 'job3': # 線程3 提交, 其他線程不提交. session.commit() session.close()if __name__ == '__main__': thread_list = [] # 創(chuàng)建5個線程 for i in range(5): name = 'job' + str(i) t = threading.Thread(target=job, name=name, args=(name,)) thread_list.append(t) for t in thread_list: t.start() for t in thread_list: t.join()

結(jié)論：

全部線程下的 Session 都時同一個 Session 每個線程下的數(shù)據(jù)都被提交到了數(shù)據(jù)庫

id session:2737857674824job0 person is add..id session:2737857674824job1 person is add..id session:2737857674824job2 person is add..id session:2737857674824job3 person is add..id session:2737857674824job4 person is add..mysql> select * from person;+----+------------+--------+----------------+| id | name | mobile | id_card_number |+----+------------+--------+----------------+| 15 | frank-job0 | 111111 | 123456789 || 16 | frank-job2 | 111111 | 123456789 || 17 | frank-job1 | 111111 | 123456789 || 18 | frank-job3 | 111111 | 123456789 || 19 | frank-job4 | 111111 | 123456789 |+----+------------+--------+----------------+5 rows in set (0.00 sec)

2. 當(dāng)使用 scoped_session 時：

2.1 多線程下不設(shè)置 Session 為全局變量

session_factory = sessionmaker(bind=engine)Session = scoped_session(session_factory)def job(name): session = Session() print(f"id session:{id(session)}") person = Person(name='frank-' + name, mobile='111111', id_card_number='123456789') print(f"{name} person is add..") session.add(person) time.sleep(1) if name == 'job3': # 線程3 提交, 其他線程不提交. session.commit() session.close()if __name__ == '__main__': thread_list = [] # 創(chuàng)建5個線程 for i in range(5): name = 'job' + str(i) t = threading.Thread(target=job, name=name, args=(name,)) thread_list.append(t) for t in thread_list: t.start() for t in thread_list: t.join()

結(jié)論：

每個線程下的 Session 都不相同 只有線程3下的數(shù)據(jù)被提交到了數(shù)據(jù)庫

id session:2173841850832job0 person is add..id session:2173841851504job1 person is add..id session:2173841851896job2 person is add..id session:2173841852008job3 person is add..id session:2173841853128job4 person is add..mysql> select * from person;+----+------------+--------+----------------+| id | name | mobile | id_card_number |+----+------------+--------+----------------+| 32 | frank-job3 | 111111 | 123456789 |+----+------------+--------+----------------+1 row in set (0.00 sec)

2.2 多線程下設(shè)置 Session 為全局變量

session_factory = sessionmaker(bind=engine)Session = scoped_session(session_factory)session = Session()def job(name): global session print(f"id session:{id(session)}") person = Person(name='frank-' + name, mobile='111111', id_card_number='123456789') print(f"{name} person is add..") session.add(person) time.sleep(1) if name == 'job3': # 線程3 提交, 其他線程不提交. session.commit() session.close()if __name__ == '__main__': thread_list = [] # 創(chuàng)建5個線程 for i in range(5): name = 'job' + str(i) t = threading.Thread(target=job, name=name, args=(name,)) thread_list.append(t) for t in thread_list: t.start() for t in thread_list: t.join()

結(jié)論：

每個線程下的 Session 是同一個 Session 每個線程下的數(shù)據(jù)都沒提交到了數(shù)據(jù)庫

id session:2810724382032job0 person is add..id session:2810724382032job1 person is add..id session:2810724382032job2 person is add..id session:2810724382032job3 person is add..id session:2810724382032job4 person is add..mysql> select * from person;+----+------------+--------+----------------+| id | name | mobile | id_card_number |+----+------------+--------+----------------+| 33 | frank-job0 | 111111 | 123456789 || 34 | frank-job2 | 111111 | 123456789 || 35 | frank-job1 | 111111 | 123456789 || 36 | frank-job3 | 111111 | 123456789 || 37 | frank-job4 | 111111 | 123456789 |+----+------------+--------+----------------+5 rows in set (0.00 sec)

以上說明：

在同一個線程中，有 scoped_session 的時候，返回的是同一個 Session 對象。 在多線程下，即使通過 scoped_session 創(chuàng)建Session，每個線程下的 Session 都是不一樣的，每個線程都有一個屬于自己的 Session 對象，這個對象只在本線程下共享。 scoped_session 只有在單線程下才能發(fā)揮其作用。在多線程下顯得沒有什么作用。