Выполнять сообщения обработчика в фоновом потоке

Я хочу запустить Runnable в фоновом потоке. Я хочу использовать Handler, потому что он удобен для задержек. Я имею в виду

handler.post(runnable, delay);

Где runnable должен выполняться в background Thread. Можно ли создать такого обработчика? Есть ли "фона" Looper где-нибудь или как его создать?

P.S. Я знаю, как это сделать с помощью настраиваемого класса extends Thread, но для этого требуется немного больше усилий по кодированию, чем выполнение этого метода обработчика. Поэтому, пожалуйста, не публикуйте другие решения или что-то вроде

handler.post(new Runnable() {
    @Override
    public void run() {
        new Thread() {
            @Override
            public void run() {
                //action
            }
        }.start();
    }
});

Я просто блуждаю, если Хендлер может сделать это "чистым" способом.

Ответы

Ответ 1

Вы можете просто сделать это:

private Handler mHandler;

private HandlerThread mHandlerThread;

public void startHandlerThread(){
    mHandlerThread = new HandlerThread("HandlerThread");
    mHandlerThread.start();
    mHandler = new Handler(mHandlerThread.getLooper());
}

Затем вызовите с помощью:

mHandler.postDelayed(new Runnable() {
        @Override
        public void run() {
          // Your task goes here
        }
    },1000);

Ответ 2

Вы можете попробовать что-то вроде этого

    private void createHandler() {
        Thread thread = new Thread() {
            public void run() {
                Looper.prepare();

                final Handler handler = new Handler();
                handler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                       // Do Work
                        handler.removeCallbacks(this);
                        Looper.myLooper().quit();
                   }
                }, 2000);

                Looper.loop();
            }
        };
        thread.start();
    }

Ответ 4

Не понятно, что вы подразумеваете под Handler.

Похоже, вам нужен поток, который обрабатывает процессы для выполнения очереди. Вероятно, вам будет полезно исследовать Executor здесь, но здесь простая двухпоточная пара, которая обменивается данными через очередь.

public class TwoThreads {
  public static void main(String args[]) throws InterruptedException {
    System.out.println("TwoThreads:Test");
    new TwoThreads().test();
  }
  // The end of the list.
  private static final Integer End = -1;

  static class Producer implements Runnable {
    final Queue<Integer> queue;

    public Producer(Queue<Integer> queue) {
      this.queue = queue;
    }

    @Override
    public void run() {
      try {
        for (int i = 0; i < 1000; i++) {
          queue.add(i);
          Thread.sleep(1);
        }
        // Finish the queue.
        queue.add(End);
      } catch (InterruptedException ex) {
        // Just exit.
      }
    }
  }

  static class Consumer implements Runnable {
    final Queue<Integer> queue;

    public Consumer(Queue<Integer> queue) {
      this.queue = queue;
    }

    @Override
    public void run() {
      boolean ended = false;
      while (!ended) {
        Integer i = queue.poll();
        if (i != null) {
          ended = i == End;
          System.out.println(i);
        }
      }
    }
  }

  public void test() throws InterruptedException {
    Queue<Integer> queue = new LinkedBlockingQueue<>();
    Thread pt = new Thread(new Producer(queue));
    Thread ct = new Thread(new Consumer(queue));
    // Start it all going.
    pt.start();
    ct.start();
    // Wait for it to finish.
    pt.join();
    ct.join();
  }
}