private void setMaxConnectionPoolSizeLocked() {        if (!mConfiguration.isInMemoryDb()                && (mConfiguration.openFlags & SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING) != 0) {            mMaxConnectionPoolSize = SQLiteGlobal.getWALConnectionPoolSize();<<=====关键步骤===        } else {            // We don't actually need to always restrict the connection pool size to 1            // for non-WAL databases.  There might be reasons to use connection pooling            // with other journal modes. However, we should always keep pool size of 1 for in-memory            // databases since every :memory: db is separate from another.            // For now, enabling connection pooling and using WAL are the same thing in the API.            mMaxConnectionPoolSize = 1;        }    }
        /**     * Gets the connection pool size when in WAL mode.     */    public static int getWALConnectionPoolSize() {        int value = SystemProperties.getInt("debug.sqlite.wal.poolsize",                Resources.getSystem().getInteger(                com.android.internal.R.integer.db_connection_pool_size));        return Math.max(2, value);    }    

    <!-- Maximum number of database connections opened and managed by framework layer         to handle queries on each database when using Write-Ahead Logging. -->    <integer name="db_connection_pool_size">4</integer>

int sqlite3PagerSharedLock(Pager *pPager){  int rc = SQLITE_OK;                /* Return code */
  /* This routine is only called from b-tree and only when there are no  ** outstanding pages. This implies that the pager state should either  ** be OPEN or READER. READER is only possible if the pager is or was in   ** exclusive access mode.  */  assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );  assert( assert_pager_state(pPager) );  assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );  assert( pPager->errCode==SQLITE_OK );
  if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){    int bHotJournal = 1;          /* True if there exists a hot journal-file */
    assert( !MEMDB );    assert( pPager->tempFile==0 || pPager->eLock==EXCLUSIVE_LOCK );
    rc = pager_wait_on_lock(pPager, SHARED_LOCK);    if( rc!=SQLITE_OK ){      assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );      goto failed;    }
    /* If a journal file exists, and there is no RESERVED lock on the    ** database file, then it either needs to be played back or deleted.    */    if( pPager->eLock<=SHARED_LOCK ){      rc = hasHotJournal(pPager, &bHotJournal);<<=========关键步骤=============    }    if( rc!=SQLITE_OK ){      goto failed;    }    if( bHotJournal ){      if( pPager->readOnly ){        rc = SQLITE_READONLY_ROLLBACK;        goto failed;      }
      /* Get an EXCLUSIVE lock on the database file. At this point it is      ** important that a RESERVED lock is not obtained on the way to the      ** EXCLUSIVE lock. If it were, another process might open the      ** database file, detect the RESERVED lock, and conclude that the      ** database is safe to read while this process is still rolling the       ** hot-journal back.*/
      ...
      if( isOpen(pPager->jfd) ){        assert( rc==SQLITE_OK );        rc = pagerSyncHotJournal(pPager); <<============关键步骤==============        if( rc==SQLITE_OK ){          rc = pager_playback(pPager, !pPager->tempFile);          pPager->eState = PAGER_OPEN;        }      }else if( !pPager->exclusiveMode ){

static int hasHotJournal(Pager *pPager, int *pExists){  sqlite3_vfs * const pVfs = pPager->pVfs;  int rc = SQLITE_OK;           /* Return code */  int exists = 1;               /* True if a journal file is present */  int jrnlOpen = !!isOpen(pPager->jfd);
  assert( pPager->useJournal );  assert( isOpen(pPager->fd) );  assert( pPager->eState==PAGER_OPEN );
  assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &    SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN  ));
  *pExists = 0;  if( !jrnlOpen ){    rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);  }  if( rc==SQLITE_OK && exists ){    int locked = 0;             /* True if some process holds a RESERVED lock */
    /* Race condition here:  Another process might have been holding the    ** the RESERVED lock and have a journal open at the sqlite3OsAccess()     ** call above, but then delete the journal and drop the lock before    ** we get to the following sqlite3OsCheckReservedLock() call.  If that    ** is the case, this routine might think there is a hot journal when    ** in fact there is none.  This results in a false-positive which will    ** be dealt with by the playback routine.  Ticket #3883.    */      rc = sqlite3OsCheckReservedLock(pPager->fd, &locked);    if( rc==SQLITE_OK && !locked ){      Pgno nPage;                 /* Number of pages in database file */
      assert( pPager->tempFile==0 );      rc = pagerPagecount(pPager, &nPage);      if( rc==SQLITE_OK ){        /* If the database is zero pages in size, that means that either (1) the        ** journal is a remnant from a prior database with the same name where        ** the database file but not the journal was deleted, or (2) the initial        ** transaction that populates a new database is being rolled back.        ** In either case, the journal file can be deleted.  However, take care        ** not to delete the journal file if it is already open due to        ** journal_mode=PERSIST.        */        if( nPage==0 && !jrnlOpen ){          sqlite3BeginBenignMalloc();          if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){            sqlite3OsDelete(pVfs, pPager->zJournal, 0);            if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);          }          sqlite3EndBenignMalloc();        }else{          /* The journal file exists and no other connection has a reserved          ** or greater lock on the database file. Now check that there is          ** at least one non-zero bytes at the start of the journal file.          ** If there is, then we consider this journal to be hot. If not,           ** it can be ignored.          */          if( !jrnlOpen ){            int f = SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL;            rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);          }          if( rc==SQLITE_OK ){            u8 first = 0;            rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);            if( rc==SQLITE_IOERR_SHORT_READ ){              rc = SQLITE_OK;            }            if( !jrnlOpen ){              sqlite3OsClose(pPager->jfd);            }            *pExists = (first!=0);          }else if( rc==SQLITE_CANTOPEN ){            /* If we cannot open the rollback journal file in order to see if            ** it has a zero header, that might be due to an I/O error, or            ** it might be due to the race condition described above and in            ** ticket #3883.  Either way, assume that the journal is hot.            ** This might be a false positive.  But if it is, then the            ** automatic journal playback and recovery mechanism will deal            ** with it under an EXCLUSIVE lock where we do not need to            ** worry so much with race conditions.            */            *pExists = 1;            rc = SQLITE_OK;          }        }      }    }  }
  return rc;}