wake-up-neo.com

Führen Sie Handler-Meldungen in einem Hintergrundthread aus

Ich möchte etwas Runnable in einem Hintergrundthread ausführen. Ich möchte Handler verwenden, weil es für Verzögerungen praktisch ist ... Was ich meine, ist

handler.post(runnable, delay);

Worunnable sollte in background Thread ..__ ausgeführt werden. Ist es möglich, einen solchen Handler zu erstellen? Gibt es irgendwo einen "Hintergrund" -Looper oder wie kann ich ihn erstellen?

P.S. Ich weiß, wie man es mit einer benutzerdefinierten Klasse macht, erweitert Thread aber es erfordert etwas mehr Codieraufwand, als es mit dem Handler zu tun. Also bitte keine anderen Lösungen oder ähnliches posten

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

Ich wandere nur ab, wenn Handler es auf "saubere" Weise tun kann.

32

Sie können dies einfach tun:

private Handler mHandler = null;

private HandlerThread mHandlerThread = null;

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

Dann rufen Sie mit auf:

handler.postDelayed(new Runnable(),1000);
63

Sie können so etwas versuchen

    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();
    }
7
Ayman Mahgoub

Sie können einen Looper mit Looper.prepare() und Looper.loop in einem Hintergrundthread einrichten.

5
Yuichi Araki

Nicht klar, was Sie mit Handler meinen.

Es klingt, als ob Sie einen Thread benötigen, dem Prozesse zugeführt werden, die von einer Warteschlange ausgeführt werden. Sie würden wahrscheinlich von der Untersuchung von Executors here profitieren, aber hier ist ein einfaches Paar aus zwei Threads, das über eine Warteschlange kommuniziert.

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();
  }
}
0
OldCurmudgeon