Как классы обработчиков работают в Android

См. Документацию .

Но чтобы понять документацию, вы должны сначала понять несколько концепций: сообщение, очередь сообщений, обработчик и лупер, а также их отношения.

Ниже показано, как работает Looper, он показывает, что он является локальным объектом потока и его взаимосвязью с MessageQueue:

class Looper{
    public static final void prepare() {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper());
    }

    public static final void loop() {
        Looper me = myLooper();
        MessageQueue queue = me.mQueue;
        while (true) {
            Message msg = queue.next(); // might block
            if (msg != null) {
                if (msg.target == null) {
                    // No target is a magic identifier for the quit message.
                    return;
                }
                msg.target.dispatchMessage(msg);
                msg.recycle();
            }
        }
    }
}

Несколько замечаний:

Looper - это локальный объект потока, так что каждый поток имеет один цикл. Каждый петлитель связан с очередью сообщений. Цикл непрерывно получает сообщения («задачи», «команды» или что угодно, что вы хотите называть их) из очереди и отправляет сообщение своей цели, которая является обработчиком для обработки этого сообщения (например, путем обратного вызова Runnable, содержащегося в сообщение). Когда в очереди не осталось сообщений, поток блокируется до тех пор, пока не появятся новые сообщения. Чтобы остановить Looper, вы должны вызвать для него quit () (который, вероятно, не останавливает цикл немедленно, а скорее устанавливает частный флаг, который периодически проверяется из цикла, сигнализируя об остановке).

Платформа Android предоставляет класс Handler для упрощения работы. Когда вы создаете экземпляр Handler, он (по умолчанию) привязан к Looper, уже прикрепленному к текущему потоку. (Обработчик знает, к какому Looper подключиться, потому что мы ранее вызвали prepare (), которая сохранила ссылку на Looper в ThreadLocal.)

С помощью Handler вы можете просто вызвать post (), чтобы «поместить сообщение в очередь сообщений потока» (так сказать). Обработчик позаботится обо всех материалах обратного вызова IdleHandler и обеспечит выполнение вашего опубликованного Runnable. (Он также может проверить, пришло ли время уже, если вы отправили сообщение с задержкой.)

В следующем коде показаны типичные способы их использования.

class LooperThread extends Thread {
  public Handler mHandler;

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

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

      Looper.loop();
  }

}

Обработчик широко используется в сервисах Android. Android поддерживает связь между приложениями. Обычно, когда мы реализуем службу, которая не должна обрабатывать многопоточность, мы реализуем обработчик, который получает обратный вызов для каждого вызова от клиента. Затем создайте объект Messenger (ссылка на обработчик), который является объектом Binder, и верните этот объект клиентам, когда они привяжут эту службу. Таким образом, клиент может использовать этот Messenger для отправки сообщений (в локальную очередь потока, отправить обработчику через Looper) в эту службу и обрабатывать их в обработчике. Пример кода прилагается:

public class MessengerService extends Service {
    /** Command to the service to display a message */
    static final int MSG_SAY_HELLO = 1;

    /**
     * Handler of incoming messages from clients.
     */
    class IncomingHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_SAY_HELLO:
                    Toast.makeText(getApplicationContext(), "hello!", Toast.LENGTH_SHORT).show();
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }


    final Messenger mMessenger = new Messenger(new IncomingHandler());

    @Override
    public IBinder onBind(Intent intent) {
        Toast.makeText(getApplicationContext(), "binding", Toast.LENGTH_SHORT).show();
        return mMessenger.getBinder();
    }
}

postDelayed (Runnable r, long delayMillis)

Заставляет Runnable r быть добавленным в очередь сообщений для запуска по истечении указанного времени. runnable будет запущен в потоке, к которому прикреплен этот обработчик.

• Runnable Представляет команду, которую можно выполнить.

• delayMillis представляет собой время, по истечении которого он должен быть выполнен.

По сути, он задерживает выполнение команды (возможно, некоторого кода) на определенный период времени (delayMillis), чтобы выполнить команду по истечении указанного времени.