自定义Looper/Handler模型 线程wait/notify版本 非poll版本

循环

    public static class Looper {

        final static ThreadLocal<Looper> threadLooper = new ThreadLocal<>();

        public static void prepare() {
            if (threadLooper.get() != null) {
                throw new RuntimeException("此线程已经创建了Looper");
            }
            threadLooper.set(new Looper());
        }

        private Looper() {

        }

        static Looper mLooper() {
            return threadLooper.get();
        }

        MessageQueue queue = new MessageQueue();

        void loop() {
            for (; ; ) {
                System.out.println("loop loop");
                Message next = queue.lastOrNull();
                if (next == null) {
                    return;
                }

                System.out.println("deal message = " + next.code);
                next.target.handleMessage(next);
                queue.remove(next);

            }
        }

    }

消息

static class Message {
        int code = 0;
        Handler target;
    }

消息队列

简单用stack结构构建了下

static class MessageQueue extends Stack<Message> {

        private final Object lock = new Object();

        Message lastOrNull() {

            for (; ; ) {
                System.out.println("message queue");
                try {
                    return lastElement();
                } catch (Exception e) {
                    synchronized (lock) {
                        try {
                            lock.wait();
                        } catch (InterruptedException interruptedException) {
                            interruptedException.printStackTrace();
                        }

                    }
                }

            }
        }

        @Override
        public Message push(Message item) {
            Message push = super.push(item);
            synchronized (lock) {
                try {
                    lock.notify();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return push;
        }
    }

处理消息

abstract static class Handler {

        private final Looper mLooper;

        public Handler() {
            this(Looper.mLooper());
        }

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

        abstract void handleMessage(Message message);

        void sendMessage(Message message) {
            message.target = this;
            mLooper.queue.push(message);
        }

    }

main方法

public static void main(String[] args) {


        Looper.prepare();
        Looper looper = Looper.mLooper();
        Handler handler = new Handler(looper) {
            @Override
            void handleMessage(Message message) {
                if (message.code > 0) {
                    message.code--;
                    sendMessage(message);
                }
            }
        };
        new Thread() {
            @Override
            public void run() {

                for (int i = 0; i < 3; i++) {
                    Message m = new Message();
                    m.code = i * 10;
                    handler.sendMessage(m);
                }

            }
        }.start();
        looper.loop();

        System.out.println("========end");

    }