Android SQLiteDatabase SQLiteSession SQLiteConnectionPool SQLiteConnection关系

转自：http://www.2cto.com/kf/201402/276805.html 

Android中使用sqlite，使用最多的类莫过于SQLiteOpenHelper及SQLiteDatabased两个类。使用最多的操作莫过于创建打开数据库、操作数据两种操作，后者最长用的是insert delete update、query两种操作。其中，query即select操作又牵扯到cursor等。

上述操作主要涉及SQLiteDatabase SQLiteSession SQLiteConnectionPool SQLiteConnection四个大类。本文将对Android操作sqlite的内部流程做简要分析。

1、主要类成员变量

public final class SQLiteDatabase extends SQLiteClosable {
    private static WeakHashMap<sqlitedatabase, object= "" > sActiveDatabases =
            new WeakHashMap<sqlitedatabase, object= "" >(); // 存储所有打开的数据库的引用
    private final ThreadLocal<sqlitesession> mThreadSession = new ThreadLocal<sqlitesession>() {
        @Override
        protected SQLiteSession initialValue() { // 每个线程有自己的一份mThreadSeesion
            return createSession();
        }
    };
    private final CursorFactory mCursorFactory; // Cursor工厂类，为了自定义Cursor
    private final SQLiteDatabaseConfiguration mConfigurationLocked; // 数据库的配置
    private SQLiteConnectionPool mConnectionPoolLocked; // 数据库连接池
    ……
}</sqlitesession></sqlitesession></sqlitedatabase,></sqlitedatabase,>

public final class SQLiteSession {
    private final SQLiteConnectionPool mConnectionPool;  // 连接池
    private SQLiteConnection mConnection;  // 连接
    private int mConnectionFlags;
    private int mConnectionUseCount;
    private Transaction mTransactionPool;  // 事务池
    private Transaction mTransactionStack; // 事务栈
    ……
}

public final class SQLiteConnectionPool implements Closeable {
    private final SQLiteDatabaseConfiguration mConfiguration;
    private int mMaxConnectionPoolSize;
    private boolean mIsOpen;
    private int mNextConnectionId;

    private ConnectionWaiter mConnectionWaiterPool;  // 连接等待池 其实是由 等待的连接 组成的链
    private ConnectionWaiter mConnectionWaiterQueue; // 连接等待队列

    private final ArrayList<sqliteconnection> mAvailableNonPrimaryConnections =
            new ArrayList<sqliteconnection>(); //强引用，非主连接
    private SQLiteConnection mAvailablePrimaryConnection;  // 主连接 只有一个
    private final WeakHashMap<sqliteconnection, acquiredconnectionstatus= "" > mAcquiredConnections =
            new WeakHashMap<sqliteconnection, acquiredconnectionstatus= "" >(); //弱引用，已取得的连接
    ……
}
</sqliteconnection,></sqliteconnection,></sqliteconnection></sqliteconnection>

public final class SQLiteConnection implements CancellationSignal.OnCancelListener {
    private final SQLiteConnectionPool mPool;
    private final SQLiteDatabaseConfiguration mConfiguration;
    private final int mConnectionId;
    private final boolean mIsPrimaryConnection;
    private final boolean mIsReadOnlyConnection;
    private final PreparedStatementCache mPreparedStatementCache; //stmt的缓存 强引用
    private PreparedStatement mPreparedStatementPool;
    private int mConnectionPtr;     // native层SQLiteConnection的指针
   ……
}

2、打开数据库时的调用情况

我们使用SQLiteOpenHelper时:
①

新建一个帮助类，getReadableDatabase或getWritableDatabase时，到②的第二条新打开

如果已经有了帮助类并且使用过，如果已经手动mDatabase.close过，到②的第二条新打开

getReadableDatabase时，无论上次使用是getReadableDatabase还是getWritableDatabase，会直接返回mDatabase，

getWritableDatabase时，如果上次是getWritableDatabase依然直接返回mDataBase，如果上次是getReadableDatabase，到②的第一条以读写模式打开。

②

如果已经有了帮助类，如果需要写入但现在是只读，即上次是getReadableDatabas这次是getWritableDatabase，则以读写模式重新打开db.reopenreadwrite

否则，如果getReadableDatabase，通过SQLiteDatabase.openDatabase打开只读数据库；如果getWritableDatabase，通过mContext.openOrCreateDatabase，最终仍通过SQLiteDatabase.openDatabase打开，此时flag已经变作CREATE_IF_NECESSARY。

到SQLiteDatabase中看下

public static SQLiteDatabase openDatabase(String path, CursorFactory factory, int flags,
        DatabaseErrorHandler errorHandler) {
    SQLiteDatabase db = new SQLiteDatabase(path, flags, factory, errorHandler);
    db.open();  // open会调用openInner 省略
    return db;
}
private void openInner() {
    synchronized (mLock) {
        assert mConnectionPoolLocked == null ;
        mConnectionPoolLocked = SQLiteConnectionPool.open(mConfigurationLocked);
        mCloseGuardLocked.open( "close" );
    }
    synchronized (sActiveDatabases) {
        sActiveDatabases.put( this , null );  // 放入sActiveDatabases
    }
}

SQLiteDatabase 持有自己的连接池，在open时获取到，在SQLiteConnectionPool中

public static SQLiteConnectionPool open(SQLiteDatabaseConfiguration configuration) {
    SQLiteConnectionPool pool = new SQLiteConnectionPool(configuration);
    pool.open();
    return pool;
}
private void open() {
    mAvailablePrimaryConnection = openConnectionLocked(mConfiguration,
            true /*primaryConnection*/ ); // 打开连接池 其实是打开一个主连接
    mIsOpen = true ;
    mCloseGuard.open( "close" );
}
private SQLiteConnection openConnectionLocked(SQLiteDatabaseConfiguration configuration,
        boolean primaryConnection) {
    final int connectionId = mNextConnectionId++;
    return SQLiteConnection.open( this , configuration,  // 通过调用connection.open()
            connectionId, primaryConnection);
}

SQLiteConnection调用的方法就是native层面了，open方法也比较简单。

private void open() {
    //--- !!! nativeOpen 并设置相应参数
    mConnectionPtr = nativeOpen(mConfiguration.path, mConfiguration.openFlags,
            mConfiguration.label,
            SQLiteDebug.DEBUG_SQL_STATEMENTS, SQLiteDebug.DEBUG_SQL_TIME);
    setPageSize();
    setForeignKeyModeFromConfiguration();
    setWalModeFromConfiguration();
    setJournalSizeLimit();
    setAutoCheckpointInterval();
    setLocaleFromConfiguration();
}

流程很简单，令人疑惑的是SQLiteConnectionPool在这里的作用。更令人疑惑的是连接池此时呈现出来的仅仅是一个主连接。
SQLiteConnectionPool中最为重要的成员是acquireConnection，下图表示了调用该成员的类及方法

可以看到，部分是开始事务时相关的方法、部分是准备statement时用到、部分是query时cursor用到。还有部分是与带返回结果的及不带返回结果的sql相关的操作，但这部分没有外部调用，也没有内部调用。其实不是的，最后一部分是为常用的insert delete update 等，具体如下。

<喎�"http://www.2cto.com/kf/ware/vc/" target="_blank" class="keylink">vcD4KPGgyPjOhomV4ZWNTUUy1xLX308PB97PMPC9oMj4K0tRTUUxpdGVEYXRhYmFzZS5leGVjU1FMzqrA/Txicj4KPHA+PC9wPgo8cD48L3A+CjxwcmUgY2xhc3M9"brush:java;"> public void execSQL(String sql) throws SQLException { //执行单条 无返回值 非select的sql executeSql(sql, null); } private int executeSql(String sql, Object[] bindArgs) throws SQLException { …… SQLiteStatement statement = new SQLiteStatement(this, sql, bindArgs); // 获取statement try { return statement.executeUpdateDelete(); } finally { statement.close(); } } public int executeUpdateDelete() { acquireReference(); try { return getSession().executeForChangedRowCount( // getSession在此出现 getSql(), getBindArgs(), getConnectionFlags(), null); } catch (SQLiteDatabaseCorruptException ex) { onCorruption(); throw ex; } finally { releaseReference(); } }

protected final SQLiteSession getSession() {  // SQLiteProgram中
    return mDatabase.getThreadSession();
}

SQLiteSession getThreadSession() {  // SQLiteDatabase中
    return mThreadSession.get();    // 和第1部分对应起来了 每个线程有自己的Session
}

继续查看 getSession().executeForChangedRowCount

// SQLiteSession中
public int executeForChangedRowCount(String sql, Object[] bindArgs, int connectionFlags,
        CancellationSignal cancellationSignal) {
    ……
    acquireConnection(sql, connectionFlags, cancellationSignal);     // 获取连接
    try {
        return mConnection.executeForChangedRowCount(sql, bindArgs,  // 通过connection执行
                cancellationSignal);
    } finally {
        releaseConnection();
    }
}
// SQLiteSession中
private void acquireConnection(String sql, int connectionFlags,
        CancellationSignal cancellationSignal) {
    if (mConnection == null ) {
        assert mConnectionUseCount == 0 ;
        mConnection = mConnectionPool.acquireConnection(sql, connectionFlags,  // 连接池中获取连接
                cancellationSignal); // might throw
        mConnectionFlags = connectionFlags;
    }
    mConnectionUseCount += 1 ;
}

总算找到SQLiteConnectionPool.acquireConnection了

// SQLiteConnectionPool中
public SQLiteConnection acquireConnection(String sql, int connectionFlags,
        CancellationSignal cancellationSignal) {
    return waitForConnection(sql, connectionFlags, cancellationSignal);
}

private SQLiteConnection waitForConnection(String sql, int connectionFlags,
        CancellationSignal cancellationSignal) {
    final boolean wantPrimaryConnection =   // 是否需要主连接，通过Flag得到
            (connectionFlags & CONNECTION_FLAG_PRIMARY_CONNECTION_AFFINITY) != 0 ;
    final ConnectionWaiter waiter;
    synchronized (mLock) {
        SQLiteConnection connection = null ;
        if (!wantPrimaryConnection) {  // 尝试获取非主连接
            connection = tryAcquireNonPrimaryConnectionLocked(
                    sql, connectionFlags);
        }
        if (connection == null ) {      //--- 尝试获取主连接
            connection = tryAcquirePrimaryConnectionLocked(connectionFlags);
        }
        if (connection != null ) {
            return connection;
        }

        // 若得不到连接，生成一个waiter
        final int priority = getPriority(connectionFlags);
        final long startTime = SystemClock.uptimeMillis();
        waiter = obtainConnectionWaiterLocked(Thread.currentThread(), startTime,
                priority, wantPrimaryConnection, sql, connectionFlags);
        // 根据优先级插入 队列
        ConnectionWaiter predecessor = null ;
        ConnectionWaiter successor = mConnectionWaiterQueue;
        while (successor != null ) {
            if (priority > successor.mPriority) {
                waiter.mNext = successor;
                break ;
            }
            predecessor = successor;
            successor = successor.mNext;
        }
        if (predecessor != null ) {
            predecessor.mNext = waiter;
        } else {
            mConnectionWaiterQueue = waiter;
        }

        nonce = waiter.mNonce;
    }
    ……
}

这里根据connectionFlags判定是否要获得主连接，如第2步分析数据库open时，就是主连接

private SQLiteConnection tryAcquirePrimaryConnectionLocked( int connectionFlags) {

    // 主连接可获取 直接返回
    SQLiteConnection connection = mAvailablePrimaryConnection;
    if (connection != null ) {
        mAvailablePrimaryConnection = null ;
        finishAcquireConnectionLocked(connection, connectionFlags);
        return connection;
    }

    // 主连接存在并且刚刚获取过,则返回空
    for (SQLiteConnection acquiredConnection : mAcquiredConnections.keySet()) {
        if (acquiredConnection.isPrimaryConnection()) {
            return null ;
        }
    }

    // 主连接不存在 新建 只可能在第一次访问时发生
    connection = openConnectionLocked(mConfiguration,
            true /*primaryConnection*/ );
    finishAcquireConnectionLocked(connection, connectionFlags);
    return connection;
}

其他时候，例如本节的update，将依靠statement的属性，由其一个成员变量mReadOnly来表示，实际由sql转换为stmt即prepare时确定。例如begin commit 命令将是false。

private SQLiteConnection tryAcquireNonPrimaryConnectionLocked(
        String sql, int connectionFlags) {
    // 尝试获取非主连接队列中的下一个连接
    SQLiteConnection connection;
    final int availableCount = mAvailableNonPrimaryConnections.size();
    if (availableCount > 1 && sql != null ) {
        // 如果sql!=null 优先使用缓存中含有相同sql语句的connection
        for ( int i = 0 ; i < availableCount; i++) {
            connection = mAvailableNonPrimaryConnections.get(i);
            if (connection.isPreparedStatementInCache(sql)) {
                mAvailableNonPrimaryConnections.remove(i);
                finishAcquireConnectionLocked(connection, connectionFlags); // might throw
                return connection;
            }
        }
    }
    if (availableCount > 0 ) {
        // 否则获取下一个连接，其实是pool最后一个
        connection = mAvailableNonPrimaryConnections.remove(availableCount - 1 );
        finishAcquireConnectionLocked(connection, connectionFlags); // might throw
        return connection;
    }

    //--- 若有需要即池中无连接时,扩展连接池，
    int openConnections = mAcquiredConnections.size();
    if (mAvailablePrimaryConnection != null ) {
        openConnections += 1 ;
    }
    if (openConnections >= mMaxConnectionPoolSize) {
        return null ;
    }
    connection = openConnectionLocked(mConfiguration,  // 新打开一个非主连接，真正连接到nativeOpen
            false /*primaryConnection*/ );
    finishAcquireConnectionLocked(connection, connectionFlags); // 会将新建立的connection放入mAcquiredConnections
    return connection;
}

那么mAvailableNonPrimaryConnections中的连接是怎么来的呢？
但凡使用acquireConnection后，必须使用releaseConnection

// SQLiteSession中
private void releaseConnection() {
    assert mConnection != null ;
    assert mConnectionUseCount > 0 ;
    if (--mConnectionUseCount == 0 ) {
        try {
            mConnectionPool.releaseConnection(mConnection); // might throw
        } finally {
            mConnection = null ;
        }
    }
}

// SQLiteConnectionPool中
public void releaseConnection(SQLiteConnection connection) {
    synchronized (mLock) {
        AcquiredConnectionStatus status = mAcquiredConnections.remove(connection);
        if (status == null ) {
            throw new IllegalStateException( "Cannot perform this operation "
                    + "because the specified connection was not acquired "
                    + "from this pool or has already been released." );
        }

        if (!mIsOpen) {
            closeConnectionAndLogExceptionsLocked(connection);
        } else if (connection.isPrimaryConnection()) {
            if (recycleConnectionLocked(connection, status)) {
                assert mAvailablePrimaryConnection == null ;
                mAvailablePrimaryConnection = connection;    // 放入主连接
            }
            wakeConnectionWaitersLocked();
        } else if (mAvailableNonPrimaryConnections.size() >= mMaxConnectionPoolSize - 1 ) {
            closeConnectionAndLogExceptionsLocked(connection);
        } else {
            if (recycleConnectionLocked(connection, status)) {
                mAvailableNonPrimaryConnections.add(connection); 放入非主连接
            }
            wakeConnectionWaitersLocked();
        }
    }
}

一个connection或者属于SQLiteConnectionPool或者属于SQLiteSession
SQLiteSession通过acquire从SQLiteConnectionPool获取connection，通过release将其返还。

4、总结

① Android SQLite中，多数操作需经过 SQLiteDatabase -> SQLiteSession -> SQLiteConnectionPool -> SQLiteConnection

② SQLiteOpenHelper类能够帮助实现一个实例里最多只有一个SQLiteDatabase对象，无论经过几次getReadableDatabase getWritableDatabase，是否经过了db.close()。

③ SQLiteDatabase.openDatabase的过程是构建SQLiteDatabase对象的过程，实质是构建SQLiteDatabase的成员变量SQLiteConnectionPool的过程，该过程是一个获取primaryConnection的过程。

④ 每个线程有自己的SQLiteSession且只有一个，每个SQLiteSession在某一时刻最多只有一个SQLiteConnection（需要时从连接池获取，用完返还），保证了一个线程在某一时刻只有一个SQLiteConnection连接到某一SQLiteDatabase。事务同样通过Session来实现，故线程之间的事务是独立的。

⑤ SQLiteConnectionPool掌管某个SQLiteDatabase的连接池。确保PrimaryConnection只有一个，如果空闲则将其返回，如果正被其他session使用则返回空，如果没有则新建。对于非PrimaryConnection，将会在连接池中优先选取stmt相同的，如果没有相同的获取池中最后一个，如果池子已经空了（此时多个线程同时用着多个连接），新建一个非主连接。

⑥ 具体关系如下