Android 是否某个特定线程的所有处理程序对象都收到相同的消息

引用

在处理程序内部，重写handleMessage（）方法。Android系统在接收到它所管理的线程的新消息时调用此方法；特定线程的所有处理程序对象都接收相同的消息

我的疑问是：特定线程的所有处理程序对象都会收到相同的消息

我创建了一个活动，其中包含以下代码

@Override
        protected void onPostCreate(Bundle savedInstanceState) {
            // TODO Auto-generated method stub
            super.onPostCreate(savedInstanceState);
            self = new Handler(Looper.getMainLooper()){
                @Override
                public void handleMessage(Message msg) {
                    Log.e(TAG,"HAndle MainActivity: "+msg.what);
                };
            };
            sen = new Sender(new Handler(Looper.getMainLooper()), Thread.NORM_PRIORITY);
            sen.start();
            sen.repeatMsg();
        }

其中sender是一个线程，它创建一个

处理程序（Looper.getMainLooper（））

我所期望的是，分派的消息应该由

self

处理程序接收，因为两个处理程序都绑定到同一个线程，并且是引用语句所声明的。但是，

self的

handleMessage

从未被调用

为什么这么乱？？我误解了什么

我应该怎么做才能达到预期的行为

此外，再次考虑“代码>第二主活动< /代码>，类似于代码>主活动< /代码>，在一些单击事件上，例如，<代码>第二主活动< /代码>启动，代码<>代码> >代码>主程序< /代码>。同时，

Sender

线程仍在重复该消息。现在，谁将收到

handleMessge

呼叫

主要活动

第二个主要活动

发送器线程内的处理程序

没有

---

更新：2018年，如果不调用self.sendMessage？@pskink，文档仍然读取相同的

self Handler将如何接收任何内容，那么一个特定线程的所有处理程序对象将接收相同的消息。意味着什么？？调用

self.sendMessage

，无论在哪里（比如在四个活动和两个服务中）绑定了

mainlooper

的处理程序，都会收到对

handleMessage

的调用？我不知道它们的意思，但是，我知道消息只由发送消息的处理程序接收it@pskink但是句柄消息将在处理程序附加到的线程中被调用，对吗？是的，此语句完全不正确-

消息

s只传递给它们指定的目标

处理程序

，而不传递给其他线程。您可以通过查看

MessageQueue

和

Looper

的源代码来确认这一点。

public class Sender extends Thread{


    protected static final String TAG = "Sender";
    private Looper mLooper;
    private Handler uiHandler;
    private int mPriority;
    public Sender(Handler handler,int priority) {
        // TODO Auto-generated constructor stub
        mPriority = priority;
        uiHandler = handler;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        Log.e(TAG,"Inside run");
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        // setPriority(mPriority);
        Process.setThreadPriority(mPriority);
        Looper.loop();

        Handler msgHandler = new Handler(mLooper){
            @Override
            public void handleMessage(Message msg) {
                // TODO Auto-generated method stub
                Log.e(TAG,"Inside handleMessage "+msg.what);
            }
        };
    }

    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }

        // If the thread has been started, wait until the looper has been
        // created.
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }


    public void repeatMsg() {
Log.e(TAG,"Inside repeatMsg");
        Timer t = new Timer();
        TimerTask tt = new TimerTask() {

            @Override
            public void run() {
                Handler h = new Handler(Looper.getMainLooper());
                Message m = Message.obtain();
                m.what = 1000;
                h.dispatchMessage(m);//sendMessage(m);
                repeatMsg();
            }
        };
        t.schedule(tt, 2000);


    }



}