Sto lavorando con un database SQLite su Android. Il mio gestore di database è un singleton e in questo momento apre una connessione al database quando viene inizializzato. È sicuro lasciare il database aperto tutto il tempo in modo che quando qualcuno chiama la mia classe per lavorare con il database è già aperto? O devo aprire e chiudere il database prima e dopo ogni accesso è necessario. C'è qualcosa di male nel lasciarlo aperto tutto il tempo?
Grazie!
Risposte:
Lo terrei aperto per tutto il tempo e lo chiuderò con un metodo del ciclo di vita come onStopo onDestroy. in questo modo, puoi facilmente verificare se il database è già in uso chiamando isDbLockedByCurrentThreado isDbLockedByOtherThreadssul singolo SQLiteDatabaseoggetto ogni volta prima di utilizzarlo. ciò impedirà più manipolazioni al database e salverà l'applicazione da un potenziale arresto anomalo
quindi nel tuo singleton, potresti avere un metodo come questo per ottenere il tuo singolo SQLiteOpenHelperoggetto:
private SQLiteDatabase db;
private MyDBOpenHelper mySingletonHelperField;
public MyDBOpenHelper getDbHelper() {
db = mySingletonHelperField.getDatabase();//returns the already created database object in my MyDBOpenHelper class(which extends `SQLiteOpenHelper`)
while(db.isDbLockedByCurrentThread() || db.isDbLockedByOtherThreads()) {
//db is locked, keep looping
}
return mySingletonHelperField;
}
quindi ogni volta che vuoi usare il tuo oggetto helper aperto, chiama questo metodo getter (assicurati che sia filettato)
un altro metodo nel tuo singleton potrebbe essere (chiamato OGNI VOLTA prima di provare a chiamare il getter sopra):
public void setDbHelper(MyDBOpenHelper mySingletonHelperField) {
if(null == this.mySingletonHelperField) {
this.mySingletonHelperField = mySingletonHelperField;
this.mySingletonHelperField.setDb(this.mySingletonHelperField.getWritableDatabase());//creates and sets the database object in the MyDBOpenHelper class
}
}
potresti anche voler chiudere il database nel singleton:
public void finalize() throws Throwable {
if(null != mySingletonHelperField)
mySingletonHelperField.close();
if(null != db)
db.close();
super.finalize();
}
se gli utenti della tua applicazione hanno la capacità di creare molte interazioni con il database molto rapidamente, dovresti usare qualcosa come ho dimostrato sopra. ma se ci sono interazioni con il database minime, non me ne preoccuperei e creo e chiudi il database ogni volta.
A partire da ora non è necessario verificare se il database è bloccato da un altro thread. Mentre usi singleton SQLiteOpenHelper in ogni thread sei al sicuro. Dalla isDbLockedByCurrentThreaddocumentazione:
Il nome di questo metodo deriva da un momento in cui avere una connessione attiva al database significava che il thread deteneva un blocco effettivo sul database. Al giorno d'oggi, non esiste più un vero "blocco del database" sebbene i thread possano bloccarsi se non possono acquisire una connessione al database per eseguire una particolare operazione.
isDbLockedByOtherThreads è deprecato dal livello API 16.
Per quanto riguarda le domande:
Il mio gestore di database è un singleton e in questo momento apre una connessione al database quando viene inizializzato.
Dovremmo dividere "apertura DB", "apertura di una connessione". SQLiteOpenHelper.getWritableDatabase () fornisce un DB aperto. Ma non dobbiamo controllare le connessioni poiché avviene internamente.
È sicuro lasciare il database aperto tutto il tempo in modo che quando qualcuno chiama la mia classe per lavorare con il database è già aperto?
Sì. Le connessioni non si bloccano se le transazioni vengono chiuse correttamente. Tieni presente che il tuo DB verrà chiuso automaticamente anche se GC lo finalizza.
O devo aprire e chiudere il database prima e dopo ogni accesso è necessario.
La chiusura dell'istanza di SQLiteDatabase non dà nulla di eccezionale tranne la chiusura delle connessioni, ma questo è un problema per lo sviluppatore se ci sono alcune connessioni in questo momento. Inoltre, dopo SQLiteDatabase.close (), SQLiteOpenHelper.getWritableDatabase () restituirà una nuova istanza.
C'è qualcosa di male nel lasciarlo aperto tutto il tempo?
No, non c'è. Si noti inoltre che la chiusura del DB in un momento e thread non correlati, ad esempio in Activity.onStop (), potrebbe chiudere le connessioni attive e lasciare i dati in uno stato incoerente.
Android 8.1 ha un SQLiteOpenHelper.setIdleConnectionTimeout(long)metodo che:
Imposta il numero massimo di millisecondi in cui la connessione SQLite può rimanere inattiva prima che venga chiusa e rimossa dal pool.
Dal punto di vista delle prestazioni, il modo ottimale è mantenere una singola istanza di SQLiteOpenHelper a livello di applicazione. L'apertura del database può essere costosa ed è un'operazione di blocco, quindi non dovrebbe essere eseguita sul thread principale e / o nei metodi del ciclo di vita dell'attività.
Il metodo setIdleConnectionTimeout () (introdotto in Android 8.1) può essere utilizzato per liberare RAM quando il database non viene utilizzato. Se è impostato il timeout di inattività, le connessioni al database verranno chiuse dopo un periodo di inattività, ovvero quando non è stato effettuato l'accesso al database. Le connessioni verranno riaperte in modo trasparente all'app, quando viene eseguita una nuova query.
In aggiunta a ciò, un'app può chiamare releaseMemory () quando passa in background o rileva la pressione della memoria, ad esempio in onTrimMemory ()
Puoi anche utilizzare ContentProvider. Farà queste cose per te.
Crea il tuo contesto dell'applicazione, quindi apri e chiudi il database da lì. Quell'oggetto ha anche un metodo OnTerminate () che potresti usare per chiudere la connessione. Non l'ho ancora provato ma mi sembra un approccio migliore.
@binnyb: non mi piace usare finalize () per chiudere la connessione. Potrebbe funzionare, ma da quello che ho capito scrivere codice in un metodo Java finalize () è una cattiva idea.
onTerminatenon verrà chiamato in un ambiente di produzione - developer.android.com/reference/android/app/…