简单地说，

不在UI线程中执行网络工作

例如，如果您执行HTTP请求，则这是一个网络操作。

解决方案：

您必须创建一个新线程或使用AsyncTask类

Way:

把你所有的作品放进去

新线程的run（）方法或AsyncTask类的doInBackground（）方法。

But:

当您从网络响应中获得一些内容并希望在视图中显示它（如在TextView中显示响应消息）时，需要返回到UI线程。

如果不执行此操作，将获得ViewRootImpl$CalledFromWrongThreadException。

如何

使用AsyncTask时，从onPostExecute（）方法更新视图或者调用runOnUiThread（）方法并更新run（）方法内的视图。

使用Android Annotations是一个选项。它将允许您在后台线程中简单地运行任何方法：

// normal method
private void normal() {
    doSomething(); // do something in background
}

@Background
protected void doSomething() 
    // run your networking code here
}

注意，尽管它提供了简单性和可读性的优点，但也有其缺点。

解决这个问题还有另一种非常方便的方法——使用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有一本很棒的电子书。

Android Jetpack引入了WorkManager，它解决了Android 8.1（奥利奥）中后台服务限制的问题，并在Android 5.0（棒棒糖）以下使用Alarm Manager，在Lolipop以上使用JobScheduler。

请使用WorkManager在后台线程上运行任务，即使用户关闭应用程序，它也将继续运行。

尽管上面有一个巨大的解决方案池，但没有人提到com.koushikduta.ion：https://github.com/koush/ion

它也是异步的，使用起来非常简单：

Ion.with(context)
.load("http://example.com/thing.json")
.asJsonObject()
.setCallback(new FutureCallback<JsonObject>() {
   @Override
    public void onCompleted(Exception e, JsonObject result) {
        // do stuff with the result or error
    }
});

在Android上，网络操作不能在主线程上运行。您可以使用线程、异步任务（短期运行任务）和服务（长期运行任务）来执行网络操作。当应用程序尝试在其主线程上执行网络操作时，将引发android.os.NetworkOnMainThreadException。如果您的任务耗时超过5秒，则需要强制关闭。

在AsyncTask中运行代码：

class FeedTask extends AsyncTask<String, Void, Boolean> {

    protected RSSFeed doInBackground(String... urls) {
       // TODO: Connect
    }

    protected void onPostExecute(RSSFeed feed) {
        // TODO: Check this.exception
        // TODO: Do something with the feed
    }
}

Or

new Thread(new Runnable(){
    @Override
    public void run() {
        try {
            // Your implementation
        }
        catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}).start();

不建议这样做。

但出于调试目的，也可以使用以下代码禁用严格模式：

if (android.os.Build.VERSION.SDK_INT > 9) {
    StrictMode.ThreadPolicy policy =
        new StrictMode.ThreadPolicy.Builder().permitAll().build();
    StrictMode.setThreadPolicy(policy);
}