android - 为什么我们应该使用 aysntask 或 service 而不是新线程

Question

在 android 中，为什么我们应该使用 asyntask 和服务，而不是使用 new thread() 并编写必要的后台功能？

我知道我们不应该在主线程或 UI 线程上运行长时间运行的操作，例如从服务器下载文件。并且应该使用异步任务或服务。

但是为什么我们不能创建一个新的线程(){它最终是一个新线程而不是主线程}并在该线程中编写必要的长时间运行的操作。

为什么谷歌创建了 AsyncTask 和服务而不建议使用常规的 New Thread()？？？

提前致谢

编辑1: 可能是我在我的问题中不清楚或者不确定，如果我是，即使是现在。帮帮我。

我明白了，整点从

开始

Do not block the UI thread
Do not access the Android UI toolkit from outside the UI thread 

为什么？ 1.UI线程能处理多少？我们如何确定断点？ ANR点是如何确定的？我们可以跟踪吗？
2. 当服务组件处理长时间运行的操作时，为什么 Activity 组件不能处理？

请记住，如果您确实使用服务，默认情况下它仍会在应用程序的主线程中运行，因此如果它执行密集或阻塞操作，您仍应在服务中创建一个新线程 http://developer.android.com/guide/components/services.html 以上声明来自android文档。

3.如果我们如此关心主线程，为什么不能立即在新线程中启动服务？不要在问题 3 中误会我的意思，我试图了解在主线程中启动服务的优势。默认情况下。

在上面的语句中，它是否暗示了主线程启动和处理服务的长时间运行操作负载的能力？如果是，是否与问题 1 矛盾。

Answer 1

好吧，让我们看看如何使用线程执行简单任务。

第一步是使用 Runnable 创建线程。像这样:

private void fetchResultsAsync() {
    Runnable runner = new Runnable() {

        @Override
        public void run() {
            List<String> results = fetchResultsFromWebServer();
        }
    };
    new Thread(runner).run();
}

问题是，我们需要显示结果，所以它实际上更像这样:

private void fetchResultsAsync() {
    Runnable runner = new Runnable() {

        @Override
        public void run() {
            List<String> results = fetchResultsFromWebServer();
            workFinished(results);
        }
    };
    new Thread(runner).run();
}
private void workFinished(List<String> results) {
    // show the results on the UI
}

看起来不错，但是有问题；回调方法 (workFinished) 必须更新 UI。如果我们从任何非主线程执行此操作，都会出现大问题。我们需要一种线程安全的方式来调用该方法，这就是 Handlers 的用途。我们还引入了一个更新进度的方法，这很常见。代码现在看起来像这样:

private final Handler myHandler = new Handler();
private void fetchResultsAsync() {
    Runnable runner = new Runnable() {

        @Override
        public void run() {
            List<String> results = fetchResultsFromWebServer();
            workFinished(results);
        }
    };
    new Thread(runner).run();
}
private void showProgress(int result) {
    myHandler.post(new Runnable() {
        @Override
        public void run() {
            // update a progress bar here
        }
    });
}
private void workFinished(final List<String> results) {
    myHandler.post(new Runnable() {
        @Override
        public void run() {
            // show the results on the UI
        }
   });
}

将此与使用 AsyncTask 的实现进行比较:

private void fetchWithTask() {
    new AsyncTask<Void, Integer, List<String>>() {

        @Override
        protected List<String> doInBackground(Void... params) {
            return fetchResultsFromWebServer();
        }

        @Override
        protected void onPostExecute(List<String> strings) {
            // show the results on the UI
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            // update a progress bar here
        }
    }.execute();
}

它在代码行数上没有太大区别，但是需要发生什么以及发生在哪里更加明显。它可以防止您犯下令人讨厌的错误，例如忘记将接触 UI 的代码包装在必须发布到 UI 线程拥有的处理程序的 Runnable 中。

现在假设您有几种不同类型的小型后台任务需要执行。从错误的后台线程调用错误的 showProgress 或 workFinished 方法非常容易，因为您必须自己将所有这些部分连接在一起。

还有一个非常讨厌的错误潜伏在 Handler 的默认构造函数的使用中。如果包含类在运行时首先被非 UI 线程引用，则处理程序将属于该线程。 AsyncTask 隐藏总是在正确的线程上做事。这很难捕捉!

乍一看，AsyncTasks 似乎没什么用，但回调管道是它们真正大有作为的地方。