java——利用生产者消费者模式思想实现简易版handler机制

参考教程：http://www.sohu.com/a/237792762_659256

首先说一下这里面涉及到的线程：

1.mainLooper：

　　这个线程可以理解为消费者线程，里面运行了一个死循环，不断进行消息出队和处理消息这两个动作。

2.workLooper：

　　这个线程就相当于是生产者线程，进行消息入队。

3.程序本身的线程：

　　这个线程是隐式的，也就是我们运行程序的这个线程，知道有这样一个东西的存在能帮助我们理解整个程序的运行。

然后介绍每一个类：

1.Message：

　　这个类的作用是存储一个生产者生产出来的具体的消息，就类似链表队列中的一个节点，自行定义需要存储的内容。

　　code：消息要执行的具体动作代码

　　msg：消息内容

　　target：用来关联hadler,根本目的时为了使这几个类共享一个MessageQueue，这个很重要

2.MessageQueue：

　　这个类就是生产者和消费者线程需要共享的一个存储消息的队列，生产者将消息放入这个队列，消费者取出消息并处理。

　　内部实现是用了BlockingQueue，这个队列特别的地方就是出队和入队的时候是阻塞的，也就是说当队列中没有元素的时候，出队这个动作会引起线程阻塞，直到有元素入队；同理入队也会因为队列满而引起线程阻塞，直到有元素出队。

　　这个类中定义了两个方法：next和enqueueMessage分别对应出对和入队。　　

　　需要考虑的就是如何将生产者和消费者多线程共享这个队列？这个在下面解释。

3.Looper

　　这个类是整个机制的核心，理解了这个类这个机制怎样运行的也就基本清楚了。

　　这个类主要是为mainThread服务的，类中定义了一个静态常量ThreadLocal，用来保存某个线程的共享变量，在这里它存的是一个：Looper，也就是这个类本身的一个实例。

　　mainThread这个线程需要在开始线程的时候通过Looper.prepareMainLooper()创建一个looper。然后调用loop()，这个函数就是mainThread的主循环，不断地做两件事：消息出队和处理消息。

4.Handler：

　　这个类主要定义了两个方法：sendMessage()和handleMessage(),即发送消息和处理消息，其中sendMessage()就是将消息入队，而handleMessage()设计成抽象方法，根据不同的实际情况设计不同的消息处理方法。

介绍完这四个类之后，要思考的就是生产者和消费者对MessageQueue的共享问题：

　　主程序开启了mainThread进程，这个进程在一开始就创建了一个Looper和一个mq，由于一开始这个mq是一个空队列，mainThread执行到loop()里的for循环时被阻塞在msg = me.mq.next();此时的程序并不会因此停止，而是向下执行，创建了一个handler，hadler中传入了mainThread中创建的那个Looper，并将这个Looper中的mq和hadler中的mq相关联，换句话说，此时handler中的mq就是mainThread中looper的mq。程序接着往下走，又创建了一个workThread，这个线程传入message，这个message除了保存了自身的信息之外，还保存了刚刚创建的handler，把这样的message传入workThread执行入队操作时，就能够将这个message存入handler中的mq中，此时也就将生产者和消费者这两个线程的MessageQueue指向了同一片内存。

　　为什么要把MainThread创建的looper保存在ThreadLocal中？为什么要设置成static final？

　　　　这个东西叫做线程本地变量，也有些地方叫做线程本地存储，其实意思差不多。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。

　　　　looper是在MainThread中创建的，也就是说每创建一个MainThead，这个MainThread中有就一个looper这样一个变量，不同的MainThread中有不同的looper。

　　　　设置成static final 这样就保证Looper这个类在创建的时,ThreadLocal就已经声明和创建。

思考的还是不太全面，先把代码先贴在这里：

Message.java

package Handler_test;

public class Message {

    private int code;

    private String msg;

    Handler target;

    public Message() {

    }

    public Message(int code, String msg, Handler handler) {

        this.code = code;

        this.msg = msg;

        this.target = handler;

    }

    public  int getCode() {

        return code;

    }

    public void setCode(int code) {

        this.code = code;

    }

    public String getMsg() {

        return this.msg;

    }

    public void setMsg(String msg) {

        this.msg = msg;

    }

}

MessageQueue.java

package Handler_test;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.LinkedBlockingQueue;

public class MessageQueue implements IMessageQueue{

    private BlockingQueue<Message> queue;

    public MessageQueue(int cap) {

        this.queue = new LinkedBlockingQueue<>(cap);

    }

    @Override

    public Message next() throws InterruptedException {

        // TODO Auto-generated method stub

        return queue.take();

    }

    @Override

    public void enqueueMessage(Message msg) throws InterruptedException {

        // TODO Auto-generated method stub

        try {

            queue.put(msg);

        }catch(InterruptedException e) {

            e.printStackTrace();

        }

    }

}

Handler.java

package Handler_test;

public abstract class Handler {

    private MessageQueue mq;

    public Handler(Looper looper) {

        mq = looper.mq;

    }

    public Handler() {

        Looper.myLooper();

    }

    public void sendMessage(Message msg) {

        try {

            mq.enqueueMessage(msg);

        }catch(InterruptedException e){

            e.printStackTrace();

        }

    }

    public  abstract void handleMessage(Message msg);

}

Looper.java

package Handler_test;

public class Looper {

    MessageQueue mq;

    //用来保存某个线程的共享变量

    //为什么要做成常量？

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

    private static Looper sMainLooper;

    public Looper() {

        mq = new MessageQueue(2);

    }

    public static void prepare() {

        if(sThreadLocal.get() != null) {

            throw new RuntimeException("一个线程只能创建一个looper");

        }

        sThreadLocal.set(new Looper());

    }

    public static void prepareMainLooper() {

        prepare();

        //??直接写Looper行么

        synchronized(Looper.class) {

            if(sMainLooper != null) {

                throw new IllegalStateException("The main Looper has already been prepared.");

            }

            sMainLooper = myLooper();

        }

    }

    public static Looper myLooper() {

        // TODO Auto-generated method stub

        return sThreadLocal.get();

    }

    public static Looper getMainLooper() {

        return sMainLooper;

    }

    public static void Loop() {

        final Looper me = myLooper();

        if(me == null) {

            throw new RuntimeException("No looper; Looper.prepared() wasn't called on this thread");

        }

        for(;;) {

            Message msg = null;

            try {

                msg = me.mq.next();

            }catch(InterruptedException e) {

                e.printStackTrace();

            }

            if(msg != null) {

                msg.target.handleMessage(msg);

            }

        }

    }

}

Main.java

package Handler_test;

import java.util.Random;

public class Main {

    public static void main(String[] args) {

        MainThread mainThread = new MainThread();

        //这里start()创建一个执行run()方法的新线程

        //调用start方法表示此进程处于 可运行状态 ，但并不一定正在运行

        //线程的调度依赖系统提供的服务

        mainThread.start();

        //mainThread在准备looper时耗时，而程序的读取不会因为线程的耗时而停止

        //但是之后的程序需要mainThread创建好looper后才能执行

        //我认为Thread.sleep(100);是表示这个程序的线程，

        //而不是mainThread以及workThread中的任何一个

        //当looper创建好后Looper.getMainLooper()判断非空，跳出循环，程序向下执行

        //mainThread在创建完looper后由于mq中没有消息而卡在了msg = me.mq.next();

        while(Looper.getMainLooper() == null) {

            try {

                Thread.sleep(100);

            }catch(InterruptedException e) {

                e.printStackTrace();

            }

        }

        //这里传入了mainThread中创建的looper

        //handler的构造函数中：mq = looper.mq;也将looper中的mq传给了handler

        //这样looper中的mq就和handler中的mq关联起来了

        //也就是共用一片内存

        Handler handler = new Handler(Looper.getMainLooper()) {

            @Override

            public void handleMessage(Message msg) {

                System.out.println("execute in: " +

            Thread.currentThread().getName());

                switch(msg.getCode()) {

                case 0:

                    System.out.println("0 case");

                    break;

                case 1:

                    System.out.println("1 case");

                    break;

                case 2:

                    System.out.println("2 case");

                    break;

                default:

                    System.out.println("default");

                    break;

                }

            }

        };

        //将前面写好的handler传入msg中

        Message msg1 = new Message(0, "first", handler);

        WorkThread workThread1 = new WorkThread(handler, msg1);

        Message msg2 = new Message(2, "two", handler);

        WorkThread workThread2 = new WorkThread(handler, msg2);

        workThread1.start();

        workThread2.start();

        //workThread中的run方法执行入队操作handler.sendMessage(message);

        //这时将msg放入了handler中定义的那个mq

        //这个mq同时也是looper中的那个mq

        //此时由于mq这个队列不为空，mainThread被唤醒

        //继续执行msg.target.handleMessage(msg);

        //由于loop()是一个死循环，mainThread在处理完一条msg之后会继续取下一条msg

        //循环这个过程

    }

    //为什么要把这两个线程做成内部类，放在外面不行么？

    public static class WorkThread extends Thread{

        private Handler handler;

        private Message message;

        public WorkThread(Handler handler, Message message) {

            setName("Work Thread");

            this.handler = handler;

            this.message = message;

        }

        @Override

        public void run() {

            //这句话可以不写么？

            super.run();

            //模拟耗时

            Random random = new Random();

            try {

                Thread.sleep(random.nextInt(10)*30);

            }catch(InterruptedException e) {

                e.printStackTrace();

            }

            //消息入队

            handler.sendMessage(message);

        }

    }

    public static class MainThread extends Thread{

        public MainThread() {

            setName("MainThread");

        }

        @Override

        public void run() {

            super.run();

            Looper.prepareMainLooper();

            System.out.println(getName() + " the looper is prepared.");

            Looper.Loop();

        }

    }

}

巴特西

java——利用生产者消费者模式思想实现简易版handler机制

最新文章

热门文章