Index

A

abstractions, programming languages as, 3

accepting loader events (listing 4.18), 62

account type

definition (listing 7.6), 144

in sync-adapters, 143–144

Activities

in application model, 30–31

AsyncTask errors, 55–58

Services versus, 92–93

addOnFileDescriptorEventListener method, 86

administrative fields in Messages, 81–83

AIDL (Android Interface Definition Language), 120–123

AlarmManager, scheduling tasks with IntentService, 134–142

AlarmManagerService, 135–139

constraints on schedulable tasks, 139–142

AlarmManagerService, 135–139

Android applications. See applications

Android Interface Definition Language (AIDL), 120–123

Android model, web apps versus desktop apps, 67–68

Android Studio

Findbugs, 169–175

static analysis tools, 168–169

annotations, 177

JCIP annotations, 177–178

support library annotations, 178–179

applications

component lifecycles, 29–31, 33–34

creating processes, 123–125

definition, 30

main thread, 36

process priority, 31–33

restrictions on, 29

startup, 36–38

web applications versus, 35

assertions, 179–180

asynchronous execution

AsyncTasks. See AsyncTasks

with closures, 41–45

cursor loaders, 59–66

with loopers. See Looper/Handler framework

asynchronous messages, 87

AsyncTasks, 41

completion, 50–52

cursor loaders and, 59–66

doInBackground method, 45–48

errors

concurrency errors, 52–55

lifecycle errors, 55–58

execution, 48–49

as Services, 99–101

when to use

autonomous tasks, 59

cancellable tasks, 59

atomic execution, 5–6. See also synchronization

single-threaded UIs, 39

volatile keyword, 19

autonomous tasks, AsyncTasks as, 59

B

background execution. See asynchronous execution

best practices for concurrency, 180–181

Binders, 113, 125

data transfer limits, 126

process failure, reporting, 126

threads, 125

@BinderThread annotation, 178

binding

multiple Services, 107–108

Services, 105

bindService method, 104

bound Services, 95–96, 103–104

binding, 105

binding multiple Services, 107–108

flags, 111–112

local bound Services, 112–114

unbinding, 106–107

bulk inserts

initial example (listing 4.8), 51

interruptible (listing 4.9), 51–52

C

callbacks, futures versus, 26–27

cancelable tasks, AsyncTasks as, 59

canceling AsyncTasks, 50–52

cellular radio power management, 129–130

classes

Messenger, 116–119

Thread, 10–11

Timer, 130

TimerTask, 130

clock type in scheduling tasks, 136

Cloneable interface, 99

closures, 41–45

clustering tasks, 129–130

Collections.unmodifiable method, 54

communication. See inter-process communication (IPC)

completion of AsyncTasks, 50–52

components

lifecycles of, 29–31, 33–34

AsyncTask errors, 55–58

list of, 29–30

concurrency

AsyncTask errors, 52–55

atomic execution, 5–6

best practices, 180–181

difficulty of, 1

in hardware, 3–4

illusion of sequential execution, 6–7

sequential execution versus, 4

in software

functional programming languages, 2–3

languages as contracts, 3

procedural programming languages, 2

threads, 4–5. See also threads

Concurrency package, 23

content authority in sync-adapters, 143

content provider definition

listing 7.7, 144

listing 7.13, 152

ContentProvider, 143

contracts

binding Services, 105

maintaining sequential execution illusion, 6–7

programming languages as, 3

copy-on-write memory sharing, 36–38

createFromParcel method, 116

cross-task communication (listing 4.7), 49

cursor loaders, 59–66

custom service-based schedulers, 133

D

data transfer limits for Binders, 126

database query

with anonymous class (listing 4.4), 44

initial example (listing 4.1), 41–42

dataset change notification

initial example (listing 7.14), 154

for sync-adapters (listing 7.15), 155

deadlock, 16–17, 38–39

declaring Services (listing 6.1), 92

defining sync-adapters, 143–145

delayed animation

improved example (listing 5.2), 75–76

initial example (listing 5.1), 74

messaged example (listing 5.3), 79–80

dependency injection frameworks, 141

desktop applications versus web apps in Android model, 67–68

doInBackground method, 45–48, 100

E

effective immutability, 23

enqueueing Messages in Looper/Handler framework, 78

Enterprise Android (Mednieks, et al.), 143

epoll mechanism, 86

errors

in AsyncTasks

concurrency errors, 52–55

lifecycle errors, 55–58

in synchronization, 15–17

exclusion files, 177

execution

of AsyncTasks, 48–49

atomic execution. See atomic execution

executors

futures, 26–27

optimum number of threads, 25–26

explicit Intents, 96–97

F

fields in Messages, 81

administrative fields, 81–83

messaging fields, 83

remote fields, 84

Findbugs, 169

with Android Studio, 169–175

with Gradle, 175–177

“The First Draft Report on the EDVAC” (von Neumann), 1

flag field (Messages), 83

flags on bound Services, 111–112

flash memory, limitations, 29

functional programming languages, 2–3

functions, passing closures to (listing 4.3), 43

futures

callbacks versus, 26–27

definition, 26

G

garbage collection, process reaping versus, 34

Göetz, Brian, 9, 21

Gradle, 175–177

Grigorik, Ilya, 130

@GuardedBy annotation, 178

H

Handler framework. See Looper/Handler framework

hardware, concurrency in, 3–4

High Performance Browser Networking (Grigorik), 130

hints. See annotations

hybrid services, 93, 153

I

idealistic backgrounding (listing 4.2), 42

IllegalMonitorStateException (listing 2.13), 21

@Immutable annotation, 178

immutable data, sharing between threads, 23

implicit Intents, 97–98

initializing

loaders (listing 4.17), 61

threads as loopers, 84

inner class implementation (listing 4.15), 57

Inspections in Android Studio, 168–169

intent filters, 97

Intents, 96–99

in application model, 30–31

explicit Intents, 96–97

implicit Intents, 97–98

IntentService, 99–103

scheduling tasks with AlarmManager, 134–142

AlarmManagerService, 135–139

constraints on schedulable tasks, 139–142

interfaces

Cloneable, 99

Parcelable, 99, 116

Runnable, 11, 73–77

Serializable, 99

inter-process communication (IPC), 114–115

AIDL, 120–123

Messenger class, 116–119

optimizing, 112–114

Parcelable interface, 116

interruptions, 21

bulk inserts, 51–52

flag state, 51

to started Services, 94–95

IPC (inter-process communication). See inter-process communication (IPC)

isCancelled method, 50–52

isIdle method, 86

J

Java Concurrency in Practice (Göetz and Peierls, et al), 9, 23, 177–178

JCIP annotations, 177–178

JobSchedule Service (listing 7.16), 156

JobScheduler, 155–165

implementing tasks, 161–165

running tasks, 159–161

scoring, 165

K

keywords

synchronized, 12, 14–15

this, 13

volatile, 17–20

killing processes, 33

L

LARGE_TASK_EXECUTOR, 49

lifecycle awareness in task scheduling, 128

lifecycles

AsyncTask errors, 55–58

of components, 29–31, 33–34

process priority, 31–33

of Services, 109–111

linkToDeath method, 126

listings

accepting loader events, 62

account type definition, 144

AIDL definition, 120

AIDL-generated code, 120–122

Alarm Scheduler task execution, 140

Android support annotations, 179

AsyncTask Service, 100

AsyncTasks

concurrency errors, 52, 53, 54

execution, 48

initial example, 46

lifecycle errors, 56

local copies of mutable data structures, 54–55

binding multiple Services to single Context, 108

bound Service client, 103–104

bulk inserts

initial example, 51

interruptible, 51–52

content provider definition, 144, 152

cursor loaders

complete, 65–66

creating, 63

database query

with anonymous class, 44

initial example, 41–42

dataset change notification

initial example, 154

for sync-adapters, 155

deadlock, 17

declaring Services, 92

delayed animation

improved example, 75–76

initial example, 74

messaged example, 79–80

explicit Intents, 96–97

Findbugs

failure example, 174–175

filter, 177

in Gradle, 176

successful example, 173

idealistic backgrounding, 42

IllegalMonitorStateException, 21

incorrect cross-task communication, 49

incorrect synchronization (single thread), 17–18

incorrect volatile usage, 20

initializing loaders, 61

inner class implementation, 57

IntentFilter, 97

IntentService helper method, 102–103

JobSchedule Service, 156

JobScheduler tasks

implementing, 161–163

scheduling, 157–158

local Service, 112–113

local Service client, 113

looper creation

with handler, 85

initial example, 84

without race condition, 85

low-power periodic scheduling with AlarmManager, 137–138

managed object implementation, 122–123

manifest for low-power scheduler, 138

message enqueueing, 82

Messenger Service, 118–119

Messenger usage, 117–118

minimal bound Service, 109

mutex errors, 16

passing closures to functions, 43

periodic Looper task, 131–132

periodic scheduling with AlarmManager, 134

reentrant monitors, 15

remote managed object usage, 123

safe publication, 24–25

Service injection, 114

simple account creation, 150–151

singleton bound Service, 111

skeleton Android application, 67

skeleton cursor list activity, 60

skeleton Java application, 67

spawning threads, 10

specifying component’s process, 124, 125

sync-adapter service

complete service, 148

implementation, 148–149

initial example, 145

sync-adapters

definition, 143

implementation, 149–150

synchronized methods, 14

synchronized static methods, 14–15

synchronizing on objects, 12

synchronizing on this, 13

threads with Runnable, 11

volatile keyword, 19

wait and notify methods, 22

loaders, 59–66

local bound Services, 112–114

local processes, 124

locks, definition, 12. See also mutexes

loop method, 71

Looper/Handler framework, 69–71

Java classes in, 71

main thread as looper, 38–39, 74

Messages

administrative fields, 81–83

enqueueing, 78

fields in, 81

messaging fields, 83

remote fields, 84

method overloading, 78–80

native Looper, 86

Runnable interface, posting, 73–77

safe publication, 69–70

scheduling tasks, 130–133

starting loopers, 84–86

sync-barriers, 87–88

task execution example, 71–73

M

main thread, 9, 36

as looper, 38–39, 74

@MainThread annotation, 178

marshaling, 99

McCarthy, John, 2–3

McLuhan, Marshall, 167

memory leaks, 80

memory model, 7

copy-on-write memory sharing, 36–38

MessageQueue, 70

native Looper, 86

sync-barriers, 87–88

task execution example, 71–73

MessageQueue.addOnFileDescriptorEventListener method, 86

MessageQueue.isIdle method, 86

MessageQueue.postSyncBarrier method, 87

MessageQueue.removeOnFileDescriptorEventListener method, 86

MessageQueue.removeSyncBarrier method, 88

Messages

enqueueing in Looper/Handler framework, 78

fields in, 81

administrative fields, 81–83

messaging fields, 83

remote fields, 84

method overloading and, 78–80

Message.setAsynchronous method, 87

messaging fields in Messages, 83

Messenger class, 116–119

methods

addOnFileDescriptorEventListener, 86

bindService, 104

createFromParcel, 116

doInBackground, 45–48, 100

isCancelled, 50–52

isIdle, 86

linkToDeath, 126

loop, 71

notify, 22–23

notifyAll, 22–23

onBind, 95, 104, 105

onCancelled, 50

onConnected, 95

onCreate, 74

onHandleIntent, 101

onPause, 76–77

onPostExecute, 47, 50

onProgressUpdate, 47

onServiceConnected, 105

onStartCommand, 93–95, 100–101

overloading, 78–80

postSyncBarrier, 87

publishProgress, 47

removeOnFileDescriptorEventListener, 86

removeSyncBarrier, 88

run, 76–77

setAsynchronous, 87

stopSelf, 101

stopService, 101

synchronized, 14–15

unbindService, 104, 106–107

unmodifiable, 54

wait, 20–21

writeToParcel, 116

minimal bound Service (listing 6.10), 109

model-view-controller (MVC) pattern, deadlock, 38–39

monitors. See also mutexes

definition, 12

reentrant monitors, 15

Moore’s law, 2–3

multiple Services, binding, 107–108

Murphy, Mark, 59

mutable data

local copies of, 54

sharing between threads, 23–25

mutating state, 2

mutexes, 6

definition, 12

errors in, 15–16

example usage, 12–13

reentrant monitors, 15

synchronized methods, 14–15

this keyword, 13

wait method, 20–21

MVC (model-view-controller) pattern, deadlock, 38–39

N

native Looper, 86

notify method, 22–23

notifyAll method, 22–23

@NotThreadSafe annotation, 178

O

onBind method, 95, 104, 105

onCancelled method, 50

onConnected method, 95

onCreate method, 74

onHandleIntent method, 101

onPause method, 76–77

onPostExecute method, 47, 50

onProgressUpdate method, 47

onServiceConnected method, 105

onStartCommand method, 93–95, 100–101

oom_adj attribute, 31–32

oom_score_adj attribute, 32

opportunistic suspension, 129

optimizing IPC (inter-process communication), 112–114

optimum number of threads, 25–26

overloading methods, 78–80

P

packages, Concurrency, 23

Parcelable interface, 99, 116

passing closures to functions (listing 4.3), 43

PendingIntents, 135

periodic tasks. See scheduling tasks

posting Runnable interface in Looper/Handler framework, 73–77

postSyncBarrier method, 87

power usage in task scheduling, 129–130

priority of processes. See process priority

procedural programming languages, 2

process priority, 31–33

flags on bound Services, 111–112

for Services, 93

in task scheduling, 128–129

process reaping, garbage collection versus, 34

processes

creating, 123–125

inter-process communication (IPC), 114–115

AIDL, 120–123

Messenger class, 116–119

optimizing, 112–114

Parcelable interface, 116

local, 124

remote, 124

reporting failure, 126

terminating, 33

programming languages

as contracts, 3

functional, 2–3

illusion of sequential execution, 6–7

procedural, 2

proxies, 115

publishProgress method, 47

R

race conditions, 13, 77

Receivers in application model, 30–31

reentrant monitors, 15

remote fields in Messages, 84

remote processes, 124

removeOnFileDescriptorEventListener method, 86

removeSyncBarrier method, 88

run method, 10, 76–77

Runnable interface, 11, 73–77

running

JobScheduler tasks, 159–161

sync-adapters, 145–147, 153–154

runtime concurrency checks, 179–180

S

safe publication, 23–25, 69–70

scheduling tasks

AlarmManager and IntentService, 134–142

AlarmManagerService, 135–139

constraints on schedulable tasks, 139–142

characteristics of, 127–128

lifecycle awareness, 128

power usage, 129–130

process priority, 128–129

scorecard for, 130

thread safety, 128

custom service-based schedulers, 133

JobScheduler, 155–165

implementing tasks, 161–165

running tasks, 159–161

scoring, 165

Looper/Handler framework, 130–133

sync-adapters, 142–155

defining, 143–145

implementing, 147–152

running, 145–147, 153–154

scoring, 152–155

sync-barriers and, 87–88

Timer and TimerTask classes, 130

scheduling window size in scheduling tasks, 136

scorecard (task scheduling characteristics), 130

AlarmManager and IntentService, 141

custom service-based schedulers, 133

JobScheduler, 165

Looper/Handler framework, 132

sync-adapters, 155

Timer and TimerTask classes, 130

sequential execution

concurrency versus, 4

hardware versus software, 3–4

illusion of, 6–7

SERIAL_EXECUTOR, 48

Serializable interface, 99

Service injection (listing 6.14), 114

Services

Activities versus, 92–93

AlarmManagerService, 135–139

AsyncTasks as, 99–101

bound Services, 95–96, 103–104

binding, 105

binding multiple Services, 107–108

flags, 111–112

local bound Services, 112–114

unbinding, 106–107

custom service-based schedulers, 133

hybrid services, 93, 153

Intents, 96–99

explicit Intents, 96–97

implicit Intents, 97–98

IntentService, 99–103

scheduling tasks with AlarmManager, 134–142

JobSchedule Service (listing 7.16), 156

lifecycle of, 109–111

process failure, reporting, 126

process priority, 32

started Services, 93–95

when to use, 91

setAsynchronous method, 87

sharing

data between threads, 23–25

memory, 36–38

single-threaded UIs, 38–39

singleton bound Service (listing 6.11), 111

singletons, 106

software, concurrency in

functional programming languages, 2–3

languages as contracts, 3

procedural programming languages, 2

spawning threads (listing 2.1), 10

start method, Thread class, 10

started Services, 93–95

starting

applications, 36–38

loopers, 84–86

starving threads, 19

static analysis tools, 167–168

Android Studio, 168–169

Findbugs, 169

with Android Studio, 169–175

with Gradle, 175–177

static methods, 14–15

stopSelf method, 101

stopService method, 101

stubs, 115

support library annotations, 178–179

switched messages, 83

sync-adapters, 142–155

defining, 143–145

implementing, 147–152

running, 145–147, 153–154

scoring, 152–155

sync-barriers, 87–88

synchronization, 6, 11

errors, 15–17

mutexes

definition, 12

example usage, 12–13

reentrant monitors, 15

synchronized methods, 14–15

this keyword, 13

notify and notifyAll methods, 22–23

volatile keyword, 17–20

wait method, 20–21

synchronized keyword, 12, 14–15

T

target field (Messages), 82

task clustering, 129–130

task scheduling. See scheduling tasks

terminating processes, 33

this keyword, 13

Thread class, 10–11

thread safety in task scheduling, 128

THREAD_POOL_EXECUTOR, 48–49

threads, 4–5

asynchronous execution with closures, 41–45

atomic execution, 5–6

Binder threads, 125

executors

futures, 26–27

optimum number of threads, 25–26

initializing as loopers, 84

interruptions, 51

main thread, 9, 36

as looper, 38–39, 74

Runnable interface, 11

sharing data, safe publication, 23–25

synchronization, 11

errors, 15–17

mutex usage, 12–13

notify and notifyAll methods, 22–23

reentrant monitors, 15

synchronized methods, 14–15

this keyword, 13

volatile keyword, 17–20

wait method, 20–21

Thread class, 10–11

@ThreadSafe annotation, 178

timed-wait, 86

Timer class, 130

TimerTask class, 130

tools

annotations, 177

JCIP annotations, 177–178

support library annotations, 178–179

assertions, 179–180

static analysis, 167–168

Android Studio, 168–169

Findbugs, 169–177

type-safe templates, 45

U

UI thread, 9, 36

as looper, 38–39, 74

@UIThread annotation, 178

unbinding Services, 106–107

unbindService method, 104, 106–107

unmarshaling, 99

unmodifiable method, 54

Updike, John, 41

V

varargs, 47

visibility, 17–20

volatile keyword, 17–20

von Neumann, John, 1

W

wait method, 20–21

wake-locks, 129, 137, 138–139

weak references, 57–58

web applications

Android applications versus, 35

in Android model, 67–68

when field (Messages), 82

Whyte, William H., 127

@WorkerThread annotation, 178

writeToParcel method, 116

Y

Yegge, Steve, 106

Z

Zygote, 36–38