blocks|key|208706|text|Aysnc任务是专门的线程，仍然意味着要与您的应用程序GUI一起使用，但同时保留UI线程的资源密集型任务。因此，当更新列表、更改视图等工作需要你执行一些抓取操作或更新操作时，你应该使用异步任务，这样你就可以将这些操作从UI线程中分离出来，但请注意，这些操作仍然以某种方式连接到UI上。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|208707|对于运行时间较长的任务，不需要UI更新，您可以使用服务，因为即使没有UI，它们也可以继续运行。|208708|因此，对于较短的任务，请使用异步任务，因为它们可能会在您的衍生活动终止后被操作系统终止(通常不会在操作过程中终止，但会完成其任务)。对于长时间和重复性的任务，请使用服务。|208709|有关更多信息，请参阅线程：|208710|AsyncTask+for+longer+than+a+few+seconds?|offset|length|208711|和|208712|AsyncTask+won't+stop+even+when+the+activity+has+destroyed|208713|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/12219930/asynctask-for-longer-than-a-few-seconds|1|https://stackoverflow.com/questions/2531336/asynctask-wont-stop-even-when-the-activity-has-destroyed^0|0|0|0|0|0|14|0|0|0|0|1L|1|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|12|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|13|8|@]|9|@$J|14|K|15|1|16]]|A|$]]|$1|L|3|M|5|6|7|17|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|18|8|@]|9|@$J|19|K|1A|1|1B]]|A|$]]|$1|P|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|W]]|X|$5|S|T|U|A|$V|Y]]]]

Aysnc task are specialized threads that are still meant to be used with your apps GUI but whilst keeping resource-heavy tasks of the UI thread. So when stuff like updating lists, changing your views etc require you to do some fetch operations or update operations, you should use async tasks so that you can keep these operations off the UI thread but note that these operations are still connected to the UI somehow.

For longer-running tasks, which don't require UI updation, you can use services instead because they can live even without a UI.

So for short tasks, use async tasks because they can get killed by the OS after your spawning activity dies (usually will not die mid-operation but will complete its task). And for long and repetitive tasks, use services instead.

for more info, See threads:

<a href="https://stackoverflow.com/questions/12219930/asynctask-for-longer-than-a-few-seconds">AsyncTask for longer than a few seconds?</a>

and

<a href="https://stackoverflow.com/questions/2531336/asynctask-wont-stop-even-when-the-activity-has-destroyed">AsyncTask won&#39;t stop even when the activity has destroyed</a>

blocks|key|211124|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|211125|为什么？|blockquote|211126|211127|211128|因为在默认情况下，AsyncTask使用的线程池不是您创建的。切勿占用不是您创建的池中的资源，因为您不知道该池的要求是什么。而且，如果池的文档告诉您不要绑定不是您创建的池中的资源，就不要从该池中绑定资源，就像这里的情况一样。|offset|length|style|CODE|211129|特别是，从Android3.2开始，AsyncTask默认使用的线程池(对于android:targetSdkVersion设置为13或更高的应用程序)中只有一个线程--如果你无限期地占用这个线程，你的其他任务都不会运行。|211130|entityMap^0|0|0|0|0|9|9|0|I|9|12|O|0^^$0|@$1|2|3|-4|4|5|6|P|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|Q|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|R|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|S|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|T|7|@$H|U|I|V|J|K]]|8|@]|9|$]]|$1|L|3|M|4|5|6|W|7|@$H|X|I|Y|J|K]|$H|Z|I|10|J|K]]|8|@]|9|$]]|$1|N|3|-4|4|5|6|11|7|@]|8|@]|9|$]]]|O|$]]

<blockquote>
 why ?
</blockquote>

Because <code>AsyncTask</code>, by default, uses a thread pool that you did not create. Never tie up resources from a pool that you did not create, as you do not know what that pool's requirements are. And never tie up resources from a pool that you did not create if the documentation for that pool tells you not to, as is the case here.

In particular, starting with Android 3.2, the thread pool used by <code>AsyncTask</code> by default (for apps with <code>android:targetSdkVersion</code> set to 13 or higher) has only one thread in it -- if you tie up this thread indefinitely, none of your other tasks will run.

blocks|key|2852048|text|这是一个非常好的问题，作为一名Android程序员需要时间来完全理解这个问题。实际上，AsyncTask有两个相关的主要问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2852049|2852050|它们与活动生命周期的联系很差，|unordered-list-item|2852051|很容易造成内存泄漏。|2852052|2852053|在RoboSpice+Motivations应用程序(available+on+Google+Play)中，我们详细地回答了这个问题。它将深入介绍AsyncTasks、Loaders及其功能和缺点，并向您介绍针对网络请求的另一种解决方案:+RoboSpice。网络请求是Android中的常见需求，本质上是长时间运行的操作。以下是该应用程序的摘录：|offset|length|2852054|AsyncTask和活动生命周期|2852055|AsyncTasks不遵循活动实例的生命周期。如果您在Activity中启动AsyncTask并旋转设备，则Activity将被销毁并创建一个新实例。但AsyncTask不会消亡。它将继续存在，直到它完成。|2852056|当它完成时，AsyncTask不会更新新活动的UI。实际上，它会更新不再显示的活动的前一个实例。例如，如果您使用findViewById来检索活动内部的视图，这可能会导致java.lang.IllegalArgumentException类型的异常:视图未附加到窗口管理器。|2852057|内存泄漏问题|2852058|将AsyncTasks创建为活动的内部类非常方便。由于AsyncTask需要在任务完成或进行时操作活动的视图，因此使用活动的内部类似乎很方便:内部类可以直接访问外部类的任何字段。|2852059|然而，这意味着内部类将在其外部类实例上持有一个不可见的引用:+Activity。|2852060|从长远来看，这会产生内存泄漏:如果AsyncTask持续很长时间，它会让活动保持“活动”，而安卓希望摆脱它，因为它不能再显示了。该活动不能被垃圾收集，这是Android保存设备资源的核心机制。|2852061|2852062|对于长时间运行的操作，使用AsyncTasks确实是一个非常非常糟糕的想法。不过，它们适用于生命周期较短的应用，比如在1秒或2秒后更新视图。|2852063|我鼓励您下载RoboSpice+Motivations+app，它真正深入地解释了这一点，并提供了执行一些后台操作的不同方法的示例和演示。|2852064|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/octo-online/robospice|1|https://play.google.com/store/apps/details?id=com.octo.android.robospice.motivations|2^0|0|0|0|0|0|1|9|0|R|O|1|0|0|0|0|0|0|0|0|0|0|6|P|2|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1I|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|1J|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1L|8|@]|9|@$K|1M|L|1N|1|1O]|$K|1P|L|1Q|1|1R]]|A|$]]|$1|M|3|N|5|6|7|1S|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1T|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1U|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1V|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1W|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1X|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|20|8|@]|9|@]|A|$]]|$1|13|3|14|5|6|7|21|8|@]|9|@$K|22|L|23|1|24]]|A|$]]|$1|15|3|-4|5|6|7|25|8|@]|9|@]|A|$]]]|16|$17|$5|18|19|1A|A|$1B|1C]]|1D|$5|18|19|1A|A|$1B|1E]]|1F|$5|18|19|1A|A|$1B|1E]]]]

It is a very good question, it takes time as an Android Programmer to fully understand the issue. Indeed AsyncTask have two main issues that are related : 

<ul>
<li>They are poorly tied to the activity life cycle</li>
<li>They create memory leaks very easily.</li>
</ul>

Inside the <a href="https://github.com/octo-online/robospice" rel="noreferrer">RoboSpice</a> Motivations app (<a href="https://play.google.com/store/apps/details?id=com.octo.android.robospice.motivations" rel="noreferrer">available on Google Play</a>) we answer that question in detail. It will give an in-depth view of AsyncTasks, Loaders, their features and drawbacks and also introduce you to an alternative solution for network requests : RoboSpice.
Network requests are a common requirement in Android and are by nature long running operations 
.
Here is an excerpt from the app :

<h3>The AsyncTask and Activity life cycle</h3>


AsyncTasks don't follow Activity instances' life cycle. If you start an AsyncTask inside an Activity and you rotate the device, the Activity will be destroyed and a new instance will be created. But the AsyncTask will not die. It will go on living until it completes. 



And when it completes, the AsyncTask won't update the UI of the new Activity. Indeed it updates the former instance of the activity that
is not displayed anymore. This can lead to an Exception of the type java.lang.IllegalArgumentException: View not attached to window manager if you
use, for instance, findViewById to retrieve a view inside the Activity.


<h3>Memory leak issue</h3>


It is very convenient to create AsyncTasks as inner classes of your Activities. As the AsyncTask will need to manipulate the views 
of the Activity when the task is complete or in progress, using an inner class of the Activity seems convenient : inner classes can 
access directly any field of the outer class.



Nevertheless, it means the inner class will hold an invisible reference on its outer class instance : the Activity. 



On the long run, this produces a memory leak : if the AsyncTask lasts for long, it keeps the activity "alive" 
whereas Android would like to get rid of it as it can no longer be displayed. The activity can't be garbage collected and that's a central
mechanism for Android to preserve resources on the device. 


<hr>

It is really a very very bad idea to use AsyncTasks for long running operations. Nevertheless, they are fine for short living ones such as updating a View after 1 or 2 seconds.

I encourage you to download the <a href="https://play.google.com/store/apps/details?id=com.octo.android.robospice.motivations" rel="noreferrer">RoboSpice Motivations app</a>, it really explains this in-depth and provides samples and demonstrations of the different ways to do some background operations.

blocks|key|208739|text|AsyncTask的问题在于，如果它被定义为activity的非静态内部类，那么它将具有对activity的引用。在activity异步任务容器完成，但AsyncTask中的后台工作仍在继续的情况下，activity对象将不会被垃圾回收，因为存在对它的引用，这会导致内存泄漏。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|208740|解决这个问题解决方案是定义活动的async+task+as+static+inner+class并使用对上下文的弱引用。|offset|length|208741|但是，将它用于简单而快速的后台任务仍然是一个好主意。要使用干净的代码开发应用程序，最好使用RxJava来运行复杂的后台任务，并使用结果更新UI。|208742|entityMap|0|LINK|mutability|MUTABLE|url|http://www.zoftino.com/android-threads-tutorial|1|http://www.zoftino.com/retrofit-rxjava-android-example^0|0|G|W|0|0|19|6|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@$D|T|E|U|1|V]]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]|P|$5|K|L|M|A|$N|Q]]]]

The problem with AsyncTask is that if it is defined as non-static inner class of the activity, it will have a reference to activity. In the scenario where activity the container of async task finishes, but the background work in AsyncTask continues, the activity object will not be garbage collected as there is a reference to it, this causes the memory leak.

The solution to fix this is define <a href="http://www.zoftino.com/android-threads-tutorial" rel="nofollow noreferrer">async task as static inner class</a> of activity and use weak reference to context.

But still, it is a good idea to use it for simple and quick background tasks. To develop app with clean code, it is better to use <a href="http://www.zoftino.com/retrofit-rxjava-android-example" rel="nofollow noreferrer">RxJava</a> to run complex background tasks and updating UI with results from it.

Quoting the documentation for AsyncTask found <a href="http://developer.android.com/reference/android/os/AsyncTask.html" rel="noreferrer">here</a>, it says: 

<blockquote>
 AsyncTasks should ideally be used for short operations (a few seconds at the most.) If you need to keep threads running for long periods of time, it is highly recommended you use the various APIs provided by the java.util.concurrent pacakge such as Executor, ThreadPoolExecutor and FutureTask.
</blockquote>

Now my question arises: why? The <code>doInBackground()</code> function runs off the UI thread so what harm is there by having a long running operation here?

Android AsyncTask for long running operations

Android

容器

引用AsyncTask found 的文档，它说：理想情况下， AsyncTasks应该用于较短的操作(最多几秒钟)。如果您需要让线程长时间运行，强烈建议您使用java.util.concurrent包提供的各种API，如Executor、ThreadPoolExecutor和FutureTask。现在我的问题出现了:...

问用于长时间运行操作的Android AsyncTask
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用于长时间运行操作的Android AsyncTaskEN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用于长时间运行操作的Android AsyncTask
EN