1page.title=Processes and Threads 2@jd:body 3 4<div id="qv-wrapper"> 5<div id="qv"> 6<h2>Quickview</h2> 7<ul> 8 <li>Every application runs in its own process and all components of the application run in that 9process, by default</li> 10 <li>Any slow, blocking operations in an activity should be done in a new thread, to avoid slowing 11down the user interface</li> 12</ul> 13 14<h2>In this document</h2> 15<ol> 16<li><a href="#Processes">Processes</a> 17 <ol> 18 <li><a href="#Lifecycle">Process lifecycle</a></li> 19 </ol> 20</li> 21<li><a href="#Threads">Threads</a> 22 <ol> 23 <li><a href="#WorkerThreads">Worker threads</a></li> 24 <li><a href="#ThreadSafe">Thread-safe methods</a></li> 25 </ol> 26</li> 27<li><a href="#IPC">Interprocess Communication</a></li> 28</ol> 29 30</div> 31</div> 32 33<p>When an application component starts and the application does not have any other components 34running, the Android system starts a new Linux process for the application with a single thread of 35execution. By default, all components of the same application run in the same process and thread 36(called the "main" thread). If an application component starts and there already exists a process 37for that application (because another component from the application exists), then the component is 38started within that process and uses the same thread of execution. However, you can arrange for 39different components in your application to run in separate processes, and you can create additional 40threads for any process.</p> 41 42<p>This document discusses how processes and threads work in an Android application.</p> 43 44 45<h2 id="Processes">Processes</h2> 46 47<p>By default, all components of the same application run in the same process and most applications 48should not change this. However, if you find that you need to control which process a certain 49component belongs to, you can do so in the manifest file.</p> 50 51<p>The manifest entry for each type of component element—<a 52href="{@docRoot}guide/topics/manifest/activity-element.html">{@code 53<activity>}</a>, <a href="{@docRoot}guide/topics/manifest/service-element.html">{@code 54<service>}</a>, <a href="{@docRoot}guide/topics/manifest/receiver-element.html">{@code 55<receiver>}</a>, and <a href="{@docRoot}guide/topics/manifest/provider-element.html">{@code 56<provider>}</a>—supports an {@code android:process} attribute that can specify a 57process in which that component should run. You can set this attribute so that each component runs 58in its own process or so that some components share a process while others do not. You can also set 59{@code android:process} so that components of different applications run in the same 60process—provided that the applications share the same Linux user ID and are signed with the 61same certificates.</p> 62 63<p>The <a href="{@docRoot}guide/topics/manifest/application-element.html">{@code 64<application>}</a> element also supports an {@code android:process} attribute, to set a 65default value that applies to all components.</p> 66 67<p>Android might decide to shut down a process at some point, when memory is low and required by 68other processes that are more immediately serving the user. Application 69components running in the process that's killed are consequently destroyed. A process is started 70again for those components when there's again work for them to do.</p> 71 72<p>When deciding which processes to kill, the Android system weighs their relative importance to 73the user. For example, it more readily shuts down a process hosting activities that are no longer 74visible on screen, compared to a process hosting visible activities. The decision whether to 75terminate a process, therefore, depends on the state of the components running in that process. The 76rules used to decide which processes to terminate is discussed below. </p> 77 78 79<h3 id="Lifecycle">Process lifecycle</h3> 80 81<p>The Android system tries to maintain an application process for as long as possible, but 82eventually needs to remove old processes to reclaim memory for new or more important processes. To 83determine which processes to keep 84and which to kill, the system places each process into an "importance hierarchy" based on the 85components running in the process and the state of those components. Processes with the lowest 86importance are eliminated first, then those with the next lowest importance, and so on, as necessary 87to recover system resources.</p> 88 89<p>There are five levels in the importance hierarchy. The following list presents the different 90types of processes in order of importance (the first process is <em>most important</em> and is 91<em>killed last</em>):</p> 92 93<ol> 94 <li><b>Foreground process</b> 95 <p>A process that is required for what the user is currently doing. A 96 process is considered to be in the foreground if any of the following conditions are true:</p> 97 98 <ul> 99 <li>It hosts an {@link android.app.Activity} that the user is interacting with (the {@link 100android.app.Activity}'s {@link android.app.Activity#onResume onResume()} method has been 101called).</li> 102 103 <li>It hosts a {@link android.app.Service} that's bound to the activity that the user is 104interacting with.</li> 105 106 <li>It hosts a {@link android.app.Service} that's running "in the foreground"—the 107service has called {@link android.app.Service#startForeground startForeground()}. 108 109 <li>It hosts a {@link android.app.Service} that's executing one of its lifecycle 110callbacks ({@link android.app.Service#onCreate onCreate()}, {@link android.app.Service#onStart 111onStart()}, or {@link android.app.Service#onDestroy onDestroy()}).</li> 112 113 <li>It hosts a {@link android.content.BroadcastReceiver} that's executing its {@link 114 android.content.BroadcastReceiver#onReceive onReceive()} method.</li> 115 </ul> 116 117 <p>Generally, only a few foreground processes exist at any given time. They are killed only as 118a last resort—if memory is so low that they cannot all continue to run. Generally, at that 119point, the device has reached a memory paging state, so killing some foreground processes is 120required to keep the user interface responsive.</p></li> 121 122 <li><b>Visible process</b> 123 <p>A process that doesn't have any foreground components, but still can 124 affect what the user sees on screen. A process is considered to be visible if either of the 125 following conditions are true:</p> 126 127 <ul> 128 <li>It hosts an {@link android.app.Activity} that is not in the foreground, but is still 129visible to the user (its {@link android.app.Activity#onPause onPause()} method has been called). 130This might occur, for example, if the foreground activity started a dialog, which allows the 131previous activity to be seen behind it.</li> 132 133 <li>It hosts a {@link android.app.Service} that's bound to a visible (or foreground) 134activity.</li> 135 </ul> 136 137 <p>A visible process is considered extremely important and will not be killed unless doing so 138is required to keep all foreground processes running. </p> 139 </li> 140 141 <li><b>Service process</b> 142 <p>A process that is running a service that has been started with the {@link 143android.content.Context#startService startService()} method and does not fall into either of the two 144higher categories. Although service processes are not directly tied to anything the user sees, they 145are generally doing things that the user cares about (such as playing music in the background or 146downloading data on the network), so the system keeps them running unless there's not enough memory 147to retain them along with all foreground and visible processes. </p> 148 </li> 149 150 <li><b>Background process</b> 151 <p>A process holding an activity that's not currently visible to the user (the activity's 152{@link android.app.Activity#onStop onStop()} method has been called). These processes have no direct 153impact on the user experience, and the system can kill them at any time to reclaim memory for a 154foreground, 155visible, or service process. Usually there are many background processes running, so they are kept 156in an LRU (least recently used) list to ensure that the process with the activity that was most 157recently seen by the user is the last to be killed. If an activity implements its lifecycle methods 158correctly, and saves its current state, killing its process will not have a visible effect on 159the user experience, because when the user navigates back to the activity, the activity restores 160all of its visible state. See the <a 161href="{@docRoot}guide/components/activities.html#SavingActivityState">Activities</a> 162document for information about saving and restoring state.</p> 163 </li> 164 165 <li><b>Empty process</b> 166 <p>A process that doesn't hold any active application components. The only reason to keep this 167kind of process alive is for caching purposes, to improve startup time the next time a component 168needs to run in it. The system often kills these processes in order to balance overall system 169resources between process caches and the underlying kernel caches.</p> 170 </li> 171</ol> 172 173 174 <p>Android ranks a process at the highest level it can, based upon the importance of the 175components currently active in the process. For example, if a process hosts a service and a visible 176activity, the process is ranked as a visible process, not a service process.</p> 177 178 <p>In addition, a process's ranking might be increased because other processes are dependent on 179it—a process that is serving another process can never be ranked lower than the process it is 180serving. For example, if a content provider in process A is serving a client in process B, or if a 181service in process A is bound to a component in process B, process A is always considered at least 182as important as process B.</p> 183 184 <p>Because a process running a service is ranked higher than a process with background activities, 185an activity that initiates a long-running operation might do well to start a <a 186href="{@docRoot}guide/components/services.html">service</a> for that operation, rather than 187simply create a worker thread—particularly if the operation will likely outlast the activity. 188For example, an activity that's uploading a picture to a web site should start a service to perform 189the upload so that the upload can continue in the background even if the user leaves the activity. 190Using a service guarantees that the operation will have at least "service process" priority, 191regardless of what happens to the activity. This is the same reason that broadcast receivers should 192employ services rather than simply put time-consuming operations in a thread.</p> 193 194 195 196 197<h2 id="Threads">Threads</h2> 198 199<p>When an application is launched, the system creates a thread of execution for the application, 200called "main." This thread is very important because it is in charge of dispatching events to 201the appropriate user interface widgets, including drawing events. It is also the thread in which 202your application interacts with components from the Android UI toolkit (components from the {@link 203android.widget} and {@link android.view} packages). As such, the main thread is also sometimes 204called the UI thread.</p> 205 206<p>The system does <em>not</em> create a separate thread for each instance of a component. All 207components that run in the same process are instantiated in the UI thread, and system calls to 208each component are dispatched from that thread. Consequently, methods that respond to system 209callbacks (such as {@link android.view.View#onKeyDown onKeyDown()} to report user actions 210or a lifecycle callback method) always run in the UI thread of the process.</p> 211 212<p>For instance, when the user touches a button on the screen, your app's UI thread dispatches the 213touch event to the widget, which in turn sets its pressed state and posts an invalidate request to 214the event queue. The UI thread dequeues the request and notifies the widget that it should redraw 215itself.</p> 216 217<p>When your app performs intensive work in response to user interaction, this single thread model 218can yield poor performance unless you implement your application properly. Specifically, if 219everything is happening in the UI thread, performing long operations such as network access or 220database queries will block the whole UI. When the thread is blocked, no events can be dispatched, 221including drawing events. From the user's perspective, the 222application appears to hang. Even worse, if the UI thread is blocked for more than a few seconds 223(about 5 seconds currently) the user is presented with the infamous "<a 224href="http://developer.android.com/guide/practices/responsiveness.html">application not 225responding</a>" (ANR) dialog. The user might then decide to quit your application and uninstall it 226if they are unhappy.</p> 227 228<p>Additionally, the Andoid UI toolkit is <em>not</em> thread-safe. So, you must not manipulate 229your UI from a worker thread—you must do all manipulation to your user interface from the UI 230thread. Thus, there are simply two rules to Android's single thread model:</p> 231 232<ol> 233<li>Do not block the UI thread 234<li>Do not access the Android UI toolkit from outside the UI thread 235</ol> 236 237<h3 id="WorkerThreads">Worker threads</h3> 238 239<p>Because of the single thread model described above, it's vital to the responsiveness of your 240application's UI that you do not block the UI thread. If you have operations to perform 241that are not instantaneous, you should make sure to do them in separate threads ("background" or 242"worker" threads).</p> 243 244<p>For example, below is some code for a click listener that downloads an image from a separate 245thread and displays it in an {@link android.widget.ImageView}:</p> 246 247<pre> 248public void onClick(View v) { 249 new Thread(new Runnable() { 250 public void run() { 251 Bitmap b = loadImageFromNetwork("http://example.com/image.png"); 252 mImageView.setImageBitmap(b); 253 } 254 }).start(); 255} 256</pre> 257 258<p>At first, this seems to work fine, because it creates a new thread to handle the network 259operation. However, it violates the second rule of the single-threaded model: <em>do not access the 260Android UI toolkit from outside the UI thread</em>—this sample modifies the {@link 261android.widget.ImageView} from the worker thread instead of the UI thread. This can result in 262undefined and unexpected behavior, which can be difficult and time-consuming to track down.</p> 263 264<p>To fix this problem, Android offers several ways to access the UI thread from other 265threads. Here is a list of methods that can help:</p> 266 267<ul> 268<li>{@link android.app.Activity#runOnUiThread(java.lang.Runnable) 269Activity.runOnUiThread(Runnable)}</li> 270<li>{@link android.view.View#post(java.lang.Runnable) View.post(Runnable)}</li> 271<li>{@link android.view.View#postDelayed(java.lang.Runnable, long) View.postDelayed(Runnable, 272long)}</li> 273</ul> 274 275<p>For example, you can fix the above code by using the {@link 276android.view.View#post(java.lang.Runnable) View.post(Runnable)} method:</p> 277 278<pre> 279public void onClick(View v) { 280 new Thread(new Runnable() { 281 public void run() { 282 final Bitmap bitmap = loadImageFromNetwork("http://example.com/image.png"); 283 mImageView.post(new Runnable() { 284 public void run() { 285 mImageView.setImageBitmap(bitmap); 286 } 287 }); 288 } 289 }).start(); 290} 291</pre> 292 293<p>Now this implementation is thread-safe: the network operation is done from a separate thread 294while the {@link android.widget.ImageView} is manipulated from the UI thread.</p> 295 296<p>However, as the complexity of the operation grows, this kind of code can get complicated and 297difficult to maintain. To handle more complex interactions with a worker thread, you might consider 298using a {@link android.os.Handler} in your worker thread, to process messages delivered from the UI 299thread. Perhaps the best solution, though, is to extend the {@link android.os.AsyncTask} class, 300which simplifies the execution of worker thread tasks that need to interact with the UI.</p> 301 302 303<h4 id="AsyncTask">Using AsyncTask</h4> 304 305<p>{@link android.os.AsyncTask} allows you to perform asynchronous work on your user 306interface. It performs the blocking operations in a worker thread and then publishes the results on 307the UI thread, without requiring you to handle threads and/or handlers yourself.</p> 308 309<p>To use it, you must subclass {@link android.os.AsyncTask} and implement the {@link 310android.os.AsyncTask#doInBackground doInBackground()} callback method, which runs in a pool of 311background threads. To update your UI, you should implement {@link 312android.os.AsyncTask#onPostExecute onPostExecute()}, which delivers the result from {@link 313android.os.AsyncTask#doInBackground doInBackground()} and runs in the UI thread, so you can safely 314update your UI. You can then run the task by calling {@link android.os.AsyncTask#execute execute()} 315from the UI thread.</p> 316 317<p>For example, you can implement the previous example using {@link android.os.AsyncTask} this 318way:</p> 319 320<pre> 321public void onClick(View v) { 322 new DownloadImageTask().execute("http://example.com/image.png"); 323} 324 325private class DownloadImageTask extends AsyncTask<String, Void, Bitmap> { 326 /** The system calls this to perform work in a worker thread and 327 * delivers it the parameters given to AsyncTask.execute() */ 328 protected Bitmap doInBackground(String... urls) { 329 return loadImageFromNetwork(urls[0]); 330 } 331 332 /** The system calls this to perform work in the UI thread and delivers 333 * the result from doInBackground() */ 334 protected void onPostExecute(Bitmap result) { 335 mImageView.setImageBitmap(result); 336 } 337} 338</pre> 339 340<p>Now the UI is safe and the code is simpler, because it separates the work into the 341part that should be done on a worker thread and the part that should be done on the UI thread.</p> 342 343<p>You should read the {@link android.os.AsyncTask} reference for a full understanding on 344how to use this class, but here is a quick overview of how it works:</p> 345 346<ul> 347<li>You can specify the type of the parameters, the progress values, and the final 348value of the task, using generics</li> 349<li>The method {@link android.os.AsyncTask#doInBackground doInBackground()} executes automatically 350on a worker thread</li> 351<li>{@link android.os.AsyncTask#onPreExecute onPreExecute()}, {@link 352android.os.AsyncTask#onPostExecute onPostExecute()}, and {@link 353android.os.AsyncTask#onProgressUpdate onProgressUpdate()} are all invoked on the UI thread</li> 354<li>The value returned by {@link android.os.AsyncTask#doInBackground doInBackground()} is sent to 355{@link android.os.AsyncTask#onPostExecute onPostExecute()}</li> 356<li>You can call {@link android.os.AsyncTask#publishProgress publishProgress()} at anytime in {@link 357android.os.AsyncTask#doInBackground doInBackground()} to execute {@link 358android.os.AsyncTask#onProgressUpdate onProgressUpdate()} on the UI thread</li> 359<li>You can cancel the task at any time, from any thread</li> 360</ul> 361 362<p class="caution"><strong>Caution:</strong> Another problem you might encounter when using a worker 363thread is unexpected restarts in your activity due to a <a 364href="{@docRoot}guide/topics/resources/runtime-changes.html">runtime configuration change</a> 365(such as when the user changes the screen orientation), which may destroy your worker thread. To 366see how you can persist your task during one of these restarts and how to properly cancel the task 367when the activity is destroyed, see the source code for the <a 368href="http://code.google.com/p/shelves/">Shelves</a> sample application.</p> 369 370 371<h3 id="ThreadSafe">Thread-safe methods</h3> 372 373<p> In some situations, the methods you implement might be called from more than one thread, and 374therefore must be written to be thread-safe. </p> 375 376<p>This is primarily true for methods that can be called remotely—such as methods in a <a 377href="{@docRoot}guide/components/bound-services.html">bound service</a>. When a call on a 378method implemented in an {@link android.os.IBinder} originates in the same process in which the 379{@link android.os.IBinder IBinder} is running, the method is executed in the caller's thread. 380However, when the call originates in another process, the method is executed in a thread chosen from 381a pool of threads that the system maintains in the same process as the {@link android.os.IBinder 382IBinder} (it's not executed in the UI thread of the process). For example, whereas a service's 383{@link android.app.Service#onBind onBind()} method would be called from the UI thread of the 384service's process, methods implemented in the object that {@link android.app.Service#onBind 385onBind()} returns (for example, a subclass that implements RPC methods) would be called from threads 386in the pool. Because a service can have more than one client, more than one pool thread can engage 387the same {@link android.os.IBinder IBinder} method at the same time. {@link android.os.IBinder 388IBinder} methods must, therefore, be implemented to be thread-safe.</p> 389 390<p> Similarly, a content provider can receive data requests that originate in other processes. 391Although the {@link android.content.ContentResolver} and {@link android.content.ContentProvider} 392classes hide the details of how the interprocess communication is managed, {@link 393android.content.ContentProvider} methods that respond to those requests—the methods {@link 394android.content.ContentProvider#query query()}, {@link android.content.ContentProvider#insert 395insert()}, {@link android.content.ContentProvider#delete delete()}, {@link 396android.content.ContentProvider#update update()}, and {@link android.content.ContentProvider#getType 397getType()}—are called from a pool of threads in the content provider's process, not the UI 398thread for the process. Because these methods might be called from any number of threads at the 399same time, they too must be implemented to be thread-safe. </p> 400 401 402<h2 id="IPC">Interprocess Communication</h2> 403 404<p>Android offers a mechanism for interprocess communication (IPC) using remote procedure calls 405(RPCs), in which a method is called by an activity or other application component, but executed 406remotely (in another process), with any result returned back to the 407caller. This entails decomposing a method call and its data to a level the operating system can 408understand, transmitting it from the local process and address space to the remote process and 409address space, then reassembling and reenacting the call there. Return values are then 410transmitted in the opposite direction. Android provides all the code to perform these IPC 411transactions, so you can focus on defining and implementing the RPC programming interface. </p> 412 413<p>To perform IPC, your application must bind to a service, using {@link 414android.content.Context#bindService bindService()}. For more information, see the <a 415href="{@docRoot}guide/components/services.html">Services</a> developer guide.</p> 416 417 418<!-- 419<h2>Beginner's Path</h2> 420 421<p>For information about how to perform work in the background for an indefinite period of time 422(without a user interface), continue with the <b><a 423href="{@docRoot}guide/components/services.html">Services</a></b> document.</p> 424--> 425
