Handler、Looper、Message简易实现

简述

• Handler 处理类
• Looper 循环类,包含消息队列,包含一个循环线程
• Message 消息类

实现

• 可以发送消息,会在一个子线程中处理消息内容,需要手动调用quit停止线程工作.可以发送runnable执行任务,可以延时.
• Message类

public class Message {
    public String name;
    public int what; //消息类型
    public int arg1;
    public int arg2;
    public Object obj; //附加对象
    public Runnable runnable; //runnable 执行对象
    public long when;
    public Handler handler;

    public Message() {
        this(0, null, null);
    }

    public Message(Runnable runnable) {
        this(0, null, runnable);
    }

    public Message(int what) {
        this(what, null, null);
    }

    public Message(int what, Object obj) {
        this(what, obj, null);
    }

    public Message(int what, Object obj, Runnable runnable) {
        this.what = what;
        this.obj = obj;
        this.runnable = runnable;
    }

    @Override
    public String toString() {
        return "Message is +" +
                " name = " + name +
                " what = " + what +
                " arg1 = " + arg1 +
                " arg2 = " + arg2;
    }
}

• handler 类

public class Handler {

    private Looper mLooper;

    public Handler() {
        mLooper = new Looper();
        mLooper.startLoop();
    }

    public Handler(Looper looper) {
        mLooper = looper;
        mLooper.startLoop();
    }

    public void post(Runnable r) {
        Message msg = new Message(r);
        sendMessageDelayed(msg, 0);
    }
    public void postDelayed(Runnable r,long delayMillis) {
        Message msg = new Message(r);
        sendMessageDelayed(msg, delayMillis);
    }

    //sub class need to implement
    public void handleMessage(Message msg) {
    }

    public void sendEmptyMessage(int what) {
        Message msg = new Message(what);
        sendMessageDelayed(msg, 0);
    }

    public void sendMessage(Message msg) {
        sendMessageDelayed(msg, 0);
    }

    public void sendMessageDelayed(Message msg, long delayMillis) {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        msg.when = System.currentTimeMillis() + delayMillis;
        msg.handler = this;
        mLooper.addMessage(msg);
    }

    public void dispatchMessage(Message msg){
        if (msg.runnable != null){
            msg.runnable.run();
            return;
        }
        handleMessage(msg);
    }

    public Looper getLooper(){
        return mLooper;
    }
}

• Looper类

public class Looper {
    private List<Message> messages = new LinkedList<>();
    private Object mLock = new Object();
    private boolean quitFlag = false;
    private Thread mThread = new Thread() {
        @Override
        public void run() {
            loop();
        }
    };

    public Looper() {
    }

    public void startLoop() {
        mThread.start();
    }

    //loop 循环
    public void loop() {
        for (; ; ) {
            if (quitFlag == true) {
                return;
            }
            if (messages.isEmpty()) {
                continue;
            }
            Message msg = messages.get(0);

            if (msg.when > System.currentTimeMillis()) {
                continue;
            }
            msg.handler.dispatchMessage(msg);
            messages.remove(msg);
        }
    }

    public boolean addMessage(Message msg) {
        if (msg == null) {
            return false;
        }
        if (msg.when == 0) {
            msg.when = System.currentTimeMillis();
        }

        for (int i = 0; i < messages.size(); i++) {
            if (msg.when < messages.get(i).when) {
                messages.add(i, msg);
                return true;
            }
        }
        messages.add(msg);
        return true;
    }

    public boolean quit() {
        quitFlag = true;
        return true;
    }
}

• 主类

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(TAG, ">>>>>>>>>>>>>>>>>>>>");
        //内存泄露
        final Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                String info = (String) msg.obj;
                switch (msg.what) {
                    case 0:
                        Log.d(TAG, msg.toString());
                        Log.d(TAG, info);
                        break;
                    case 1:
                        Log.d(TAG, msg.toString());
                        Log.d(TAG, info + " ");
                        break;
                    case 2:
                        Log.d(TAG, msg.toString());
                        Log.d(TAG, info);
                        break;
                }

            }
        };

        Message msg = new Message();
        msg.what = 0;
        msg.obj = "msg 0, delay msg";
        handler.sendMessageDelayed(msg,10000);

        handler.sendEmptyMessage(1);

        Message msg2 = new Message(2,"msg 2");
        handler.sendMessage(msg2);

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                Log.d(TAG, "quit loop");
                handler.getLooper().quit();
            }
        };
        handler.postDelayed(runnable,20000);
    }
}