[MUSIC]

When we last saw stormy, it was just that pretty storming and

not working due to a network on main thread exceptionary.

As the name would indicate, we were getting the error because our

app was trying to get data while on the main thread.

So what exactly is a thread?

We're supposed to be doing entry development, not sewing.

Let's talk about this concept of threads, as it relates to apps and

computer programs in general.

We've all experienced this at some point with our phones and

it can cause lots of frustrations.

You do something in an app, and the app lags.

You tap somewhere else on the screen and nothing happens.

Tap, tap, tap and no response.

As good responsible developers, we want to make our users happy with our apps.

One way to accomplish this is to ensure responsiveness to input from the user.

We never want to leave it in a frozen state.

To accomplish this, we perform work on separate threads of execution in parallel.

Let us take a look at an example.

Let us think about a conversation we are having with a friend.

Generally, we want to be responsive to their input, right?

No one enjoys having a one way conversation.

If I'm talking to Ben I don't want to roughly leave the conversation to go get

water, that will leave him waiting and frustrated.

Typically, I'd wait to finish the conversation and

then get my work in water.

You know, do two things in order.

This is know as performing synchronous tasks.

What if I'm really thirsty though?

I could ask someone else to go get me some water while I'm talking with Ben.

That work, getting water, is done in parallel with my main work,

the conversation with Ben.

On an Android device, and most computers,

all the work is typically done on one main thread of execution.

My conversation with Ben is like work being done on the main thread.

We can perform additional work in the background like getting water

by executing it on a separate asynchronous thread of execution.

This background thread, Craig here in this example

can perform long running operations that would otherwise clog up the main thread.

What do I mean by a thread of execution?

In programming, we use the term thread to refer to a path of execution for code.

We can make our code perform multiple tasks at once,

just like the conversation and water example we just explored.

This is known as concurrency which means

having multiple things happen at the same time.

How does this relate to Android programing?

Android has many ways to handle asynchronous processing.

Further, it's built right into okay HTTP.

We'll explore that more here shortly.

Why are we even talking about this, well, just like our conversation and water

example, we want our app to be completely attentive and responsive to our user.

You can think if the Android operating system as a highway with multiple lanes.

Each lane is a thread used for processing code.

On this highway, we have vehicles speeding along.

Think of these vehicles as code executing in different apps or

different parts of the system.

The code we just wrote is synchronous code.

This is like blocking the lane with a slow moving truck.

When we write asynchronous code, we move this truck to another lane, and

it keeps the traffic on the main lane flowing as normal.

Let's think about networking on this highway.

We all know that the network can be a little unreliable at times.

When we make a network call on our app what happens if we have issues and

our request takes a long time?

We're making that all on our main thread like we are in our code right now.

It can block the user interface.

None of the user interface code will get executed and

the user won't be able to do anything with the app.

They would think it is unresponsive or broken, leading to frustration and

then they might even, delete our app.

All of our networking code should be done in a background thread.

One of these side lanes.

This way, we won't block the UI from being responsive.

When this network request completes, we need to move back

from the background thread to the main thread to update our UI,

since all of UI updates are done on the main thread.

That's a lot to take in, I know, but concurrency can improve the responsiveness

of our code by ensuring that our main thread is free to respond to user events.

Our next step, then, is to change our code to be asynchronous.

Let's see how we can do that, next.