关于Android SQLite3多线程并发问题

最近有看到过Sqlite3的相关文章，在这做一下学习笔记。

关于sqlite的介绍，可以参照一下：http://blog.csdn.net/ghost5216/article/details/4863246

sqlite3数据库是一个数据库一个文件，所以当多进程访问操作同一数据库时，即与操作同一文件一样，文件锁问题。
对同个数据库进行多进程同时读是允许的，但多进程同时写是不允许的，如果一个进程已经正在写，其他进程就会写失败。sqlite3返回信息就是"Database is locked"，错误码SQLITE_BUSY，sqlite3对高并发访问支持不好，多线程访问数据库会出现数据库锁定现象。

那么在并发的情况下，如何安全的访问sqlite数据库呢？

假设你已经有一个自己的SQLiteOpenHelper。

[java]  view plain  copy

1. public class DatabaseHelper extends SQLiteOpenHelper { ... }  

[java]  view plain  copy

1. //Thread 1  
2. Context context = getApplicationContext();  
3. DatabaseHelper helper = new DatabaseHelper(context);  
4. SQLiteDatabase database = helper.getWritableDatabase();  
5. database.insert(…);  
6. database.close();  
7.   
8. // Thread 2  
9. Context context = getApplicationContext();  
10. DatabaseHelper helper = new DatabaseHelper(context);  
11. SQLiteDatabase database = helper.getWritableDatabase();  
12. database.insert(…);  
13. database.close();  

在你的logcat中将会得到下面的输出信息，并且有一个写操作将不会成功

[java]  view plain  copy

1. android.database.sqlite.SQLiteDatabaseLockedException: database is locked (code 5)  

发生这种情况是因为你每次都创建了一个新的SQLiteOpenHelper，实际上你每次都创建了一个数据库的连接。如果你在同一时间用不同的数据库连接来对同一的数据库进行写操作的话，那么其中一个会失败。
在 Android 平台上，如果你想在多线程环境下安全的使用数据库的话，那么你得确保所有的线程使用的都是同一个数据库连接。

确保只有一个数据库连接存在，我们可以使用单例模式，代码如下:

[java]  view plain  copy

1. public class DatabaseManager {  
2.   
3.     private static DatabaseManager instance;  
4.     private static SQLiteOpenHelper mDatabaseHelper;  
5.   
6.     public static synchronized void initialize(Context context, SQLiteOpenHelper helper) {  
7.         if (instance == null) {  
8.             instance = new DatabaseManager();  
9.             mDatabaseHelper = helper;  
10.         }  
11.     }  
12.   
13.     public static synchronized DatabaseManager getInstance() {  
14.         if (instance == null) {  
15.             throw new IllegalStateException(DatabaseManager.class.getSimpleName() +  
16.                     " is not initialized, call initialize(..) method first.");  
17.         }  
18.   
19.         return instance;  
20.     }  
21.   
22.     public synchronized SQLiteDatabase getDatabase() {  
23.         return new mDatabaseHelper.getWritableDatabase();  
24.     }  
25.   
26. }  

现在我们来看看执行结果:

// In your application class
DatabaseManager.initializeInstance(getApplicationContext());

// Thread 1
DatabaseManager manager = DatabaseManager.getInstance();
SQLiteDatabase database = manager.getDatabase()
database.insert(…);
database.close();

// Thread 2
DatabaseManager manager = DatabaseManager.getInstance();
SQLiteDatabase database = manager.getDatabase()
database.insert(…);
database.close();

你的应用将会崩溃，异常信息如下:

java.lang.IllegalStateException: attempt to re-open an already-closed object: SQLiteDatabase

因为我们只使用一个数据库连接，Thread1和Thread2的都是由getDatabase()方法返回的相同连接。发生的什么事呢，在Thread2还在使用数据库连接时，Thread1可能已经把它给关闭了，那就是为什么你会得到崩溃异常。
我们需要确保在没有任何一个人在使用数据库时，才去关闭它。在StackOverflow上推荐的做法是永远不要关闭数据库。Android会尊重你这种做法，但会给你如下的提示。所以我一点也不推荐这种做法。

Leak found

Caused by: java.lang.IllegalStateException: SQLiteDatabase created and never closed

下面是一个样例程序

public class DatabaseManager{

    private AtomicInteger mOpenCounter = new AtomicInteger();

    private static DatabaseManager instance;
    private static SQLiteOpenHelper mDatabaseHelper;
    private SQLiteDatabase mDatabase;

    public static synchronized void initializeInstance(SQLiteOpenHelper helper) {
        if (instance == null) {
            instance = new DatabaseManager();
            mDatabaseHelper = helper;
        }
    }

    public static synchronized DatabaseManager getInstance() {
        if (instance == null) {
            throw new IllegalStateException(DatabaseManager.class.getSimpleName() +
                    " is not initialized, call initializeInstance(..) method first.");
        }

        return instance;
    }

    public synchronized SQLiteDatabase openDatabase() {
        if(mOpenCounter.incrementAndGet() == 1) {
            // Opening new database
            mDatabase = mDatabaseHelper.getWritableDatabase();
        }
        return mDatabase;
    }

    public synchronized void closeDatabase() {
        if(mOpenCounter.decrementAndGet() == 0) {
            // Closing database
            mDatabase.close();

        }
    }}

使用方式：

SQLiteDatabase database = DatabaseManager.getInstance().openDatabase();
database.insert(...);
// database.close(); Don't close it directly!
DatabaseManager.getInstance().closeDatabase(); // correct way

每当你需要使用数据库时，你需要使用DatabaseManager的openDatabase()方法来取得数据库。我们会使用一个引用计数来判断是否要创建数据库对象。如果引用计数为1，则需要创建一个数据库，如果不为1，说明我们已经创建过了。
在closeDatabase()方法中我们同样通过判断引用计数的值，如果引用计数降为0，则说明我们需要close数据库。

大致的做法就是在多线程访问的情况下需要自己来封装一个DatabaseManager来管理Sqlite数据库的读写，需要同步的同步，需要异步的异步，不要直接操作数据库，这样很容易出现因为锁的问题导致加锁后的操作失败。