SQLiteDatabase 多线程数据库读写分析与优化

    最新需要给软件做数据库读写方面的优化，之前无论读写，都是用一个 SQLiteOpenHelper.getWriteableDataBase() 来操作数据库，现在需要多线程并发读写。 Android 的数据库系统用的是sqlite ，sqlite的每一个数据库其实都是一个.db文件，它的同步锁也就精确到文件级别了。 下面分析一下不同情况下，在同一个数据库文件上操作sqlite的表现：

1，多线程写，使用一个SQLiteOpenHelper。也就保证了多线程使用一个SQLiteDatabase。
　　先看看相关的源码
　　java代码

1. //SQLiteDatabase.java
   
2. 
   
3. 　　public long insertWithOnConflict(String table, String nullColumnHack,
   
4. 　　ContentValues initialValues, int conflictAlgorithm) {
   
5. 　　if (!isOpen()) {
   
6. 　　throw new IllegalStateException("database not open");
   
7. 　　}
   
8. 　　.... 省略
   
9. 　　lock();
   
10. 　　SQLiteStatement statement = null;
    
11. 　　try {
    
12. 　　statement = compileStatement(sql.toString());
    
13. 　　// Bind the values
    
14. 　　if (entrySet != null) {
    
15. 　　int size = entrySet.size();
    
16. 　　Iterator> entriesIter = 
    
17. entrySet.iterator();
    
18. 　　for (int i = 0; i < size; i++) {
    
19. 　　Map.Entry entry = entriesIter.next();
    
20. 　　DatabaseUtils.bindObjectToProgram(statement, i + 1, entry.getValue());
    
21. 　　}
    
22. 　　}
    
23. 　　// Run the program and then cleanup
    
24. 　　statement.execute();
    
25. 　　long insertedRowId = lastInsertRow();
    
26. 　　if (insertedRowId == -1) {
    
27. 　　Log.e(TAG, "Error inserting " + initialValues + " using " + sql);
    
28. 　　} else {
    
29. 　　if (Config.LOGD && Log.isLoggable(TAG, Log.VERBOSE)) {
    
30. 　　Log.v(TAG, "Inserting row " + insertedRowId + " from "
    
31. 　　+ initialValues + " using " + sql);
    
32. 　　}
    
33. 　　}
    
34. 　　return insertedRowId;
    
35. 　　} catch (SQLiteDatabaseCorruptException e) {
    
36. 　　onCorruption();
    
37. 　　throw e;
    
38. 　　} finally {
    
39. 　　if (statement != null) {
    
40. 　　statement.close();
    
41. 　　}
    
42. 　　unlock();
    
43. 　　}
    
44. 　　}

复制代码

　　java代码

1. //SQLiteDatabase.java
   
2. 
   
3. 　　private final ReentrantLock mLock = new ReentrantLock(true);
   
4. 　　/* package */ void lock() {
   
5. 　　if (!mLockingEnabled) return;
   
6. 　　mLock.lock();
   
7. 　　if (SQLiteDebug.DEBUG_LOCK_TIME_TRACKING) {
   
8. 　　if (mLock.getHoldCount() == 1) {
   
9. 　　// Use elapsed real-time since the CPU may sleep when waiting for IO
   
10. 　　mLockAcquiredWallTime = SystemClock.elapsedRealtime();
    
11. 　　mLockAcquiredThreadTime = Debug.threadCpuTimeNanos();
    
12. 　　}
    
13. 　　}
    
14. 　　}

复制代码

　　通过源码可以知道，在执行插入时，会请求SQLiteDatabase对象的成员对象 mlock 的锁，来保证插入不会并发执行。
　　经测试不会引发异常。
　　但是我们可以通过使用多个SQLiteDatabase对象同时插入，来绕过这个锁。
2，多线程写，使用多个SQLiteOpenHelper，插入时可能引发异常,导致插入错误。
　　E/Database(1471): android.database.sqlite.SQLiteException: error code 5: database is locked08-01
　　E/Database(1471): at android.database.sqlite.SQLiteStatement.native_execute(Native Method)
　　E/Database(1471): at android.database.sqlite.SQLiteStatement.execute(SQLiteStatement.java:55)
　　E/Database(1471): at android.database.sqlite.SQLiteDatabase.insertWithOnConflict(SQLiteDatabase.java:1549)
　　多线程写，每个线程使用一个SQLiteOpenHelper，也就使得每个线程使用一个SQLiteDatabase对象。多个线程同时执行insert, 最后调用到本地方法 SQLiteStatement.native_execute
　　抛出异常,可见android 框架，多线程写数据库的本地方法里没有同步锁保护，并发写会抛出异常。
　　所以，多线程写必须使用同一个SQLiteOpenHelper对象。
3，多线程读
　　看SQLiteDatabase的源码可以知道，insert , update , execSQL 都会 调用lock(), 乍一看唯有query 没有调用lock()。可是。。。
　　仔细看，发现
　　[attach]/data/attachment/forum/201308/eyeandroid.com69985050700111.jpg[/attach]
　　最后，查询结果是一个SQLiteCursor对象。
　　SQLiteCursor保存了查询条件，但是并没有立即执行查询，而是使用了lazy的策略，在需要时加载部分数据。
　　[attach]/data/attachment/forum/201308/eyeandroid.com69985050700112.jpg[/attach]
　　在加载数据时，调用了SQLiteQuery的fillWindow方法，而该方法依然会调用SQLiteDatabase.lock()
　　java代码

1. /**
   
2. 
   
3. 　　* Reads rows into a buffer. This method acquires the database lock.
   
4. 　　*
   
5. 　　* @param window The window to fill into
   
6. 　　* @return number of total rows in the query
   
7. 　　*/
   
8. 　　/* package */ int fillWindow(CursorWindow window,
   
9. 　　int maxRead, int lastPos) {
   
10. 　　long timeStart = SystemClock.uptimeMillis();
    
11. 　　mDatabase.lock();
    
12. 　　mDatabase.logTimeStat(mSql, timeStart, 
    
13. SQLiteDatabase.GET_LOCK_LOG_PREFIX);
    
14. 　　try {
    
15. 　　acquireReference();
    
16. 　　try {
    
17. 　　window.acquireReference();
    
18. 　　// if the start pos is not equal to 0, then most likely window is
    
19. 　　// too small for the data set, loading by another thread
    
20. 　　// is not safe in this situation. the native code will ignore maxRead
    
21. 　　int numRows = native_fill_window(window, window.getStartPosition(), 
    
22. mOffsetIndex,
    
23. 　　maxRead, lastPos);
    
24. 　　// Logging
    
25. 　　if (SQLiteDebug.DEBUG_SQL_STATEMENTS) {
    
26. 　　Log.d(TAG, "fillWindow(): " + mSql);
    
27. 　　}
    
28. 　　mDatabase.logTimeStat(mSql, timeStart);
    
29. 　　return numRows;
    
30. 　　} catch (IllegalStateException e){
    
31. 　　// simply ignore it
    
32. 　　return 0;
    
33. 　　} catch (SQLiteDatabaseCorruptException e) {
    
34. 　　mDatabase.onCorruption();
    
35. 　　throw e;
    
36. 　　} finally {
    
37. 　　window.releaseReference();
    
38. 　　}
    
39. 　　} finally {
    
40. 　　releaseReference();
    
41. 　　mDatabase.unlock();
    
42. 　　}
    
43. 　　}

复制代码

　　所以想要多线程读，读之间没有同步锁，也得每个线程使用各自的SQLiteOpenHelper对象，经测试，没有问题。
4，多线程读写
　　我们最终想要达到的目的，是多线程并发读写
　　多线程写之前已经知道结果了，同一时间只能有一个写。
　　多线程读可以并发
　　所以，使用下面的策略：
　　一个线程写，多个线程同时读，每个线程都用各自SQLiteOpenHelper。
　　这样，在java层，所有线程之间都不会锁住，也就是说，写与读之间不会锁，读与读之间也不会锁。
　　发现有插入异常。
　　E/SQLiteDatabase(18263): Error inserting descreption=InsertThread#01375493606407
　　E/SQLiteDatabase(18263): android.database.sqlite.SQLiteDatabaseLockedException: database is locked (code 5)
　　E/SQLiteDatabase(18263): at android.database.sqlite.SQLiteConnection.nativeExecuteForLastInsertedRowId(Native Method)
　　插入异常，说明在有线程读的时候写数据库，会抛出异常。
　　分析源码可以知道， SQLiteOpenHelper.getReadableDatabase() 不见得获得的就是只读SQLiteDatabase 。
　　java代码

1. // SQLiteOpenHelper.java
   
2. 
   
3. 　　public synchronized SQLiteDatabase getReadableDatabase() {
   
4. 　　if (mDatabase != null && mDatabase.isOpen()) {
   
5. 　　"color:#FF0000;"> return mDatabase; // The database is already open for 
   
6. business
   
7. 　　}
   
8. 　　if (mIsInitializing) {
   
9. 　　throw new IllegalStateException("getReadableDatabase called 
   
10. recursively");
    
11. 　　}
    
12. 　　try {
    
13. 　　return getWritableDatabase();
    
14. 　　} catch (SQLiteException e) {
    
15. 　　if (mName == null) throw e; // Can't open a temp database read-only!
    
16. 　　Log.e(TAG, "Couldn't open " + mName + " for writing (will try read-only):", 
    
17. e);
    
18. 　　}
    
19. 　　SQLiteDatabase db = null;
    
20. 　　try {
    
21. 　　mIsInitializing = true;
    
22. 　　String path = mContext.getDatabasePath(mName).getPath();
    
23. 　　db = SQLiteDatabase.openDatabase(path, mFactory, 
    
24. SQLiteDatabase.OPEN_READONLY);
    
25. 　　if (db.getVersion() != mNewVersion) {
    
26. 　　throw new SQLiteException("Can't upgrade read-only database from version " 
    
27. +
    
28. 　　db.getVersion() + " to " + mNewVersion + ": " + path);
    
29. 　　}
    
30. 　　onOpen(db);
    
31. 　　Log.w(TAG, "Opened " + mName + " in read-only mode");
    
32. 　　mDatabase = db;
    
33. 　　return mDatabase;
    
34. 　　} finally {
    
35. 　　mIsInitializing = false;
    
36. 　　if (db != null && db != mDatabase) db.close();
    
37. 　　}
    
38. 　　}

复制代码

　　因为它先看有没有已经创建的SQLiteDatabase，没有的话先尝试创建读写 SQLiteDatabase ，失败后才尝试创建只读SQLiteDatabase 。
　　所以写了个新方法，来获得只读SQLiteDatabase
　　java代码

1. //DbHelper.java
   
2. 
   
3. 　　//DbHelper extends SQLiteOpenHelper
   
4. 　　public SQLiteDatabase getOnlyReadDatabase() {
   
5. 　　try{
   
6. 　　getWritableDatabase(); //保证数据库版本最新
   
7. 　　}catch(SQLiteException e){
   
8. 　　Log.e(TAG, "Couldn't open " + mName + " for writing (will try 
   
9. read-only):",e);
   
10. 　　}
    
11. 　　SQLiteDatabase db = null;
    
12. 　　try {
    
13. 　　String path = mContext.getDatabasePath(mName).getPath();
    
14. 　　db = SQLiteDatabase.openDatabase(path, mFactory, 
    
15. SQLiteDatabase.OPEN_READONLY);
    
16. 　　if (db.getVersion() != mNewVersion) {
    
17. 　　throw new SQLiteException("Can't upgrade read-only database from version " 
    
18. +
    
19. 　　db.getVersion() + " to " + mNewVersion + ": " + path);
    
20. 　　}
    
21. 　　onOpen(db);
    
22. 　　readOnlyDbs.add(db);
    
23. 　　return db;
    
24. 　　} finally {
    
25. 　　}
    
26. 　　}

复制代码

　　使用策略：一个线程写，多个线程同时读，只用一个SQLiteOpenHelper,读线程使用自己写的getOnlyReadDatabase()方法获得只读。
　　但是经过测试，还是会抛出异常，2.2上只有插入异常，4.1.2上甚至还有读异常。
　　4.1.2上测试，读异常。
　　E/SQLiteLog(18263): (5) database is locked
　　W/dalvikvm(18263): threadid=21: thread exiting with uncaught exception (group=0x41e2c300)
　　E/AndroidRuntime(18263): FATAL EXCEPTION: onlyReadThread#8
　　E/AndroidRuntime(18263): android.database.sqlite.SQLiteDatabaseLockedException: database is locked (code 5): , while compiling: SELECT * FROM test_t
　　看来此路不同啊。
　　其实SQLiteDataBase 在API 11 多了一个 属性 ENABLE_WRITE_AHEAD_LOGGING。
　　可以打，enableWriteAheadLogging()，可以关闭disableWriteAheadLogging()，默认是关闭的。
　　这个属性是什么意思呢?
　　参考api文档，这个属性关闭时，不允许读，写同时进行，通过 锁 来保证。
　　当打开时，它允许一个写线程与多个读线程同时在一个SQLiteDatabase上起作用。实现原理是写操作其实是在一个单独的文件，不是原数据库文件。所以写在执行时，不会影响读操作，读操作读的是原数据文件，是写操作开始之前的内容。
　　在写操作执行成功后，会把修改合并会原数据库文件。此时读操作才能读到修改后的内容。但是这样将花费更多的内存。
　　有了它，多线程读写问题就解决了，可惜只能在API 11 以上使用。
　　所以只能判断sdk版本，如果3.0以上，就打开这个属性。
　　java代码

1. public DbHelper(Context context , boolean enableWAL) {
   
2. 
   
3. 　　this(context, DEFAULT_DB_NAME, null, DEFAULT_VERSION);
   
4. 　　if( enableWAL && Build.VERSION.SDK_INT >= 11){
   
5. 　　getWritableDatabase().enableWriteAheadLogging();
   
6. 　　}
   
7. 　　}

复制代码

结论：想要多线程并发读写，3.0以下就不要想了，3.0以上，直接设置enableWriteAheadLogging()就ok。如果还是达不到要求，就使用多个db文件吧。