关闭

ZeroMQ(java)中对IO的封装(StreamEngine.java)

1222人阅读 评论(0) 收藏 举报
分类:

哎,各种各样杂七杂八的事情。。。好久没有看代码了,其实要搞明白一个与IO相关的框架,最好的办法就是把它的I/0的读写两个过程搞清楚。。。例如在netty中,如果能将eventLoop的运行原理搞清楚,然后摸清楚整个I/O读写两个过程,那么也就差不太多了。。。。

这次来看看ZeroMQ(java)中如何来处理I/O的,先来看看一个类型的定义,IOObject类型,这个类型应该扮演的是工具类的形象,前面看过在ZeroMQ中所谓的IO线程的定义,那么IOObject就是用于直接与IO线程交互的,或者说的更直接的一点就是它是与IO线程里的poller对象交互的。。。

那么先来看看IOObject的类图吧:



这张图应该将IOObject与IOThread以及Poller之间的关系表现的很清楚了吧。。。。IOObject实现了IPollEvents接口,那么也就代表它可以响应IO事件。。。不过其实它并不直接实现这些IO事件,而是将其委托给内部的一个IPollEvents对象。。只不过是做了一层代理而已。。。


好了,接下来来看看IOObject的代码吧,先来看看它的属性申明:

    private Poller poller;   //poller对象
    private IPollEvents handler;   //用于执行事件回调的handler

这个poller就是从IO线程里面获取过来的,handler就是刚刚提到的事件回调的处理对象。。。IOObject不过是对其进行了一层包装而已。。。

那么接下来来看看重要的方法定义:

    //在将一个IO对象加入到一个IO线程的时候,要注意确定当前IO对象之前没有加入到任何IO线程或者已经从别的IO线程上面退下来了
    //将当前这个IO对象加入到IO线程上面去,说白了主要是获取这个IO线程的poller对象
    public void plug(IOThread io_thread_) {
        assert (io_thread_ != null);
        assert (poller == null);
        poller = io_thread_.get_poller ();      //获取这个线程的poller对象
    }

这个方法用于将当前这个IO对象加入到一个IO线程,其实主要的是要获取这个IO线程的Poller对象。。好了,接下来再来看看如何注册channel以及事件吧:

    //在poller里面移除channel
    public final void rm_fd(SelectableChannel handle) {
        poller.rm_fd(handle);
    }
    //给这个channel注册读取的事件
    public final void set_pollin (SelectableChannel handle_) {
        poller.set_pollin (handle_);
    }
    //在这个channel上面注册写事件
    public final void set_pollout (SelectableChannel handle_) {
        poller.set_pollout (handle_);
    }
    //注册链接事件
    public final void set_pollconnect(SelectableChannel handle) {
        poller.set_pollconnect(handle);
    }
    //注册accept事件
    public final void set_pollaccept(SelectableChannel handle) {
        poller.set_pollaccept(handle);
    }
    //取消读取事件的注册
    public final void reset_pollin(SelectableChannel handle) {
        poller.reset_pollin (handle);
    }

    //取消写事件的注册
    public final void reset_pollout(SelectableChannel handle) {
        poller.reset_pollout (handle);
    }

这部分代码应该很简单吧,而且应该对IOObject的用处比较的清楚了,然后至于说IOObject对象如何响应in_event什么的,前面已经说过了,其实是委托给了handler对象来处理。。。好啦,IOObject的分析就算差不多了。。接下来来看看StreamEngine类型的实现吧,还是先来看看它初略的类图吧:



其实觉得看一个类的类图,基本上就能看出这个类的很多情况,好了,不说闲话了,来看看它的属性的定义吧:

    private static final int GREETING_SIZE = 12;   //问候msg的大小,12个字节  (10字节的头,1字节的版本,1字节的socket类型)
    
    //  True iff we are registered with an I/O poller.
    private boolean io_enabled;   //如果是true的话,表示当前已经注册到了poller上面去
    
    private SocketChannel handle;   //真正底层用于通信的socketChannel

    private ByteBuffer inbuf;  //接收数据的buf
    private int insize;   //记录接收的数据的大小
    private DecoderBase decoder;  //decoder

    private Transfer outbuf;   //outbuf
    private int outsize;   //outbuf的大小
    private EncoderBase encoder;  //encoder

    //  When true, we are still trying to determine whether
    //  the peer is using versioned protocol, and if so, which
    //  version.  When false, normal message flow has started.
    private boolean handshaking;  //是否是在握手中,当值为false的时候代表握手已经完成了
    
    //  The receive buffer holding the greeting message
    //  that we are receiving from the peer.
    private final ByteBuffer greeting;  //用于接收问候msg的buf

    //  The send buffer holding the greeting message
    //  that we are sending to the peer.
    private final ByteBuffer greeting_output_buffer;  //用于发送问候msg的buf
    
    private SessionBase session;    //所属的session


    private Options options;  //选项配置

    // String representation of endpoint
    private String endpoint;   //这里一般是地址信息

    private boolean plugged;   //是否已经加入了
    private boolean terminating;  //是否已经停止了
    
    // Socket
    private SocketBase socket;  //所属的socket
    
    private IOObject io_object;    //拥有的IO对象

这里面有很多重要的属性,例如handler是SocketChannel类型的,可以知道它才是实际上底层用于通信的,然后又inbuf以及outbuf,这两个东西是干嘛用的应该一眼就看出来了吧,然后还有encoder和decoder,呵呵,可以猜到,读取到的数据先要经过decoder的处理才提交给上层,发送出去的数据也会通过encoder处理成二进制再发送出去。。。然后还有一个io_objcet对象。。。

接下来来看看构造方法吧:

    //构造函数,第一个参数是底层的channel,
    public StreamEngine (SocketChannel fd_, final Options options_, final String endpoint_) 
    {
        handle = fd_;
        inbuf = null;
        insize = 0;
        io_enabled = false;
        outbuf = null;
        outsize = 0;
        handshaking = true;  //初始化为ture,表示还没有完成握手
        session = null;
        options = options_;
        plugged = false;
        terminating = false;
        endpoint = endpoint_;
        socket = null;
        greeting = ByteBuffer.allocate (GREETING_SIZE);  //创建用于接收问候msg的buf
        greeting_output_buffer = ByteBuffer.allocate (GREETING_SIZE);   //创建用于发送握手信息的buf
        encoder = null;
        decoder = null;


        try {
            Utils.unblock_socket (handle);  //将底层的channel设置为非阻塞的
            if (options.sndbuf != 0) {  //设置底层的socket的发送缓冲大小
                handle.socket().setSendBufferSize((int)options.sndbuf);
            }
            if (options.rcvbuf != 0) {  //设置底层的socket的接收缓冲大小
                handle.socket().setReceiveBufferSize((int)options.rcvbuf);
            }

        } catch (IOException e) {
            throw new ZError.IOException(e);
        }

    }

这个比较有意思的就是将channel设置为了非阻塞的模式,然后设置了底层socket的发送以及接受缓冲的大小。。其余的就没啥意思了。。。

    //将当前engine加入到IO线程以及session,其实这里最主要的事情是将channel注册到poller上面去
    public void plug (IOThread io_thread_,
            SessionBase session_)  {
        assert (!plugged);
        plugged = true;  //标志位
        
        //  Connect to session object.
        assert (session == null);
        assert (session_ != null);
        session = session_;    //当前所属的session
        socket = session.get_soket ();  //获取所属的scoekt,这个是ZMQ的socket

        io_object = new IOObject(null);  //创建IO对象,
        io_object.set_handler(this);  //设置IO对象的事件回调
        //  Connect to I/O threads poller object.
        io_object.plug (io_thread_);  // 将IO对象搞到这个IO线程上面去,其实最主要的就是获取这个IO线程的poller对象
        io_object.add_fd (handle);   //将底层的channel加入
        io_enabled = true; //表示已经加入了
        
        //  Send the 'length' and 'flags' fields of the identity message.
        //  The 'length' field is encoded in the long format.
        //设置发送的问候msg的信息
        greeting_output_buffer.put ((byte) 0xff);
        greeting_output_buffer.putLong (options.identity_size + 1);
        greeting_output_buffer.put ((byte) 0x7f);

        io_object.set_pollin (handle);  //注册当前channel的读事件
        //  When there's a raw custom encoder, we don't send 10 bytes frame
        boolean custom = false;
        try {
            custom = options.encoder != null && options.encoder.getDeclaredField ("RAW_ENCODER") != null;
        } catch (SecurityException e) {
        } catch (NoSuchFieldException e) {
        }
        
        if (!custom) {
            outsize = greeting_output_buffer.position ();
            outbuf = new Transfer.ByteBufferTransfer ((ByteBuffer) greeting_output_buffer.flip ());  //设置需要发送的buf,将问候信息发送出去
            io_object.set_pollout (handle);
        }        
        
        //  Flush all the data that may have been already received downstream.
        in_event ();  //看是否有数据读取了
    }

这个方法用于将当前IO对象注册到IO线程上面去,并且还要管理session,可以看到这里主要是利用IOObject对象,用于在poller对象上面注册channel,以及读写事件。。。另外还有对握手信息的处理。。。好了,握手这部分的内容,因为现在还没有看,不知道具体的流程是啥样的,就先放一下。。。再来看两个重要的方法定义吧:

    //当底层的chanel有数据可以读取的时候的回调方法
    public void in_event ()  {
        if (handshaking)
            if (!handshake ())
                return;
        
        assert (decoder != null);
        boolean disconnection = false;

        //  If there's no data to process in the buffer...
        if (insize == 0) {  //如果inbuf里面没有数据需要处理

            //  Retrieve the buffer and read as much data as possible.
            //  Note that buffer can be arbitrarily large. However, we assume
            //  the underlying TCP layer has fixed buffer size and thus the
            //  number of bytes read will be always limited.
            inbuf = decoder.get_buffer ();  //从解码器里面获取buf,用于写入读取的数据,因为在已经设置了底层socket的TCP接收缓冲区的大小
            insize = read (inbuf);  //用于将发送过来的数据写到buf中去,并记录大小
            inbuf.flip();  //这里准备从buf里面读取数据了

            //  Check whether the peer has closed the connection.
            if (insize == -1) {  //如果是-1的话,表示底层的socket连接已经出现了问题
                insize = 0;
                disconnection = true;
            }
        }

        //  Push the data to the decoder.
        int processed = decoder.process_buffer (inbuf, insize);  //解析这些读取到的数据

        if (processed == -1) {
            disconnection = true;
        } else {

            //  Stop polling for input if we got stuck.
            if (processed < insize)  //如果处理的数据居然还没有读到的数据多,那么取消读取事件的注册
                io_object.reset_pollin (handle);

            //  Adjust the buffer.
            insize -= processed;  //还剩下没有处理的数据的大小
        }

        //  Flush all messages the decoder may have produced.
        session.flush ();  //将decoder解析出来的数据交给session

        //  An input error has occurred. If the last decoded message
        //  has already been accepted, we terminate the engine immediately.
        //  Otherwise, we stop waiting for socket events and postpone
        //  the termination until after the message is accepted.
        if (disconnection) {   //表示已经断开了连接,那么需要处理一下
            if (decoder.stalled ()) {
                io_object.rm_fd (handle);
                io_enabled = false;
            } else
                error ();
        }

    }
    
    //表示可以写数据了
    public void out_event ()   {
        //  If write buffer is empty, try to read new data from the encoder.
        if (outsize == 0) {  //需要写的数据量为0

            //  Even when we stop polling as soon as there is no
            //  data to send, the poller may invoke out_event one
            //  more time due to 'speculative write' optimisation.
            if (encoder == null) {
                 assert (handshaking);
                 return;
            }
            
            outbuf = encoder.get_data (null);  //从encoder里面获取数据
            outsize = outbuf.remaining();
            //  If there is no data to send, stop polling for output.
            if (outbuf.remaining() == 0) {   //如果确实没有数据要写,那么取消写事件的注册
                io_object.reset_pollout (handle);
                
                // when we use custom encoder, we might want to close
                if (encoder.is_error()) {
                    error();
                }

                return;
            }
        }

        //  If there are any data to write in write buffer, write as much as
        //  possible to the socket. Note that amount of data to write can be
        //  arbitratily large. However, we assume that underlying TCP layer has
        //  limited transmission buffer and thus the actual number of bytes
        //  written should be reasonably modest.
        int nbytes = write (outbuf);  //写数据

        //  IO error has occurred. We stop waiting for output events.
        //  The engine is not terminated until we detect input error;
        //  this is necessary to prevent losing incomming messages.
        if (nbytes == -1) {  //如果-1,那么表示底层用到的socket其实已经出现了问题
            io_object.reset_pollout (handle);  //取消写事件的注册

            if (terminating)
                terminate ();

            return;
        }

        outsize -= nbytes;  //这里更新需要写的数据的数量

        //  If we are still handshaking and there are no data
        //  to send, stop polling for output.
        if (handshaking)
            if (outsize == 0)
                io_object.reset_pollout (handle);
        
        // when we use custom encoder, we might want to close after sending a response
        if (outsize == 0) {
            if (encoder != null && encoder.is_error ()) {
                error();
                return;
            }
            if (terminating)
                terminate ();
        }

    }

这两个方法是用于相应IO事件的,前面提到的IOObject将IO事件其实委托给了内部的handler来处理,其实这个handler对象就是SteamEngine对象,也就是底层的channel有数据可以读写的时候,将会用上面的两个方法来处理。这里就可以看到读写事件最原始的处理流程了,而且也看到了encoder以及decoder的用处。。。这里代码应该还算是比较的简单,由于这部分还涉及到与上层的session对象之间的交互,这个还要等到以后来分析。。。


好了,那么到这里ZeroMQ中IO的处理流程也就算是有了基本的了解了。。。。

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:457381次
    • 积分:6551
    • 等级:
    • 排名:第3651名
    • 原创:191篇
    • 转载:0篇
    • 译文:0篇
    • 评论:82条