Android中的Handler

关注

原创最新推荐文章于 2026-07-23 16:18:49 发布 860 阅读 AI 写同款· GEO 优化 ›

Handler机制（二）——Message池和其他小问题（待更新） Message创建的时候除了new Message()之外，还有两种方式首先看第一个，是通过Handler对象来调用获取Message对象。可以看到obtainMessage()方法有多个重载，除了空参外，还可以传入一些参数，这些参数都是初始化Message对象使用的，是Message类中的属性。无一例外，他们都是调用的Message中的obtain方法，只是根据传入参数个数的不同，调用的是obtain方法的多个重载方法。阅读详情

1、主线程给自己发送Message

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private Handler mHandler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);

        mBtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {

                Looper looper = Looper.getMainLooper(); // 主线程的Looper对象,Looper looper2 = Looper.myLooper(); // looper == looper2
                // 这里以主线程的Looper对象创建了handler，
                // 所以，这个handler发送的Message会被传递给主线程的MessageQueue。
                mHandler = new LocalHandler(looper);
                mHandler.removeMessages(0);

                // 构建Message对象
                // 第一个参数：是自己指定的message代号，方便在handler选择性地接收
                // 第二三个参数没有什么意义
                // 第四个参数需要封装的对象
                Message msg = mHandler.obtainMessage(1, 2, 3, "主线程发消息了");

                mHandler.sendMessage(msg); // 发送消息
            }
        });
    }

    class LocalHandler extends Handler {

        public LocalHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    mText.setText("我是主线程的Handler，收到了消息：" + (String) msg.obj);
                    break;
            }
        }
    }
}

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private final Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    mText.setText("我是主线程的Handler，收到了消息：" + (String) msg.obj);
                    break;
            }
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);

        mBtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                mHandler.obtainMessage(1, "主线程发消息了").sendToTarget();
            }
        });
    }
}

2、其他线程给主线程发送Message

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private Handler mHandler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);

        mBtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // 可以看出这里启动了一个线程来操作消息的封装和发送的工作
                // 这样原来主线程的发送就变成了其他线程的发送，简单吧？呵呵
                new LocalThread().start();
            }
        });
    }

    // 加了一个线程类
    class LocalThread extends Thread {

        @Override
        public void run() {
            Looper looper = Looper.getMainLooper(); // 主线程的Looper对象，// Looper looper2 = Looper.myLooper(); // looper2 == null
            // 这里以主线程的Looper对象创建了handler，
            // 所以，这个handler发送的Message会被传递给主线程的MessageQueue。
            mHandler = new LocalHandler(looper);

            // 构建Message对象
            // 第一个参数：是自己指定的message代号，方便在handler选择性地接收
            // 第二三个参数没有什么意义
            // 第四个参数需要封装的对象
            Message msg = mHandler.obtainMessage(1, 2, 3, "其他线程发消息了");

            mHandler.sendMessage(msg); // 发送消息
        }
    }

    class LocalHandler extends Handler {

        public LocalHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    mText.setText("我是主线程的Handler，收到了消息：" + (String) msg.obj);
                    break;
            }
        }
    }
}

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private final Handler mHandler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    mText.setText("我是主线程的Handler，收到了消息：" + (String) msg.obj);
                    break;
            }
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);

        mBtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                new LocalThread().start();
            }
        });
    }

    // 加了一个线程类
    class LocalThread extends Thread {

        @Override
        public void run() {
            mHandler.obtainMessage(1, "其他线程发消息了").sendToTarget();
        }
    }
}

3、主线程给其他线程发送Message

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private Handler mThreadHandler;
    private Handler mMainHandler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);

                // 启动线程
        new MyThread().start();

        mBtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // 这里handler的实例化在线程中
                // 线程启动的时候就已经实例化了
                Message msg = mThreadHandler.obtainMessage(1, "主线程发送的消息");
                mThreadHandler.sendMessage(msg);
            }
        });
    }

    class MyHandler extends Handler {

        public MyHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            mText.setText("我是主线程的Handler，收到了消息：" + (String) msg.obj);
        }
    }

    class MyThread extends Thread {

        @Override
        public void run() {
            Looper.prepare(); // 创建该线程的Looper对象，用于接收消息

            // 注意了：这里的handler是定义在主线程中的哦，呵呵，
            // 前面看到直接使用了handler对象，是不是在找，在什么地方实例化的呢？
            // 现在看到了吧？？？呵呵，开始的时候实例化不了，因为该线程的Looper对象
            // 还不存在呢。现在可以实例化了
            // 这里Looper.myLooper()获得的就是该线程的Looper对象了
            mThreadHandler = new ThreadHandler(Looper.myLooper());


            // 这个方法，有疑惑吗？
            // 其实就是一个循环，循环从MessageQueue中取消息。
            // 不经常去看看，你怎么知道你有新消息呢？？？
            Looper.loop();
        }

        // 定义线程类中的消息处理类
        class ThreadHandler extends Handler {
            public ThreadHandler(Looper looper) {
                super(looper);
            }

            @Override
            public void handleMessage(Message msg) {
                // 这里对该线程中的MessageQueue中的Message进行处理
                // 这里我们再返回给主线程一个消息
                mMainHandler = new MyHandler(Looper.getMainLooper());
                Message msg2 = mMainHandler.obtainMessage(1, 1, 1, "子线程收到:" + (String) msg.obj);
                mMainHandler.sendMessage(msg2);
            }
        }
    }
}

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private Handler mThreadHandler;

    private final Handler mMainHandler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 11:
                    Log.d("gg", (String) msg.obj + msg.what);
                    mText.setText("我是主线程的Handler，收到了消息：" + (String) msg.obj);
                    break;
            }
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);

        // 启动线程
        new MyThread().start();

        mBtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // 这里handler的实例化在线程中，不知道何时创建成功，所以在使用前先判断下，否则可能crash
                if (mThreadHandler != null) {
                    mThreadHandler.obtainMessage(1, "主线程发送的消息").sendToTarget();
                }
            }
        });
    }

    class MyThread extends Thread {

        @Override
        public void run() {
            Looper.prepare(); // 创建该线程的Looper对象，用于接收消息

            // 注意了：这里的handler是定义在主线程中的哦，呵呵，
            // 前面看到直接使用了handler对象，是不是在找，在什么地方实例化的呢？
            // 现在看到了吧？？？呵呵，开始的时候实例化不了，因为该线程的Looper对象还不存在呢。现在可以实例化了
            // 这里Looper.myLooper()获得的就是该线程的Looper对象了
            mThreadHandler = new ThreadHandler(Looper.myLooper());

            // 这个方法，有疑惑吗？
            // 其实就是一个循环，循环从MessageQueue中取消息。
            // 不经常去看看，你怎么知道你有新消息呢？？？
            Looper.loop();
        }

        // 定义线程类中的消息处理类
        class ThreadHandler extends Handler {

            public ThreadHandler(Looper looper) {
                super(looper);
            }

            @Override
            public void handleMessage(Message msg) {
                // 这里对该线程中的MessageQueue中的Message进行处理
                // 这里我们再返回给主线程一个消息
                switch (msg.what) {
                    case 1:
                        Log.d("gg", (String) msg.obj + msg.what);
                        mMainHandler.obtainMessage(11, "子线程收到:" + (String) msg.obj).sendToTarget();
                        break;
                }

            }
        }
    }
}
// 09-02 16:30:10.658: D/gg(7800): 主线程发送的消息1
// 09-02 16:30:10.658: D/gg(7800): 子线程收到:主线程发送的消息11

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private Handler mThreadHandler;

    private final Handler mMainHandler = new Handler() {

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 11:
                    Log.d("gg", (String) msg.obj + msg.what);
                    mText.setText("我是主线程的Handler，收到了消息：" + (String) msg.obj);
                    break;
            }
        }
    };

    // 定义线程类中的消息处理类
    class ThreadHandler extends Handler {

        public ThreadHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            // 这里对该线程中的MessageQueue中的Message进行处理
            // 这里我们再返回给主线程一个消息
            switch (msg.what) {
                case 1:
                    Log.d("gg", (String) msg.obj + msg.what);
                    mMainHandler.obtainMessage(11, "子线程收到:" + (String) msg.obj).sendToTarget();
                    break;
            }
        }
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);

        HandlerThread handlerThread = new HandlerThread("xiancheng");
        handlerThread.start();
        mThreadHandler = new ThreadHandler(handlerThread.getLooper());

        mBtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // 这里handler的实例化在线程中，不知道何时创建成功，所以在使用前先判断下，否则可能crash
                if (mThreadHandler != null) {
                    mThreadHandler.obtainMessage(1, "主线程发送的消息").sendToTarget();
                }
            }
        });
    }
}

4、其他线程给自己发送Message

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private Handler mThreadHandler;
    private Handler mMainHandler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);

        mBtn.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // 启动线程
                new MyThread().start();
            }
        });
    }

    class MyHandler extends Handler {

        public MyHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            mText.setText((String) msg.obj);
        }
    }

    class MyThread extends Thread {

        @Override
        public void run() {
            Looper.prepare(); // 创建该线程的Looper对象
            // 这里Looper.myLooper()获得的就是该线程的Looper对象了
            mThreadHandler = new ThreadHandler(Looper.myLooper());
            Message msg = mThreadHandler.obtainMessage(1, "我自己");
            mThreadHandler.sendMessage(msg);

            Looper.loop();
        }

        // 定义线程类中的消息处理类
        class ThreadHandler extends Handler {

            public ThreadHandler(Looper looper) {
                super(looper);
            }

            @Override
            public void handleMessage(Message msg) {
                // 这里对该线程中的MessageQueue中的Message进行处理
                // 这里我们再返回给主线程一个消息
                // 加入判断看看是不是该线程自己发的信息
                if (msg.what == 1) {
                    mMainHandler = new MyHandler(Looper.getMainLooper());
                    Message msg2 = mMainHandler.obtainMessage(1, "禀告主线程:我收到了自己发给自己的Message");
                    mMainHandler.sendMessage(msg2);
                }
            }
        }
    }
}

public class MainActivity extends Activity {
    private Button mBtn;
    private TextView mText;
    private Handler mHandler;
    private Handler mMainHandler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        mBtn = (Button) this.findViewById(R.id.btn);
        mText = (TextView) this.findViewById(R.id.view);
        mBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View arg0) {
                // 启动线程
                new MyThread().start();
            }
        });
    }

    class MainHandler extends Handler {
        public MainHandler(Looper looper) {
            super(looper);
        }
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 11:
                    Log.d("gg", (String) msg.obj + msg.what);
                    mText.setText((String) msg.obj);
                    break;
            }
        }
    }

    class MyThread extends Thread {
        @Override
        public void run() {
            Looper.prepare(); // 创建该线程的Looper对象
            // 这里Looper.myLooper()获得的就是该线程的Looper对象了
            // Looper looper = Looper.getMainLooper();
            // Looper looper2 = Looper.myLooper(); // looper2 != looper
            mHandler = new ThreadHandler(Looper.myLooper());
            mHandler.obtainMessage(1, 2, 3, "我自己").sendToTarget();
            Looper.loop();
        }

        // 定义线程类中的消息处理类
        class ThreadHandler extends Handler {

            public ThreadHandler(Looper looper) {
                super(looper);
            }

            @Override
            public void handleMessage(Message msg) {
                // 这里对该线程中的MessageQueue中的Message进行处理
                // 这里我们再返回给主线程一个消息
                // 加入判断看看是不是该线程自己发的信息
                switch (msg.what) {
                    case 1:
                        Log.d("gg", (String) msg.obj + msg.what);
                        mMainHandler = new MainHandler(Looper.getMainLooper());
                        mMainHandler.obtainMessage(11, 22, 33, "禀告主线程:我收到了自己发给自己的Message").sendToTarget();
                        break;
                }
            }
        }
    }
}
// 09-02 16:06:42.322: D/gg(7001): 我自己1
// 09-02 16:06:42.338: D/gg(7001): 禀告主线程:我收到了自己发给自己的Message11

class LooperThread extends Thread {
    public Handler mHandler;

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

        mHandler = new Handler() {

            @Override
            public void handleMessage(Message msg) {

            }
        };

        Looper.loop();
    }
}

//通过Handler启动线程    
HandlerThread handlerThread = new HandlerThread("threadone");  
handlerThread.start();  
mHandler =  new Handler(handlerThread.getLooper());//那么这个Handler对象就是与HandlerThread这个线程绑定了（这时就不再是与UI线程绑定了，这样它处理耗时操作将不会阻塞UI）
mHandler.post(mRunnable);    

private Runnable mRunnable = new Runnable() {   
	@Override
	public void run() {    
		count++;    
		//setTitle("" +count);    
		//每2秒执行一次    
		mHandler.postDelayed(mRunnable, 2000);    
    }    
};

是MessageQueue的管理者。

每一个MessageQueue都不能脱离Looper而存在，Looper对象的创建是通过prepare()函数来实现的。同时每一个Looper对象和一个线程关联。
通过调用Looper.myLooper()可以获得当前线程的Looper对象
创建一个Looper对象时，会同时创建一个MessageQueue对象。除了主线程有默认的Looper，其他线程默认是没有MessageQueue对象的，所以，不能
接受Message。
如需要接受，自己定义一个Looper对象(通过prepare函数),这样该线程就有了自己的Looper对象和MessageQueue数据结构了。
Looper从MessageQueue中取出Message然后，交由Handler的handleMessage进行处理。处理完成后，调用Message.recycle()将其放入Message Pool中。

http://www.eoeandroid.com/thread-49595-1-1.html?_dsign=7a783b06

Android 之 Looper、MessageQueue、Handler 与消息循环

Handler主要用来发送消息和处理消息。每个handler实例都对应着一个线程和该线程的消息队列。
当你创建一个handler对象时，该handler对象就属于创建它的线程，并和该线程的消息队列绑定，比如在主线程中创建handler对象，那么该handler就只属于主线程，并且和主线程的消息队列绑定。