I did some more research.
Although it is preferred that an application not consume CPU resources if it is not in the foreground. It seems that this is complicated if multiple threads are running (which is likely to be the case in order to keep the main UI thread responsive). From what I have read so far, it doesn't seem like there is anything that explicitly prevents a worker thread from continuing to execute even if its parent UI thread has been moved to the background/suspended.
I imagine the correct way to handle things is for the main UI thread to kill any worker threads when onPause() is called and start them up again when onResume is called. This guarantees that there truly is no CPU load for the application while it is not visible (well, except for Services and Broadcast Receivers). The main thread should be careful to save any state needed by the worker thread(s) so that they can start up again when the application comes to the foreground and pick up from where they left off as if they were never killed in the first place.
However, what's to prevent an application from behaving badly and NOT killing its worker threads? Based on all the high-level talk about the OS not letting backgrounded applications use CPU resources, I had just assumed that ALL threads/processes associated with an app that are not Services or Broadcast Receivers are somehow suspended when an application moves out of the foreground. Instead it seems that it would be very easy for a badly managed worker thread to keep running until it is unceremoniously killed by the OS.
In theory, I suppose you could let a worker thread continue to execute in the background if a.) the run time is guaranteed to be finite (e.g. loading a web page), and b.) the user wouldn't care if the thread was killed before completing its finite workload (e.g. a web page could just be reloaded if necessary). However, for the AndroXplorer file copy that I mentioned in my previous post, since this "background" thread is not running as a service, how would the user ever know if thread executing the copy was killed before the operation was complete? This seems like it could be a problem.
In general, although the platform provides all of the tools necessary to implement persistent applications without using CPU resources, it is the developer's responsibility to play nicely. Given that resources (i.e. battery/engery) are scare in a mobile environment, it seems like it would have been better to "break" applications that don't behave nicely instead of letting badly behaved applications break the system (by wasting resources). You could even have a worker thread simply spinning in the background, doing nothing but using CPU. Obviously, it would be killed eventually, but not until the memory was needed.
Am I way off the map here or is my understanding more or less correct?