Looper允许在单个线程上按顺序执行任务。handler定义了我们需要执行的任务。这是我在这个例子中试图说明的一个典型场景:

class SampleLooper extends Thread {
@Override
public void run() {
  try {
    // preparing a looper on current thread     
    // the current thread is being detected implicitly
    Looper.prepare();

    // now, the handler will automatically bind to the
    // Looper that is attached to the current thread
    // You don't need to specify the Looper explicitly
    handler = new Handler();

    // After the following line the thread will start
    // running the message loop and will not normally
    // exit the loop unless a problem happens or you
    // quit() the looper (see below)
    Looper.loop();
  } catch (Throwable t) {
    Log.e(TAG, "halted due to an error", t);
  } 
}
}

现在我们可以在一些其他线程(比如ui线程)中使用处理程序将任务发布到Looper上执行。

handler.post(new Runnable()
{
public void run() {
//This will be executed on thread using Looper.
    }
});

在UI线程上，我们有一个隐式的循环器，允许我们处理UI线程上的消息。

Looper & Handler的最简单定义:

Looper是一个将线程转换为管道线程的类，Handler为您提供了一种机制，可以将任务从任何其他线程推入该管道。

一般措词的详细说明:

因此，流水线线程是一个可以通过处理程序从其他线程接受更多任务的线程。

Looper之所以这样命名，是因为它实现了循环——接受下一个任务，执行它，然后再接受下一个任务，以此类推。Handler之所以被称为Handler，是因为它用于处理或接受每次来自任何其他线程的下一个任务，并传递给Looper(线程或管道线程)。

例子:

循环程序和处理程序或管道线程的非常完美的例子是下载多个图像或在单个线程中逐个上传到服务器(Http)，而不是在后台为每个网络调用启动一个新线程。

在这里阅读更多关于Looper和Handler以及Pipeline Thread的定义:

Android内脏:环形器和处理程序的介绍

什么是环形使者?

Looper是一个用于执行队列中的消息(可运行对象)的类。普通线程没有这样的队列，例如简单线程没有任何队列。它执行一次，方法执行完成后，线程将不再运行另一个Message(Runnable)。

我们可以在哪里使用Looper类?

如果有人想要执行多个消息(Runnables)，那么他应该使用负责在线程中创建队列的Looper类。 例如，在编写从internet下载文件的应用程序时，我们可以使用Looper类将要下载的文件放入队列中。

它是如何工作的?

有prepare()方法来准备Looper。然后，您可以使用loop()方法在当前线程中创建一个消息循环，现在您的Looper已经准备好在队列中执行请求，直到退出循环。

下面是您可以准备Looper的代码。

class LooperThread extends Thread {
      public Handler mHandler;

      @Override
      public void run() {
          Looper.prepare();

          mHandler = new Handler() {
              @Override
              public void handleMessage(Message msg) {
                  // process incoming messages here
              }
          };

          Looper.loop();
      }
  }

Looper允许在单个线程上按顺序执行任务。handler定义了我们需要执行的任务。这是我在这个例子中试图说明的一个典型场景:

class SampleLooper extends Thread {
@Override
public void run() {
  try {
    // preparing a looper on current thread     
    // the current thread is being detected implicitly
    Looper.prepare();

    // now, the handler will automatically bind to the
    // Looper that is attached to the current thread
    // You don't need to specify the Looper explicitly
    handler = new Handler();

    // After the following line the thread will start
    // running the message loop and will not normally
    // exit the loop unless a problem happens or you
    // quit() the looper (see below)
    Looper.loop();
  } catch (Throwable t) {
    Log.e(TAG, "halted due to an error", t);
  } 
}
}

现在我们可以在一些其他线程(比如ui线程)中使用处理程序将任务发布到Looper上执行。

handler.post(new Runnable()
{
public void run() {
//This will be executed on thread using Looper.
    }
});

在UI线程上，我们有一个隐式的循环器，允许我们处理UI线程上的消息。

我尝试在Kotlin中给出一个例子。下面是代码示例。

首先，我们需要实例化handler(提供的循环程序而不是默认的循环程序)中的变量处理程序，它要求主线程(loop . getmainlooper())。

函数getAllCourses()需要返回LiveData，因此我们使用handler.postDelayed()将其添加到消息队列中，并在常量SERVICE_LATENCY_IN_MILLIS中指定的x毫秒后运行。

请随意对我的解释再细化一些措辞，使之更清楚。

class RemoteDataSource private constructor(private val jsonHelper: JsonHelper) {

    private val handler = Handler(Looper.getMainLooper())

    companion object {
        private const val SERVICE_LATENCY_IN_MILLIS: Long = 2000

        @Volatile
        private var instance: RemoteDataSource? = null

        fun getInstance(helper: JsonHelper): RemoteDataSource =
                instance ?: synchronized(this) {
                    RemoteDataSource(helper).apply { instance = this }
                }
    }

    fun getAllCourses(): LiveData<ApiResponse<List<CourseResponse>>> {
        EspressoIdlingResource.increment()
        val resultCourse = MutableLiveData<ApiResponse<List<CourseResponse>>>()
        handler.postDelayed({
            resultCourse.value = ApiResponse.success(jsonHelper.loadCourses())
            EspressoIdlingResource.decrement()
        }, SERVICE_LATENCY_IN_MILLIS)
        return resultCourse
    }

这个答案与问题无关，但looper的使用以及人们在这里的所有答案中创建处理程序和looper的方式都是明显的坏习惯(尽管有些解释是正确的)，我不得不发布这个:

HandlerThread thread = new HandlerThread(threadName);
thread.start();
Looper looper = thread.getLooper();
Handler myHandler = new Handler(looper);

以及一个完整的实现