//第一步：打开ServerSocketChannel，用于监听客户端的连接，它是所有客户端的父管道
ServerSocketChannel acceptorSvr = ServerSocketChannel.open();
//第二步，绑定监听端口，设置连接为非阻塞模式
acceptorSvr.socket().bind(new InetSocketAddress(InetAddress.getByName("IP"),port));
acceptorSvr.configureBlocking(false);
//第三步,创建Reactor线程，创建多路复用器并启动线程
Selector selector = Selector.open();
New Thread(new ReactorTask()).start();
//第四步，将ServerSocketChannel注册到Reactor线程的多路复用器Selector上，监听ACCEPT事件
SelectionKey key = acceptorSvr.register(selector,SelectionKey.OP_ACCEPt,ioHandler);
//第五步，多路复用器在线程run方法的无限循环体内轮询准备就绪的key
int num = selector.select();
Set selectedKeys = selector.selectedKeys();
Iterator it = selectedKeys.iterator();
while(it.hasNext()){
    SelectionKey key = (SelectionKey)it.next();
    // ... deal with I/O event ...
}
//第六步，多路复用器监听到有新的客户端接入，处理新的接入请求，完成TCP三次握手，建立物理链路
SocketChannel channel = svrChannel.accept();
//第七步，设置客户端链路为非阻塞模式
channel.configureBlocking(false);
channel.socket().setReuseAddress(true);
//第八步，将新接入的客户端连接注册到Reactor线程的多路复用器上，监听读操作，用来读取客户端发送的网络消息
SelectionKey key = socketChannel.register(selector,SelectionKey.OP_READ,ioHandler);
//第九步，异步读取客户端请求消息到缓冲区
int readNumber = channel.read(receivedBuffer);
//第十步，对ByteBuffer进行编码，如果有半包消息指针reset，继续读取后续的报文，将解码成功的消息封装成Task，投递到业务线程池中，进行业务逻辑编排
Object message = null;
while(buffer.hasRemain()){
    byteBuffer.mark();
    Object message = decode(byteBuffer);
    if(message == null){
        byteBuffer.reset();
        break;
    }
    messageList.add(message);
}
if(!byteBuffer.hasRemain()){
    byteBuffer.clear();
}else{
    byteBuffer.compact();
}
if(messageList !=null &!messageList.isEmpty()){
    for(Object messageE : messageList){
        handlerTask(messageE);
    }
}
//第十一步，将POJO对象encode成ByteBuffer，调用SocketChannel的异步write接口，将消息异步发送给客户端
socketChannel.write(buffer);

package com.idea4j.jvm.mat;
public class Point {
    private int x;
    private int y;
    public Point(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
}

package com.idea4j.jvm.mat;
public class Line {
    private Point startPoint;//
    private Point endPoint;
    public Line(Point startPoint, Point endPoint) {
        this.startPoint = startPoint;
        this.endPoint = endPoint;
    }
    public Point getStartPoint() {
        return startPoint;
    }
    public void setStartPoint(Point startPoint) {
        this.startPoint = startPoint;
    }
    public Point getEndPoint() {
        return endPoint;
    }
    public void setEndPoint(Point endPoint) {
        this.endPoint = endPoint;
    }
}

package com.idea4j.jvm.mat;
public class ShallowRetainedDump {
    public static void main(String[] args) throws InterruptedException {
        //
        Point a = new Point(0, 0);
        Point b = new Point(1, 1);
        Point c = new Point(5, 3);
        Point d = new Point(9, 8);
        Point e = new Point(6, 7);
        Point f = new Point(3, 9);
        Point g = new Point(4, 8);
        Line aLine = new Line(a, b);
        Line bLine = new Line(a, c);
        Line cLine = new Line(d, e);
        Line dLine = new Line(f, g);
        a = null;
        b = null;
        c = null;
        d = null;
        e = null;
        Thread.sleep(1000000);
    }
}

* -XX:+UseCompressedOops开启指针压缩（默认） oop对象指针
* -XX:-UseCompressedOops关闭指针压缩