来自开发者android：

AsyncTask理想情况下应用于短操作（最多几秒钟）

使用newCachedThreadPool是一个好方法。还可以考虑其他选项，如newSingleThreadExecutor、newFixedThreadPool

    ExecutorService myExecutor = Executors.newCachedThreadPool();
    myExecutor.execute(new Runnable() {
        @Override
        public void run() {
            URL url = new URL(urls[0]);
            SAXParserFactory factory = SAXParserFactory.newInstance();
            SAXParser parser = factory.newSAXParser();
            XMLReader xmlreader = parser.getXMLReader();
            RssHandler theRSSHandler = new RssHandler();
            xmlreader.setContentHandler(theRSSHandler);
            InputSource is = new InputSource(url.openStream());
            xmlreader.parse(is);
        }
    });

ThreadPoolExecutor是一个帮助程序类，可使此过程更简单。这类管理一组线程的创建并管理如何在这些线程之间分配工作。随着工作量的增加或减少，该类会加速或破坏更多线程可根据工作负载进行调整。

有关Android线程的更多信息，请参阅本文。

这在Android 3.0及更高版本中发生。从Android 3.0及更高版本开始，他们限制在主线程/UI线程中运行网络操作（访问Internet的功能）（活动中创建和恢复方法产生的内容）。

这是为了鼓励在网络操作中使用单独的线程。有关如何正确执行网络活动的详细信息，请参阅AsyncTask。

解决这个问题还有另一种非常方便的方法——使用RxJava的并发功能。您可以在后台执行任何任务，并以非常方便的方式将结果发布到主线程，因此这些结果将被传递到处理链。

第一个经过验证的答案建议是使用AsynTask。是的，这是一个解决方案，但现在已经过时了，因为周围有新的工具。

String getUrl() {
    return "SomeUrl";
}

private Object makeCallParseResponse(String url) {
    return null;
    //
}

private void processResponse(Object o) {

}

getUrl方法提供URL地址，它将在主线程上执行。

makeCallParseResponse（..）-执行实际工作

processResponse（..）-将处理主线程上的结果。

异步执行的代码如下：

rx.Observable.defer(new Func0<rx.Observable<String>>() {
    @Override
    public rx.Observable<String> call() {
        return rx.Observable.just(getUrl());
    }
})
    .subscribeOn(Schedulers.io())
    .observeOn(Schedulers.io())
    .map(new Func1<String, Object>() {
        @Override
        public Object call(final String s) {
            return makeCallParseResponse(s);
        }
    })
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Action1<Object>() {
        @Override
        public void call(Object o) {
             processResponse(o);
        }
    },
    new Action1<Throwable>() {
        @Override
        public void call(Throwable throwable) {
            // Process error here, it will be posted on
            // the main thread
        }
    });

与AsyncTask相比，此方法允许切换调度器任意次数（例如，在一个调度器上获取数据，并在另一个调度器中处理这些数据（例如，scheduler.computation（）））。您还可以定义自己的调度器。

为了使用此库，请在build.gradle文件中包含以下行：

   compile 'io.reactivex:rxjava:1.1.5'
   compile 'io.reactivex:rxandroid:1.2.0'

最后一个依赖项包括对.mainThread（）调度程序的支持。

RxJava有一本很棒的电子书。

你可以使用Kotlin和Anko。

Kotlin是Android的新官方语言。您可以在这里找到更多信息：适用于Android的Kotlin。

Anko是Android中Kotlin支持的库。GitHub页面上有一些文档。

这个解决方案非常有用，只有@AntonioLeiva编写的几行代码：使用Anko在Android中使用Kotlin运行后台任务（KAD 09）。

doAsync {
    var result = runLongTask()
    uiThread {
        toast(result)
    }
}

虽然很简单，但当您在UI线程上运行后台作业时，就会出现NetworkOnMainThread，因此您必须做的一件事就是在后台运行longTask作业。你可以在Android应用程序中使用此方法和Kotlin与Anko来完成此操作。

截至2018年，我建议在Kotlin中使用RxJava进行网络获取。下面是一个简单的例子。

Single.fromCallable {
        // Your Network Fetching Code
        Network.fetchHttp(url) 
    }
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe {
        // What you need to do with your result on the view 
        result -> view.updateScreen(result) 
    }

您可以使用Kotlin协程：

 class YoutActivity : AppCompatActivity, CoroutineScope {
      
      override fun onCreate(...) {
         launch {  yourHeavyMethod() }
      }

      suspend fun yourHeavyMethod() {
         with(Dispatchers.IO){ yourNetworkCall() }
         ...
         ...
      }
 } 

您可以遵循本指南。