Android sqlite数据库连接池连接异常分析

转:http://bbs.51cto.com/thread-1113117-1.html

 

Android sqlite数据库连接池连接异常分析

1 android开发过程中,突然碰到了这个错误,数据库连接分配不到,日志如下:
W/SQLiteConnectionPool( 3681): Theconnection pool for database '/data/user/0/com.android.providers.contacts/databases/contacts2.db'has been unable to grant a connection to thread 371 (ContactsProviderWorker)with flags 0x1 for 30.000002 seconds.
W/SQLiteConnectionPool( 3681): Connections:0 active, 1 idle, 0 available.


2 网上别人的总结
搜索了上面错误日志,找到别人的解决方法:

1.png (62.72 KB)
2014-6-23 19:43


他说是在一个Transaction里面又执行一个execSql(sql)导致。但是经过自己的分析发现,完全不是这么回事。可见,网络上很多东西都是不可全信的。
为什么这么说呢,我们首先来分析下整个数据库连接的获取过程,一般进行下列操作时都会申请获取一个数据库连接。
a.
Query, insert, delete操作
b.
beginTranscation操作
从网上截了个图,让大家看的更清楚点

2.png (91.23 KB)
2014-6-23 19:43




Ok... 那么我们就以insert操作为例,说明数据库连接获取的流程。


1.
01 SqliteDatabase的insert方法
02 public long insert(String table, StringnullColumnHack, ContentValues values) {
03  
04 try {
05  
06 return insertWithOnConflict(table, nullColumnHack, values,CONFLICT_NONE);
07  
08 } catch(SQLException e) {
09  
10 Log.e(TAG, "Error inserting "+ values, e);
11  
12 return -1;
13  
14 }
15 }
2.
Ok... 继续往下面分析insertWithOnConflict方法
01 public long insertWithOnConflict(Stringtable, String nullColumnHack,
02  
03 ContentValues initialValues, int conflictAlgorithm) {
04  
05 acquireReference();
06  
07 try {
08  
09 StringBuilder sql = newStringBuilder();
10  
11 sql.append("INSERT");
12  
13 sql.append(CONFLICT_VALUES[conflictAlgorithm]);
14  
15 sql.append(" INTO ");
16  
17 ...
18  
19 sql.append(')');
20  
21  
22  
23 SQLiteStatement statement = newSQLiteStatement(this, sql.toString(),bindArgs);
24  
25 try {
26  
27 returnstatement.executeInsert();
28  
29 } finally{
30  
31 statement.close();
32  
33 }
34  
35 } finally{
36  
37 releaseReference();
38  
39 }
40  
41 }
这个方法首先构造insert的sql语句,然后调用statement的executeInsert()方法
那继续跟下去
3.
frameworks\base\core\java\android\database\sqlite\SQLiteStatement.java
01 public long executeInsert() {
02  
03 ...
04  
05 return getSession().executeForLastInsertedRowId(
06  
07 getSql(), getBindArgs(), getConnectionFlags(),null);
08  
09 ...
10  
11 }
这个方法比较重要,分成两步来分析:
首先分析getSession()方法,
然后再去看看executeForLastInsertedRowId方法。


3a. getSession分析
01 frameworks\base\core\java\android\database\sqlite\SQLiteProgram.java
02 protected final SQLiteSession getSession(){
03  
04 return mDatabase.getThreadSession();
05 }
06 3b. 调用的是SqliteDatabase.getThreadSession()方法,继续分析
07 frameworks\base\core\java\android\database\sqlite\SQLiteDatabase.java
08 SQLiteSession getThreadSession() {
09  
10 return mThreadSession.get(); // initialValue() throws if database closed
11  
12 }
调用的是mThreadSession.get(),看看mThreadSession是什么东西
01 private final ThreadLocal<SQLiteSession>mThreadSession = new ThreadLocal<SQLiteSession>() {
02  
03 protected SQLiteSession initialValue() {
04  
05 return createSession();
06  
07 }
08 };
09  
10  
11 SQLiteSession createSession() {
12  
13 final SQLiteConnectionPool pool;
14  
15 synchronized (mLock) {
16  
17 pool = mConnectionPoolLocked;
18  
19 }
20  
21 return new SQLiteSession(pool);
22  
23 }
24  
25  
26 public SQLiteSession(SQLiteConnectionPoolconnectionPool) {
27  
28 if (connectionPool == null) {
29  
30 throw new IllegalArgumentException("connectionPool must not benull");
31  
32 }
33  
34 mConnectionPool = connectionPool;
35  
36 }
嗯,非常明白,这是一个ThreadLocal类型的变量,ThreadLocal,Java提供的一个用于多线程之间隔离数据的东西,避免多线程访问同一个变量导致冲突。
也就是ThreadLocal是为每个线程保存一份变量,这样就不会引起冲突了。这个ThreadLocal如果有不理解的,可以百度下ThreadLocal的使用。


Ok..理解完ThreadLocal之后,继续看createSession方法
它是使用mConnectionPoolLocked这么个SQLiteConnectionPool变量来实例化一个SQLiteSession对象。而这个mConnectionPoolLocked对象是SqliteDatabase打开的时候实例化的,也就是说一个database只有一个这样连接。
那么,这里我们可以理清楚一个关系
a.
一个线程会对应一个SqliteSession对象,这个是用ThreadLocal对象来维持的。
b.
一个数据库对应唯一一个sqliteDabase对象,以及唯一一个SQLiteConnectionPool对象,然后各个线程之间共享这个SQLiteConnectionPool对象。
Ok..理清楚这几个关系之后,返回去分析executeForLastInsertedRowId方法


4.
frameworks\base\core\java\android\database\sqlite\SQLiteSession.java
01 public long executeForLastInsertedRowId(Stringsql, Object[] bindArgs,int connectionFlags,
02  
03 CancellationSignal cancellationSignal) {
04  
05 ...
06  
07 acquireConnection(sql, connectionFlags, cancellationSignal);// mightthrow
08  
09 try {
10  
11 return mConnection.executeForLastInsertedRowId(sql, bindArgs,
12  
13 cancellationSignal); //might throw
14  
15 } finally{
16  
17 releaseConnection(); // might throw
18  
19 }
20  
21 }
这个方法主要分析两个操作
acquireConnection
releaseConnection
因为中间的mConnection.executeForLastInsertedRowId语句主要是通过Jni往底层调用,插入数据库数据,不是今天我们讨论的话题。

Ok.. 那这两个操作,一个个来分析
4a. acquireConnection
frameworks\base\core\java\android\database\sqlite\SQLiteSession.java
01 private void acquireConnection(String sql,intconnectionFlags,
02  
03 CancellationSignal cancellationSignal) {
04  
05  
06 if (mConnection == null) {
07  
08 assert mConnectionUseCount == 0;
09  
10 mConnection = mConnectionPool.acquireConnection(sql, connectionFlags,
11  
12 cancellationSignal); // mightthrow
13  
14 mConnectionFlags = connectionFlags;
15  
16 }
17  
18 mConnectionUseCount += 1;
19  
20  
21 }
Ok..首先会去判断当前线程的Session里面的mConnection是否为null,如果不为null,就只是简单的把连接个数mConnectionUseCount加1
如果为null,也就是当前线程的Session没有连接数据库,那么就要去申请一个连接。



所以这里的逻辑特别重要,就是一个对于一个线程而已,它只会去获取一次数据库连接。即使你调用再多的beginTranscation以及query,第一次调用的时候会去获取连接,以后就是让mConnectionUseCount 加1;
当然,你使用beginTranscation需要手动调用endTranscation,不然不会去释放连接。
调用其他的,比如query,insert之类的,不需要手动释放。系统会帮你去调用释放连接。
Ok.. 接下来分析mConnectionPool.acquireConnection的流程.


4b. 调用mConnectionPool.acquireConnection,顾名思义,它是向连接池申请一个连接;根据之前的分析,这个连接池是唯一的,是多个线程之间共享的。

frameworks\base\core\java\android\database\sqlite\SQLiteConnectionPool.java
001 public SQLiteConnectionacquireConnection(String sql, intconnectionFlags,
002  
003 CancellationSignal cancellationSignal) {
004  
005 return waitForConnection(sql, connectionFlags, cancellationSignal);
006  
007 }
008  
009  
010  
011  
012 private SQLiteConnectionwaitForConnection(String sql, intconnectionFlags,
013  
014 CancellationSignal cancellationSignal) {
015  
016 final boolean wantPrimaryConnection =
017  
018 (connectionFlags &CONNECTION_FLAG_PRIMARY_CONNECTION_AFFINITY) !=0;
019  
020  
021  
022 final ConnectionWaiter waiter;
023  
024 final int nonce;
025  
026 synchronized (mLock) {
027  
028 throwIfClosedLocked();
029  
030  
031  
032 // Abort if canceled.
033  
034 if (cancellationSignal != null) {
035  
036 cancellationSignal.throwIfCanceled();
037  
038 }
039  
040  
041  
042 // Try to acquire a connection.
043  
044 SQLiteConnection connection = null;
045  
046 if (!wantPrimaryConnection) {
047 //尝试获取非主连接
048  
049 connection =tryAcquireNonPrimaryConnectionLocked(
050  
051 sql, connectionFlags);// might throw
052  
053 }
054  
055 if (connection == null) {
056 //尝试去获取主连接
057  
058 connection =tryAcquirePrimaryConnectionLocked(connectionFlags);// might throw
059  
060 }
061  
062 if (connection != null) {
063 //获取到连接后,返回连接
064  
065 return connection;
066  
067 }
068  
069 //没有获取到连接,新建一个waiter对象,加入等待队列
070  
071  
072 // No connections available.
073 Enqueue a waiter in priority order.
074  
075 final int priority = getPriority(connectionFlags);
076  
077 final long startTime = SystemClock.uptimeMillis();
078  
079 waiter = obtainConnectionWaiterLocked(Thread.currentThread(), startTime,
080  
081 priority,wantPrimaryConnection, sql, connectionFlags);
082  
083 ConnectionWaiter predecessor = null;
084  
085 ConnectionWaiter successor = mConnectionWaiterQueue;
086  
087 while (successor != null) {
088  
089  
090 if (priority >successor.mPriority) {
091  
092 waiter.mNext = successor;
093  
094 break;
095  
096 }
097  
098 predecessor = successor;
099  
100 successor = successor.mNext;
101  
102 }
103  
104 if (predecessor != null) {
105  
106 predecessor.mNext = waiter;
107  
108 } else{
109  
110 mConnectionWaiterQueue =waiter;
111  
112 }
113  
114  
115  
116 nonce = waiter.mNonce;
117  
118 }
119  
120  
121  
122 ....
123  
124  
125  
126 //把当前线程睡眠30s,然后尝试去获取连接,如果没有获取到连接,则打印当前线程的等待时间。
127  
128 try {
129  
130 // Park the thread until a connection is assigned or the pool is closed.
131  
132 // Rethrow an exception from the wait, if we got one.
133  
134 long busyTimeoutMillis = CONNECTION_POOL_BUSY_MILLIS;
135 //30s
136  
137 long nextBusyTimeoutTime = waiter.mStartTime + busyTimeoutMillis;
138  
139 for (;;) {
140  
141 // Detect and recover fromconnection leaks.
142  
143 if(mConnectionLeaked.compareAndSet(true,false)) {
144  
145  
146 synchronized (mLock) {
147  
148 wakeConnectionWaitersLocked();
149 }
150  
151 }
152  
153  
154  
155 // Wait to be unparked (mayalready have happened), a timeout, or interruption.
156  
157 LockSupport.parkNanos(this,busyTimeoutMillis * 1000000L);
158 //当前线程停止30s
159  
160  
161  
162 // Clear the interrupted flag,just in case.
163  
164 Thread.interrupted();
165  
166  
167  
168 // Check whether we are donewaiting yet.
169  
170 synchronized (mLock) {
171  
172 throwIfClosedLocked();
173  
174 final SQLiteConnectionconnection = waiter.mAssignedConnection;
175  
176 final RuntimeException ex =waiter.mException;
177  
178 if (connection != null ||ex != null) {
179  
180 recycleConnectionWaiterLocked(waiter);
181  
182 if (connection != null){
183  
184 return connection;
185  
186 }
187  
188 throw ex; // rethrow!
189  
190 }
191  
192  
193  
194  
195 final long now =SystemClock.uptimeMillis();
196  
197 if (now <nextBusyTimeoutTime) {
198  
199 busyTimeoutMillis = now- nextBusyTimeoutTime;
200  
201 } else{
202  
203 logConnectionPoolBusyLocked(now- waiter.mStartTime, connectionFlags);
204 //打印出当前线程等待的时间
205  
206 busyTimeoutMillis =CONNECTION_POOL_BUSY_MILLIS;
207  
208 nextBusyTimeoutTime =now + busyTimeoutMillis;
209  
210 }
211  
212 }
213  
214 }
215  
216 } finally{
217  
218 ...
219  
220 }
221  
222 }
这个方法比较多,我在里面做了一点注释,大概包括下面几个步骤。同时要明确一个概念,主连接和非主连接。
其实他们没有本质的区别,主连接是一定有的,在初始化的时候就实例化完毕;而非主连接是一个连接集合,也就是说非主连接可以有很多个。不过一般有个最大大小,我们可以配置的。
Ok...明白这个概念之后,讲讲步骤
a.
如果没有指定要获取主连接的话,首先尝试获取非主连接
01 private SQLiteConnectiontryAcquireNonPrimaryConnectionLocked(
02  
03 String sql, intconnectionFlags) {
04  
05 // Try to acquire the next connection in the queue.
06  
07 SQLiteConnection connection;
08  
09 final int availableCount = mAvailableNonPrimaryConnections.size();
10  
11 if (availableCount > 1 && sql != null) {
12  
13 // If we have a choice, then prefer a connection that has the
14  
15 // prepared statement in its cache.
16  
17  
18 for (int i = 0; i <availableCount; i++) {
19  
20 connection =mAvailableNonPrimaryConnections.get(i);
21  
22 if(connection.isPreparedStatementInCache(sql)) {
23  
24 mAvailableNonPrimaryConnections.remove(i);
25  
26  
27 finishAcquireConnectionLocked(connection,connectionFlags);// might throw
28  
29 return connection;
30  
31 }
32  
33 }
34  
35 }
36  
37 if (availableCount > 0) {
38  
39 // Otherwise, just grab the next one.
40  
41  
42 connection =mAvailableNonPrimaryConnections.remove(availableCount -1);
43  
44 finishAcquireConnectionLocked(connection, connectionFlags);// mightthrow
45  
46 return connection;
47  
48 }
49  
50  
51  
52 // Expand the pool if needed.
53  
54 int openConnections = mAcquiredConnections.size();
55  
56 if (mAvailablePrimaryConnection != null) {
57  
58 openConnections += 1;
59  
60  
61 }
62  
63  
64  
65 if (openConnections >= mMaxConnectionPoolSize) {
66  
67 return null;
68  
69 }
70  
71 connection = openConnectionLocked(mConfiguration,
72  
73 false /*primaryConnection*/);// might throw
74  
75 finishAcquireConnectionLocked(connection, connectionFlags);// mightthrow
76  
77 return connection;
78  
79 }
获取非主连接的时候,首先会判断已有的连接中有没有相同的sql,如果有的话,就直接返回这个连接。
然后如果第一步没有成功的话,比如传入的sql是null,那么就会尝试获取队列里面的最后一个连接,然后返回。
如果第二步也没有成功,那么它会尝试去扩充非主连接集合
但是,它会去判断是否超过了最大的连接数,是已经到达最大的连接数,那么就返回null
1 if (openConnections >=mMaxConnectionPoolSize) {
2  
3 return null;
4  
5 }
如果还没有到达最大连接数,那么就把连接放入非主连接集合,然后返回这个扩容的连接。


b.
如果没有获取到非主连接,或者指定要获取主连接,那么就要去尝试获取主连接。
01 private SQLiteConnectiontryAcquirePrimaryConnectionLocked(intconnectionFlags) {
02  
03 // If the primary connection is available, acquire it now.
04  
05 SQLiteConnection connection = mAvailablePrimaryConnection;
06  
07 if (connection != null) {
08  
09 mAvailablePrimaryConnection = null;
10  
11 finishAcquireConnectionLocked(connection, connectionFlags);// mightthrow
12  
13 return connection;
14  
15 }
16  
17  
18  
19 // Make sure that the primary connection actually exists and has justbeen acquired.
20  
21 for (SQLiteConnection acquiredConnection :mAcquiredConnections.keySet()) {
22  
23 if (acquiredConnection.isPrimaryConnection()) {
24  
25 return null;
26  
27 }
28  
29  
30 }
31  
32  
33  
34 // Uhoh.
35 No primaryconnection!
36 Either thisis the firsttime we asked
37  
38 // for it, or maybe it leaked?
39  
40 connection = openConnectionLocked(mConfiguration,
41  
42 true /*primaryConnection*/); //might throw
43  
44 finishAcquireConnectionLocked(connection, connectionFlags);// mightthrow
45  
46 return connection;
47  
48 }
由于主连接只有一个,所以它用一个变量来表示 --- mAvailablePrimaryConnection
如果主连接为null就返回主连接,并把主连接设置成null,也就是主连接被占用。
1 if (connection != null) {
2  
3 mAvailablePrimaryConnection = null;
4  
5 finishAcquireConnectionLocked(connection, connectionFlags);// mightthrow
6  
7 return connection;
8  
9 }
如果主连接为null,那么它会去查看是否已经有人获取了主连接,如果是,那么返回null;这样做就是确保主连接是存在的。
如果经过上面一步确认,还没有返回,那么说明主连接没有创建;这个一般是不可能的,因为主连接时数据库初始化的时候创建的。这个一般是第一次访问,或者出现了程序异常。那么就新建一个主连接,然后返回。


c.
如果获取到连接,那么返回这个连接
1 if (connection != null) {
2  
3 return connection;
4 }
d.
如果没有获取到连接,那么新建一个waiter对象,并进入等待队列。
e.
线程进入死循环,不断休眠(30s),然后重新获取连接。直到获取到连接后返回。否则,记录下当前线程等待的时间。不过这里要注意,这里打印的等待时间并不包括系统睡眠的时间。比如,下午1点进入等待,2点-4点手机睡眠,那么到5点的时候打印,只能算两个小时。
也就是上面我们看到的异常日志:
04-2314:25:48.522 W/SQLiteConnectionPool( 3681): The connection pool for database'/data/user/0/com.android.providers.contacts/databases/contacts2.db' has beenunable to grant a connection to thread 371 (ContactsProviderWorker) with flags0x1 for 30.000002 seconds.
04-23 14:25:48.522 W/SQLiteConnectionPool( 3681):Connections: 0 active, 1 idle, 0 available.


Ok...至此,整个申请数据库连接过程分析基本完毕,下面分析释放的过程



5.释放连接
frameworks\base\core\java\android\database\sqlite\SQLiteSession.java
01 finally {
02 releaseConnection();// might throw
03 }
04  
05  
06 private void releaseConnection() {
07  
08  
09 assert mConnection != null;
10  
11 assert mConnectionUseCount > 0;
12  
13 if (--mConnectionUseCount == 0) {
14  
15  
16 try {
17  
18 mConnectionPool.releaseConnection(mConnection);// might throw
19  
20 } finally{
21  
22 mConnection = null;
23  
24 }
25  
26 }
27  
28 }
首先会去判断当前使用数是否为大于0,还记得前面我们说过如果线程第一次申请连接,那么就去申请,然后使用数+1;但是如果线程已经拥有了连接,那么我们只是简单的把连接数+1。
所以,这里要判断这个连接数是否>0
然后把连接数减去1,看是否等于0;这是什么意思呢?就是说当前线程已经没有使用数据库的操作了。

如果减去1之后>0,那么说明当前线程还要使用这个连接操作数据库,还不能释放。
这里也可以看出,申请连接和释放连接一定要是一一对应的。申请了,一定要释放。当然,对于应用程序来说,只有beginTranscation需要手动去释放,也就是调用endTranscation,而且必须要调用(一般写在finally里面)。
Ok...一切都ok的话,正式去释放连接
mConnectionPool.releaseConnection(mConnection);// might throw


5a. 正式释放连接

frameworks\base\core\java\android\database\sqlite\SQLiteConnectionPool.java
01 public voidreleaseConnection(SQLiteConnection connection) {
02  
03  
04 synchronized (mLock) {
05  
06 ....
07  
08 if (!mIsOpen) {
09  
10 closeConnectionAndLogExceptionsLocked(connection);
11  
12 } elseif (connection.isPrimaryConnection()) {
13  
14 if(recycleConnectionLocked(connection, status)) {
15  
16 assert mAvailablePrimaryConnection== null;
17  
18 mAvailablePrimaryConnection= connection;
19  
20 }
21  
22 wakeConnectionWaitersLocked();
23  
24 } elseif (mAvailableNonPrimaryConnections.size() >=mMaxConnectionPoolSize -1) {
25  
26 closeConnectionAndLogExceptionsLocked(connection);
27  
28 } else{
29  
30 if(recycleConnectionLocked(connection, status)) {
31  
32 mAvailableNonPrimaryConnections.add(connection);
33  
34 }
35  
36  
37 wakeConnectionWaitersLocked();
38  
39 }
40  
41 }
42  
43 }
这里会去根据当前连接是否是主连接而选择释放方法,然后通知那些正在等待的线程(waiter)去获取连接。


6. 总结
1. 如文章开头所说,这个bug不是由于在beginTranscation里面执行一个execuSql(sql)所导致的,因为在同一个线程里面,即使申请两次数据库连接,那也只是让使用数+1而已。它只会去申请一个连接。除非beginTranscation和execuSql(sql) 不在一个线程,另外开线程去execuSql(sql).
2. 那么怎么会导致这个bug呢?

a. 时间过长的操作,某个操作持续很长时间,那么其他线程等待的时候就会打印这个信息。不过,一般不会等待太久。因为一般不会有这么长时间的数据库操作。
b. 忘记调用endTranscation,如前面所说,只有beginTranscation需要程序员手动去调用endTransction来释放连接,其他操作不需要。
那么,有个时候会疏忽忘记调用endTransction了。
或者endTranscation没有放在finally里面,导致出现异常而没有调用endTransction
c.
死锁,这个比较复杂,需要具体问题具体分析。
如果出现死锁,线程互相等待,这样也没有去释放连接;那么后面的线程自然也拿不到数据库连接了。




参考资料
http://blog.csdn.net/efeics/article/details/18970483
发布了183 篇原创文章 · 获赞 53 · 访问量 20万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 精致技术 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览