2

I am developing an Android application where my SQLite database is inserted multiple times by Service and IntentService.

I start my Service right after application is started in MainActivity. My MainActivity has few tabs with fragments. One of the Fragments activates IntentService on its Resume. It means that my Service and IntentService may potentially run synchronously.

The data inserted by Service and IntentService could be the same. This situation may lead to duplication or Exception.

Can we assume that Service and IntentService can run on the same time and generate inconsistency in DataBase?

Kirk_hehe
  • 449
  • 7
  • 17
  • @Doe this isn't technically correct. Services do not run on threads. A `Service` is an instance of a class. The methods of a `Service` run on threads. Some methods of services run on the main thread, and some on worker (background) threads. You can also create services that manage their own background threads. An example to refute your statement is that `onCreate()` and `onStartCommand()` are called on an `IntentService` on the **main thread**. The only method that is provided in an `IntentService` that is **not** called on the **main thread** is `onHandleIntent()`. – David Wasser Jul 05 '17 at 19:46

1 Answers1

1

If you have a Service, then when startService() is called this results in a call to onStartCommand() which runs on the main (UI) Thread in the process.

In an IntentService, when startService() is called this results in a call to onHandleIntent() which is called on a worker thread.

Obviously there is a potential that both of these calls will happen in parallel.

There are many ways to deal with potential parallel execution. Here are a few examples:

  1. You can synchronize the database loading on a common object so that both threads cannot load the database at the same time. Each thread should check if the data has already been loaded before it loads to prevent duplicates.

  2. To load your database, you can submit a job to a queue (or submit a Runnable to a Handler, or something similar). You then have a separate thread that dequeues entries from the queue and runs them serially (one after another). In this case, if both your services submit jobs to the queue, one will run before the other one and they will not run in parallel. Also here you should make sure that you prevent duplicates by either checking if the data has already been loaded before loading it again, or by making sure that you only run one job in the queue.

  3. Create a table in your database that is used as a locking mechanism and has a column that indicates whether a load is in progress (this should be a primary key column that allows no duplicates). Before you start to the load the data, insert a row into the locking table. If there is a load in progress, this should fail with "duplicate key". If it is successful, load your data. When you are done, delete the row from the locking table.
David Wasser
  • 93,459
  • 16
  • 209
  • 274