首页 > 代码库 > 安卓线程相关 HandlerThread Handler Thread Looper Message Runnable

安卓线程相关 HandlerThread Handler Thread Looper Message Runnable

2024-07-21 05:10:55   216人阅读

本文由PurpleSword(jzj1993)原创，转载请注明
原文网址 http://blog.csdn.net/jzj1993

安卓主线程（UI线程）是线程不安全的：对UI控件的操作都应在主线程中完成；UI线程不应执行耗时操作，以免程序不响应（即ANR异常）


实现新线程的常用方法（注意要调用start方法启动新线程而不是run方法）：

一、定义类，实现Runnable接口

    class MyRunnable implements Runnable {
        /**
         * 实现接口的run方法
         */
        @Override
        public void run() {
            // run方法的中程序体将在新线程中执行
        }
    }
    new Thread(new MyRunnable()).start();


二、简洁写法

        new Thread(new Runnable() {
            @Override
            public void run() {
                // 新线程操作
            }
        }).start();


三、定义类，继承Thread（不推荐）：

    class MyThread extends Thread {
        /**
         * 覆写run方法
         */
        @Override
        public void run() {
            // 新线程操作
        }
    }
    new MyThread().start();


Thread和Runnable关系

    public class Thread extends Object implements Runnable {
    }


创建UI线程/主线程的Handler

一、（推荐写法，用于不处理消息，只是接收Runnable的情况下）

    // 无参数实例化时，会创建当前正在运行线程(即主线程)的Handler
    Handler handler = new Handler();

如果handler需要处理消息，按照以下写法将会产生警告This Handler class should be static or leaks might occur。此时可使用方法二）

    Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            }
        }
    };

二、（缺点在于需要定义一个新的类，写起来比较麻烦）

    // 无参数实例化时，会创建当前正在运行线程(即主线程)的Handler
    private Handler handler = new MyHandler() {
        // 处理其他线程发送的消息
        @Override
        public void handleMessage(Message msg) {
            Log.d("msg", "msg what = " + msg.what);
            switch (msg.what) {
            }
        }
    };

    protected static class MyHandler extends Handler {
    }

三、（推荐写法，可用于接收Runnable和处理消息的情况下）

    boolean handleMessage(Message msg) {
        switch (msg.what) {
        }
        return true;
    }

    private final Handler mainHandler = new Handler(Looper.getMainLooper(),
            new Handler.Callback() {
                @Override
                public boolean handleMessage(Message msg) {
                    return ActivityMain.this.handleMessage(msg);
                }
            });

在UI线程中执行程序

        handler.post(new Runnable(){
            @Override
            public void run() {
                // 操作UI控件等...
            }
        });


创建新线程的Handler

    private HandlerThread handlerThread;
    private Handler handler;

    this.handlerThread = new HandlerThread(getClass().getSimpleName());
    this.handlerThread.start();
    this.handler = new Handler(this.handlerThread.getLooper(),
            new Handler.Callback() {
                public boolean handleMessage(Message msg) {
                    return NewThread.this.handleMessage(msg);
                }
            });

    /**
     * 处理消息
     * 
     * @param msg
     * @return
     */
    private boolean handleMessage(Message msg) {
        switch (msg.what) {
        }
        return true;
    }

通过Message进行线程间通信：在任意线程中向其他线程Handler发送消息

    /**
     * 向线程Handler发送消息
     * 
     * @param id
     * @param o
     */
    protected void sendMsg(int id, Object o) {
        if (handler != null) {
            Message msg = Message.obtain();
            msg.obj = o;
            msg.what = id;
            handler.sendMessage(msg);
        }
    }

    /**
     * 向线程Handler发送消息
     * 
     * @param what
     */
    protected void sendMsg(int what) {
        if (handler != null) {
            handler.sendEmptyMessage(what);
        }
    }


    handler.sendMessageDelayed(msg, milliseconds);

    Message.obtain(handler, what, obj).sendToTarget();


安卓线程相关 HandlerThread Handler Thread Looper Message Runnable


联系
我们