In the viewpoint of running code in the UI thread, is there any difference between:
MainActivity.this.runOnUiThread(new Runnable() { public void run() { Log.d("UI thread", "I am the UI thread"); } }); or
MainActivity.this.myView.post(new Runnable() { public void run() { Log.d("UI thread", "I am the UI thread"); } }); and
private class BackgroundTask extends AsyncTask<String, Void, Bitmap> { protected void onPostExecute(Bitmap result) { Log.d("UI thread", "I am the UI thread"); } } None of those are precisely the same, though they will all have the same net effect.
The difference between the first and the second is that if you happen to be on the main application thread when executing the code, the first one (runOnUiThread()) will execute the Runnable immediately. The second one (post()) always puts the Runnable at the end of the event queue, even if you are already on the main application thread.
The third one, assuming you create and execute an instance of BackgroundTask, will waste a lot of time grabbing a thread out of the thread pool, to execute a default no-op doInBackground(), before eventually doing what amounts to a post(). This is by far the least efficient of the three. Use AsyncTask if you actually have work to do in a background thread, not just for the use of onPostExecute().
AsyncTask.execute() requires you to call from the UI thread anyway, which renders this option useless for the use case of simply running code on the UI thread from a background thread unless you move all of your background work into doInBackground() and use AsyncTask properly.
AsyncTask from UI thread?
boolean isUiThread = (Looper.getMainLooper().getThread() == Thread.currentThread());Looper.getMainLooper().isCurrentThreadI like the one from HPP comment, it can be used anywhere without any parameter:
new Handler(Looper.getMainLooper()).post(new Runnable() { @Override public void run() { Log.d("UI thread", "I am the UI thread"); } }); 
There is a fourth way using Handler
new Handler().post(new Runnable() { @Override public void run() { // Code here will run in UI thread } }); 
new Handler(Looper.getMainLooper()).post(r), which is the preferred manner as Looper.getMainLooper() makes a static call to main, whereas postOnUiThread() must have an instance of MainActivity in scope.
The answer by Pomber is acceptable, however I'm not a big fan of creating new objects repeatedly. The best solutions are always the ones that try to mitigate memory hog. Yes, there is auto garbage collection but memory conservation in a mobile device falls within the confines of best practice. The code below updates a TextView in a service.
TextViewUpdater textViewUpdater = new TextViewUpdater(); Handler textViewUpdaterHandler = new Handler(Looper.getMainLooper()); private class TextViewUpdater implements Runnable{ private String txt; @Override public void run() { searchResultTextView.setText(txt); } public void setText(String txt){ this.txt = txt; } } It can be used from anywhere like this:
textViewUpdater.setText("Hello"); textViewUpdaterHandler.post(textViewUpdater); 
The best solutions are always the ones that try to mitigate memory hog. There are many other criteria for best, and this has a slight smell of premature optimization. That is, unless you know you are calling it enough that number of objects created is an issue (compared to the ten thousand other ways in which your app is probably creating garbage.), what may be best is to write the simplest (easiest to understand) code, and move on to some other task.textViewUpdaterHandler would be better named something like uiHandler or mainHandler, since it is generally useful for any post to main UI thread; it is not at all tied to your TextViewUpdater class. I would move it away from the rest of that code, and make it clear that it can be used elsewhere... The rest of the code is dubious, because to avoid creating one object dynamically, you break what could be a single call into two steps setText and post, that rely on a long-lived object that you use as a temporary. Unnecessary complexity, and not thread-safe. Not easy to maintain.uiHandler and textViewUpdater, then improve your class by changing to public void setText(String txt, Handler uiHandler) and adding method line uiHandler.post(this); Then caller can do in one step: textViewUpdater.setText("Hello", uiHandler);. Then in future, if needs to be thread safe, method can wrap its statements inside a lock on uiHandler, and caller remains unchanged.
As of Android P you can use getMainExecutor():
getMainExecutor().execute(new Runnable() { @Override public void run() { // Code will run on the main thread } }); From the Android developer docs:
Return an Executor that will run enqueued tasks on the main thread associated with this context. This is the thread used to dispatch calls to application components (activities, services, etc).
From the CommonsBlog:
You can call getMainExecutor() on Context to get an Executor that will execute its jobs on the main application thread. There are other ways of accomplishing this, using Looper and a custom Executor implementation, but this is simpler.
If you need to use in Fragment you should use
private Context context; @Override public void onAttach(Context context) { super.onAttach(context); this.context = context; } ((MainActivity)context).runOnUiThread(new Runnable() { public void run() { Log.d("UI thread", "I am the UI thread"); } }); instead of
getActivity().runOnUiThread(new Runnable() { public void run() { Log.d("UI thread", "I am the UI thread"); } }); Because There will be null pointer exception in some situation like pager fragment
use Handler
new Handler(Looper.getMainLooper()).post(new Runnable() { @Override public void run() { // Code here will run in UI thread } }); 
java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare() if it's not called from the UI thread.Kotlin version:
Handler(Looper.getMainLooper()).post { Toast.makeText(context, "Running on UI(Main) thread.", Toast.LENGTH_LONG).show() } Or if you are using Kotlin coroutines: inside coroutine scope add this:
withContext(Dispatchers.Main) { Toast.makeText(context, "Running on UI(Main) thread.", Toast.LENGTH_LONG).show() } 