Python数据库连接池DButils

　　DButils是python的一个实现数据库连接池的模块

　　两种模式：

　　1.为每一个线程创建一个链接，即使线程即使调用了close()方法，也不会关闭，只是把线程放到连接池，供自己再次使用，当连接关闭时，线程连接自动关闭。

 1 from DBUtils.PersistentDB import PersistentDB
 2 import pymysql
 3 PooL = PersistentDB(
 4     creator = pymysql,  #使用链接数据库的模块
 5     maxusage = None, #一个链接最多被使用的次数，None表示无限制
 6     setsession = [], #开始会话前执行的命令
 7     ping = 0, #ping MySQL服务端,检查服务是否可用
 8     closeable = False, #conn.close()实际上被忽略，供下次使用，直到线程关闭，自动关闭链接，而等于True时，conn.close()真的被关闭
 9     threadlocal = None, # 本线程独享值的对象，用于保存链接对象
10     host = '127.0.0.1',
11     port = 3306,
12     user = 'root',
13     password = '123',
14     database = 'ok1',
15     charset = 'utf8'
16 )
17 def func():
18     conn = PooL.connection()
19     cursor = conn.cursor()
20     cursor.execute('select * from book')
21     result = cursor.fetchall()
22     print(result)
23     cursor.close()
24     conn.close()
25 import threading
26 for i in range(5):
27     t = threading.Thread(target=func)
28     t.start()

模式一

　　2.创建一批连接到连接池，供所有线程共享使用

　　注意：由于pymysql,mysqlDB中的threadsafety值为1，所有线程共享连接

 1 import time
 2 import pymysql
 3 import threading
 4 from DBUtils.PooledDB import PooledDB,SharedDBConnection
 5 
 6 POOL = PooledDB(
 7     creator = pymysql, #使用链接数据库的模块
 8     maxconnections = 6,  #连接池允许的最大连接数，0和None表示没有限制
 9     mincached = 2, #初始化时，连接池至少创建的空闲的连接，0表示不创建
10     maxcached = 5, #连接池空闲的最多连接数，0和None表示没有限制
11     maxshared = 3, #连接池中最多共享的连接数量，0和None表示全部共享，ps:其实并没有什么用，因为pymsql和MySQLDB等模块中的threadsafety都为1，所有值无论设置多少，_maxcahed永远为0，所以永远是所有链接共享
12     blocking = True, #链接池中如果没有可用共享连接后，是否阻塞等待，True表示等待，False表示不等待然后报错
13     setsession = [],#开始会话前执行的命令列表
14     ping = 0,#ping Mysql 服务端，检查服务是否可用
15     host = '127.0.0.1',
16     port = 3306,
17     user = 'root',
18     password = '123',
19     database = 'ok1',
20     charset = 'utf8'
21 )
22 def func():
23     #检测当前正在运行的连接数是否小于最大的连接数，如果不小于则等待连接或者抛出raise TooManyConnections异常
24     #否则优先去初始化时创建的连接中获取连接SteadyDBConnection
25     #然后将SteadyDBConnection对象封装到PooledDedicatedDBConnection中并返回
26     #如果最开始创建的连接没有链接，则去创建SteadyDBConnection对象，再封装到PooledDedicatedDBConnection中并返回
27     #一旦关闭链接后，连接就返回到连接池让后续线程继续使用
28     conn = POOL.connection()
29     cursor = conn.cursor()
30     cursor.execute('select * from book')
31     result = cursor.fetchall()
32     print(result)
33     conn.close()
34 func()

模式二

　　PS：关于pymysql模块，如果没有单线程的情况，连接MySQL数据库没有问题，但如果要是多线程，就需要加锁，一旦加锁，后面的线程就得等待，势必会降低使用效率。

 1 import pymysql
 2 import threading
 3 from threading import RLock
 4 LOCK = RLock()
 5 CONN = pymysql.connect(host='127.0.0.1',
 6                        port = 3306,
 7                        user = 'root',
 8                        password = '123',
 9                        database = 'ok1',
10                        charset = 'utf8'
11                        )
12 def task(arg):
13     with LOCK:
14         cursor = CONN.cursor()
15         cursor.execute('select * from book')
16         result = cursor.fetchall()
17         cursor.close()
18         print(result)
19 for i in range(10):
20     t = threading.Thread(target=task,args=(i,))
21     t.start()

加锁

 1 import pymysql
 2 import threading
 3 CONN = pymysql.connect(host='127.0.0.1',
 4                        port=3306,
 5                        user='root',
 6                        password='123',
 7                        database='ok1',
 8                        charset='utf8')
 9 
10 def task(arg):
11     cursor = CONN.cursor()
12     cursor.execute('select * from book')
13     result = cursor.fetchall()
14     cursor.close()
15     print(result)
16 for i in range(10):  #1时不会报错
17     t = threading.Thread(target=task, args=(i,))
18     t.start()

不加锁

 

转载于:https://www.cnblogs.com/sxh-myblogs/p/8227615.html