Uso corretto di yieldIfContendedSafely() in un'applicazione Android con multithreading

Question

Nella mia applicazione, sto utilizzando uno AsyncTask per scrivere alcuni dati in un database in una transazione. È possibile accedere a questo database anche dal thread dell'interfaccia utente. Guardando attraverso i metodi di database disponibili, mi sono imbattuto in yieldIfContendedSafely(). Sembra che questo metodo dovrebbe essere utilizzato per tutti i casi in cui una transazione viene effettuata da un thread separato. Ma quasi nessun documento su questo metodo è diverso da quello seguente:

Termina temporaneamente la transazione per consentire l'esecuzione di altri thread. Si presume che la transazione abbia avuto esito positivo finora. Non chiamare setTransactionSuccessful prima di chiamare questo. Quando questo restituisce una nuova transazione sarà stata creata ma non contrassegnata come riuscita. Ciò presuppone che non vi siano transazioni nidificate (beginTransaction è stato chiamato una sola volta) e genererà un'eccezione se non è così.

Ecco come presumo che si può usare questo metodo a un filo:

 try { 
     db.beginTransaction(); 
     //insert some stuff into the database here 
     ... 



     // is this how you use this method? 
     boolean yielded = db.yieldIfContendedSafely(); 
     if (yielded) { 
      try { 
       Thread.sleep(500); 
      } catch (InterruptedException e) { 
       e.printStackTrace(); 
      } 
     } 



     db.setTransactionSuccessful(); 
    } catch (SQLException e) { 
     return false; 
    } finally { 
     db.endTransaction(); 
     db.close(); 
    } 

È questo il modo corretto di utilizzare questo metodo? Va bene usare db.yieldIfContendedSafely() più di una volta nella stessa transazione, tra più scritture su diverse tabelle nel database? Eventuali suggerimenti?

Answer 1

Tirare qualche esempio di codice dalle librerie Android sembra molto più più semplice da usare rispetto a quella ...

Questo è tratto da com.android.providers.calendar.SQLiteContentProvider.java

@Override 
public int bulkInsert(Uri uri, ContentValues[] values) { 
    int numValues = values.length; 
    mDb = mOpenHelper.getWritableDatabase(); 
    mDb.beginTransactionWithListener(this); 
    try { 
     for (int i = 0; i < numValues; i++) { 
      Uri result = insertInTransaction(uri, values[i]); 
      if (result != null) { 
       mNotifyChange = true; 
      } 
      mDb.yieldIfContendedSafely(); 
     } 
     mDb.setTransactionSuccessful(); 
    } finally { 
     mDb.endTransaction(); 
    } 

    onEndTransaction(); 
    return numValues; 
} 

Anche esaminando il codice sorgente per la funzione stessa, sembra che, se resa, la chiamata rinvierà l'esecuzione del thread per un breve periodo in ogni caso.