android 多线程数据库读写分析与优化【转】

//SQLiteDatabase.java   
  
public long insertWithOnConflict(String table, String nullColumnHack,  
            ContentValues initialValues, int conflictAlgorithm) {  
        if (!isOpen()) {  
            throw new IllegalStateException("database not open");  
        }  
  
        .... 省略  
  
        lock();  
        SQLiteStatement statement = null;  
        try {  
            statement = compileStatement(sql.toString());  
  
            // Bind the values  
            if (entrySet != null) {  
                int size = entrySet.size();  
                Iterator<Map.Entry<String, Object>> entriesIter = entrySet.iterator();  
                for (int i = 0; i < size; i++) {  
                    Map.Entry<String, Object> entry = entriesIter.next();  
                    DatabaseUtils.bindObjectToProgram(statement, i + 1, entry.getValue());  
                }  
            }  
  
            // Run the program and then cleanup  
            statement.execute();  
  
            long insertedRowId = lastInsertRow();  
            if (insertedRowId == -1) {  
                Log.e(TAG, "Error inserting " + initialValues + " using " + sql);  
            } else {  
                if (Config.LOGD && Log.isLoggable(TAG, Log.VERBOSE)) {  
                    Log.v(TAG, "Inserting row " + insertedRowId + " from "  
                            + initialValues + " using " + sql);  
                }  
            }  
            return insertedRowId;  
        } catch (SQLiteDatabaseCorruptException e) {  
            onCorruption();  
            throw e;  
        } finally {  
            if (statement != null) {  
                statement.close();  
            }  
            unlock();  
        }  
    }  

//SQLiteDatabase.java   
  
  
 private final ReentrantLock mLock = new ReentrantLock(true);  
  
/* package */ void lock() {  
  
       if (!mLockingEnabled) return;   
  
             mLock.lock();   
  
             if (SQLiteDebug.DEBUG_LOCK_TIME_TRACKING) {   
  
                 if (mLock.getHoldCount() == 1) {   
  
                       // Use elapsed real-time since the CPU may sleep when waiting for IO  
  
                       mLockAcquiredWallTime = SystemClock.elapsedRealtime();   
  
                       mLockAcquiredThreadTime = Debug.threadCpuTimeNanos();   
  
                 }   
  
      }   
  
}  

/** 
   * Reads rows into a buffer. This method acquires the database lock. 
   * 
   * @param window The window to fill into 
   * @return number of total rows in the query 
   */  
  /* package */ int fillWindow(CursorWindow window,  
          int maxRead, int lastPos) {  
      long timeStart = SystemClock.uptimeMillis();  
      mDatabase.lock();  
      mDatabase.logTimeStat(mSql, timeStart, SQLiteDatabase.GET_LOCK_LOG_PREFIX);  
      try {  
          acquireReference();  
          try {  
              window.acquireReference();  
              // if the start pos is not equal to 0, then most likely window is  
              // too small for the data set, loading by another thread  
              // is not safe in this situation. the native code will ignore maxRead  
              int numRows = native_fill_window(window, window.getStartPosition(), mOffsetIndex,  
                      maxRead, lastPos);  
  
              // Logging  
              if (SQLiteDebug.DEBUG_SQL_STATEMENTS) {  
                  Log.d(TAG, "fillWindow(): " + mSql);  
              }  
              mDatabase.logTimeStat(mSql, timeStart);  
              return numRows;  
          } catch (IllegalStateException e){  
              // simply ignore it  
              return 0;  
          } catch (SQLiteDatabaseCorruptException e) {  
              mDatabase.onCorruption();  
              throw e;  
          } finally {  
              window.releaseReference();  
          }  
      } finally {  
          releaseReference();  
          mDatabase.unlock();  
      }  
  }  

//  SQLiteOpenHelper.java  
  
  public synchronized SQLiteDatabase getReadableDatabase() {  
        if (mDatabase != null && mDatabase.isOpen()) {  
           <span style="color:#FF0000;"> return mDatabase;</span>  // The database is already open for business  
        }  
  
        if (mIsInitializing) {  
            throw new IllegalStateException("getReadableDatabase called recursively");  
        }  
  
        try {  
            return getWritableDatabase();  
        } catch (SQLiteException e) {  
            if (mName == null) throw e;  // Can‘t open a temp database read-only!  
            Log.e(TAG, "Couldn‘t open " + mName + " for writing (will try read-only):", e);  
        }  
  
        SQLiteDatabase db = null;  
        try {  
            mIsInitializing = true;  
            String path = mContext.getDatabasePath(mName).getPath();  
            db = SQLiteDatabase.openDatabase(path, mFactory, SQLiteDatabase.OPEN_READONLY);  
            if (db.getVersion() != mNewVersion) {  
                throw new SQLiteException("Can‘t upgrade read-only database from version " +  
                        db.getVersion() + " to " + mNewVersion + ": " + path);  
            }  
  
            onOpen(db);  
            Log.w(TAG, "Opened " + mName + " in read-only mode");  
            mDatabase = db;  
            return mDatabase;  
        } finally {  
            mIsInitializing = false;  
            if (db != null && db != mDatabase) db.close();  
        }  
    } 

//DbHelper.java   
//DbHelper extends SQLiteOpenHelper  
public SQLiteDatabase getOnlyReadDatabase() {  
        try{  
            getWritableDatabase(); //保证数据库版本最新  
        }catch(SQLiteException e){  
            Log.e(TAG, "Couldn‘t open " + mName + " for writing (will try read-only):",e);  
        }  
          
        SQLiteDatabase db = null;  
        try {  
            String path = mContext.getDatabasePath(mName).getPath();  
            db = SQLiteDatabase.openDatabase(path, mFactory, SQLiteDatabase.OPEN_READONLY);  
            if (db.getVersion() != mNewVersion) {  
                throw new SQLiteException("Can‘t upgrade read-only database from version " +  
                        db.getVersion() + " to " + mNewVersion + ": " + path);  
            }  
  
            onOpen(db);  
            readOnlyDbs.add(db);  
            return db;  
        } finally {  
        }  
}  

public DbHelper(Context context , boolean enableWAL) {  
        this(context, DEFAULT_DB_NAME, null, DEFAULT_VERSION);  
        if( enableWAL && Build.VERSION.SDK_INT >= 11){  
            getWritableDatabase().enableWriteAheadLogging();  
        }  
}