How to Fix NetworkOnMainThreadException in Android (Java)

By the end of this page, you will understand why Android throws NetworkOnMainThreadException, why network work should never run on the UI thread, and how to move RSS fetching code to a background thread safely. You will also learn how developers typically handle networking, parsing, and UI updates in real Android apps.

NetworkOnMainThreadException happens when your Android app tries to perform a network operation on the main thread.

In Android, the main thread is also called the UI thread. It is responsible for:

• drawing the screen
• responding to taps and scrolls
• updating views
• keeping the app responsive

Network calls such as this line:

url.openStream()

can take an unknown amount of time. The internet may be slow, the server may delay its response, or the connection may fail.

If Android allowed this work on the main thread, the app could freeze. To prevent that, Android throws NetworkOnMainThreadException.

Your code is doing two kinds of work:

• network I/O: downloading the RSS XML from the URL
• parsing: reading the XML using SAX

The important issue is the network request. That must happen off the main thread.

This matters in real programming because almost every app performs slow operations such as:

• API requests
• downloading files
• database access
• reading large files

A responsive app separates:

• background work for slow tasks
• main-thread work for updating the UI

That separation is a core Android programming rule.

Think of the main thread as a cashier serving customers in a busy store.

• If the cashier keeps helping customers, the line moves.
• If the cashier leaves to drive across town to pick up a package, everyone waits.

A network request is like sending someone across town. It may take a few seconds or much longer.

So instead of making the cashier do it, you send a worker in the background. When the package arrives, the cashier is told the result and updates the screen.

In Android terms:

• main thread = the cashier
• background thread = the worker
• UI update = telling the cashier what to display

The core fix is: move network work off the main thread.

Problematic code

This code causes the exception if called on the UI thread:

URL url = new URL(urlToRssFeed);
InputSource is = new InputSource(url.openStream());
xmlreader.parse(is);

The openStream() call performs network I/O.

Simple background thread example

new Thread(() -> {
    try {
        URL url = new URL(urlToRssFeed);
        SAXParserFactory factory = SAXParserFactory.newInstance();
        SAXParser parser = factory.newSAXParser();
        XMLReader xmlReader = parser.getXMLReader();
        RssHandler rssHandler = new ();
        xmlReader.setContentHandler(rssHandler);

            (url.openStream());
        xmlReader.parse(inputSource);

           rssHandler.getFeed();

        runOnUiThread(() -> {
            
        });
    }  (Exception e) {
        e.printStackTrace();
        runOnUiThread(() -> {
            
        });
    }
}).start();

Consider this example:

new Thread(() -> {
    try {
        URL url = new URL(urlToRssFeed);
        InputSource inputSource = new InputSource(url.openStream());

        SAXParserFactory factory = SAXParserFactory.newInstance();
        SAXParser parser = factory.newSAXParser();
        XMLReader xmlReader = parser.getXMLReader();

        RssHandler handler = new RssHandler();
        xmlReader.setContentHandler(handler);
        xmlReader.parse(inputSource);

        Feed feed = handler.getFeed();

        runOnUiThread(() -> {
            // show feed on screen
        });
    } catch (Exception e) {
        runOnUiThread(() -> {
            // show error
        });
    }
}).start();

Step by step

1. new Thread(...).start()

This rule applies far beyond RSS parsing.

Common situations where background threading is required

• Fetching JSON from a REST API
• Downloading images or files
• Uploading form data
• Reading data from a remote server
• Parsing XML or JSON after downloading it
• Syncing app data with cloud services

Example scenarios

Weather app

A weather app requests forecast data from an API. The request must happen in the background, then the screen updates with temperature data.

News app

A news app downloads article feeds and parses them. This is very similar to your RSS reader case.

Login screen

A login form sends credentials to a backend server. The request runs in the background while a loading indicator is shown.

File downloader

A file download may take many seconds. Running it on the main thread would freeze the app immediately.

In all these cases, the pattern is the same:

1. start background work
2. wait for result or error
3. update UI on main thread

In real Android projects, developers usually do more than just start a raw thread.

Common patterns

1. Guard clauses before networking

Developers validate input early:

if (urlToRssFeed == null || urlToRssFeed.isEmpty()) {
    return;
}

This avoids starting bad requests.

2. Try-with-resources or proper stream closing

Streams should be closed to avoid leaks.

try (InputStream stream = url.openStream()) {
    InputSource inputSource = new InputSource(stream);
    xmlReader.parse(inputSource);
}

3. Error handling

Production apps distinguish different failures:

• no internet connection
• timeout
• malformed XML
• invalid URL
• server error

4. Loading state

Apps often show and hide a loading indicator:

• show spinner before request
• hide spinner after success or failure

5. Repository or service classes

Instead of putting networking directly in an Activity, developers often create classes like:

1. Performing network requests directly in onCreate() or button handlers

Broken example:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    URL url = new URL(urlToRssFeed);
    InputSource is = new InputSource(url.openStream());
}

Why it is wrong:

• onCreate() runs on the main thread
• openStream() performs network I/O

How to avoid it:

• move the network call to a background thread

2. Updating UI from a background thread

Broken example:

new Thread(() -> {
    textView.setText("Loaded");
}).start();

Why it is wrong:

• Android views must be updated on the main thread

Quick rules

• NetworkOnMainThreadException means you did network I/O on the UI thread.
• url.openStream() is a network operation.
• Network calls must run on a background thread.
• UI updates must run on the main thread.
• Add internet permission in AndroidManifest.xml.

Basic pattern

new Thread(() -> {
    try {
        // network work here
        runOnUiThread(() -> {
            // update UI here
        });
    } catch (Exception e) {
        runOnUiThread(() -> {
            // show error here
        });
    }
}).start();

Permission

<uses-permission android:name="android.permission.INTERNET" />

Safe stream usage

try (InputStream stream = url.openStream()) {
    InputSource inputSource = new InputSource(stream);
    xmlReader.parse(inputSource);
}

Why does Android throw NetworkOnMainThreadException?

Because your app is trying to do a network request on the main UI thread, which can freeze the interface.

Which line in my code causes the problem?

This line is the main cause:

url.openStream()

It opens a network connection and reads data from the internet.

Can I parse XML on the main thread if the file is local?

If the file is truly local and small, parsing may be possible on the main thread, but heavy parsing can still make the UI lag. Network access must not run there.

Is AsyncTask the right fix?

For old codebases, you may see it used, but it is deprecated. Prefer a background thread, ExecutorService, or modern Android tools.

Do I also need internet permission?

Yes. Add this to the manifest:

<uses-permission android:name="android.permission.INTERNET" />

Can I update a TextView from the background thread?

No. Use runOnUiThread() or another main-thread mechanism.

What is the best modern approach in Android?

In modern apps, developers often use Retrofit with coroutines or other structured background execution tools. But the core idea is still the same: keep network work off the main thread.

• Android main thread — This exception is directly related to how the UI thread works.
• Background threads — The main fix is moving work to a background thread.
• runOnUiThread() — Needed when you want to update views after background work finishes.
• Exception handling — Network and parsing operations can fail and should be handled safely.
• InputStream — Your RSS data is read through a stream that should be closed properly.
• SAX parsing — Your code uses a SAX parser to process XML.
• Android permissions — Network access requires the INTERNET permission.
• Asynchronous programming — This problem is a practical example of async work in Android.