Java网络与多线程系列之1：实现一个简单的对象池

前言

为什么要从对象池开始呢，先从一个网络IO操作的demo说起

比如下面这段代码，显而易见已经在代码中使用了一个固定大小的线程池，所以现在的重点在实现Runnble接口的匿名对象上，这个对象每次创建线程都要重复创建。

假设有个提供http服务的程序，每天要处理几万，上百万等等的用户请求，那么我们的程序岂不是每次请求都会创建一次Runnble的实现对象？这种大量重复创建同一个对象显然会造成大量的内存资源浪费（如果再增加GC的要回收他们所需要消耗的系统资源，显然耗费的资源只会比表面看起来更多）

/**
     * 一个请求
     * @param host -主机地址
     * @param port -端口号
     * @param size -线程数
     * @return
     */
    public static List<Socket> request(String host, int port, int size) {
    ScheduledThreadPoolExecutor exe = new ScheduledThreadPoolExecutor(size);
    List<Socket> list = new ArrayList<Socket>(size);
    int errsize = 0;
    for (int i = 0; i < size; i++) {
        System.err.println("正在创建连接线程" + i);
        Socket socket;
        try {
        socket = request(host, port);
        exe.execute(new Runnable() {
            @Override
            public void run() {
            handler(socket);
            }
        });
        list.add(socket);
        } catch (IOException e) {
        errsize++;
        }
    }
    System.err.println("请求失败次数" + errsize);
    return list;
    }

    public static void handler(Socket socket) {
    try {
        PrintWriter writer = new PrintWriter(
            new OutputStreamWriter(new BufferedOutputStream(socket.getOutputStream(), 8192), "utf-8"), true);
        for (int i = 5; i > 0; i--) {
        writer.print("xxx");
        writer.write("sss");
        writer.println("123");
        }
        Thread.sleep(1000 * 60);
        socket.close();
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    }

除了Runnable之外，在实际实践中还有很多类似的重复创建对象的示例，不再一一举例。

既然知道了重复创建对象是个很耗费资源的一件事情，那么我们如何优化呢？

没错，利用“对象池”来重复利用有限资源的对象（比如数据库连接是有上限的）

线程池、数据库连接池这些都是我们平时司空见惯的“池”，那么我们的主题就是实现一个简单的“对象池”

对象池实现

对象池调用接口

先定义一个对象池接口，这个接口抽象了几个调用方法，一般只用得到这三个接口

package cc.eguid.test.SimulationServer.pool;

public interface BasePool<T> {

    /**
     * 从对象池中获取空闲对象（如果对象池已满会一直阻塞，直到有空闲对象）
     * @return
     */
    public T getObject();

    /**
     * 回收对象到对象池
     * @param obj
     */
    public void returnObject(T obj);

    /**
     * 是否有空闲对象
     * @return
     */
    public boolean has();

}

对象工厂

想象一下，如果我们直接实现该接口之后，我们要如何创建一个未知的对象？比如创建带参数的对象或者其他方式创建对象，为了应对这种情况，我们需要抽象出一个对象创建工厂接口，另外提供一个默认的简单的对象工厂。

package cc.eguid.test.SimulationServer.pool;

public interface CreateObjectFactory<T> {
    /**
     * 创建对象
     * @return
     */
    public T create(Class<T> objectClass) ;

    /**
     * 销毁对象
     */
    public void detory(T obj);

    /**
     * 重置对象
     */
    public T reset(T obj);
}

package cc.eguid.test.SimulationServer.pool;

public class DefaultObjectFactory<T> implements CreateObjectFactory<T> {

    @Override
    public T create(Class<T> objectClass) {
    try {
        return objectClass.newInstance();
    } catch (InstantiationException | IllegalAccessException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return null;
    }

    @Override
    public void detory(T obj) {
    obj = null;
    }

    @Override
    public T reset(T obj) {
    T newobj = create((Class<T>) obj.getClass());
    detory(obj);
    return newobj;
    }

}

对象池的管理

现在，对象创建有了，我们要实现对象池的接口，来对对象的创建、重置、缓存、获取和回收操作进行管理了。

package cc.eguid.test.SimulationServer.pool;

import java.util.concurrent.ConcurrentLinkedQueue;

import org.apache.log4j.Logger;

/**
 * 对象池管理
 *
 * @author eguid
 * @date 2018-01-09
 * @param <T>
 */
public class BaseObjectPool<T> implements BasePool<T> {

    final static Logger log = Logger.getLogger(BaseObjectPool.class);

    /**
     * 空闲对象池（已交回的对象），初始化时都是空闲的对象
     */
    ConcurrentLinkedQueue<T> idleObjects = null;

    volatile int usingAmount = 0;// 当前已使用的对象数量（出借的对象）

    volatile int activeSize = 0;// 创建的对象数量（当对象池满时，该值等于对象池大小）

    volatile boolean isHaveIdle = Boolean.TRUE;

    /**
     * 对象池中对象的总数量（通过初始化方法确定，不可修改）
     */
    private final int size;

    private Class<T> objectClass = null;// 要创建的对象class

    /**
     * 创建对象的工厂
     */
    private CreateObjectFactory<T> factory;

    /**
     * 默认
     *
     * @param factory -可以为空，为空则根据默认对象工厂类创建对象
     * @param size
     * @param cl
     */
    public BaseObjectPool(int size, Class<T> cl) {
    this(null, size, cl);
    }

    /**
     * 默认
     *
     * @param factory -可以为空，为空则根据默认对象工厂类创建对象
     * @param size
     * @param cl
     */
    public BaseObjectPool(CreateObjectFactory<T> factory, int size, Class<T> cl) {
    this.size = size;
    this.objectClass = cl;
    if (factory == null) {
        factory = new DefaultObjectFactory<T>();
    }
    this.factory = factory;
    idleObjects = new ConcurrentLinkedQueue<>();
    }

    @Override
    public synchronized T getObject() {
    T obj = null;
    if (isFull()) {// 对象池是否已满，如果满了就从空闲连接池中获取空闲对象
        if (has()) {// 如果没有空闲对象，那么将会一直阻塞
        if ((obj = idleObjects.poll()) != null) {// 如果空闲对象池中也没有空闲对象，那么将返回null
            log.info("从对象池中取出空闲的对象");
            usingAmount++;// 使用对象增加
        }
        }
    } else {
        log.info("创建新的对象到对象池");
        obj = factory.create(this.objectClass);
        activeSize++;// 活动对象增加
        usingAmount++;// 使用对象增加
    }
    return obj;
    }

    @Override
    public synchronized void returnObject(T obj) {
    log.info("当前回收的对象：" + obj.getClass().getName());
    if (obj != null) {
        log.info("准备回收对象到对象池");
        T idleobj = factory.reset(obj);
        if (idleObjects.offer(idleobj)) {// 将对象放入空闲对象
        usingAmount--;
        log.info("回收对象后当前对象池状态：(对象创建数量：" + getActiveSize() + "，对象当前使用数量：" + getUsingAmount() + ")");
        } else {
        log.warn("回收失败");
        }
    }
    }

    /**
     * 空闲对象池中是否还有空闲对象可以获取
     */
    public boolean has() {
    return usingAmount < size;
    }

    /**
     * 池中对象数量是否已经达到最大值（对象池是否已满）
     *
     * @return
     */
    public boolean isFull() {
    return activeSize >= size;
    }

    public CreateObjectFactory<T> getFactory() {
    return factory;
    }

    public void setFactory(CreateObjectFactory<T> factory) {
    this.factory = factory;
    }

    public ConcurrentLinkedQueue<T> getIdleObjects() {
    return idleObjects;
    }

    /**
     * 获取当前正在使用的对象数量
     *
     * @return
     */
    public int getUsingAmount() {
    return usingAmount;
    }

    /**
     * 获取当前创建的对象数量
     *
     * @return
     */
    public int getActiveSize() {
    return activeSize;
    }

    public int getSize() {
    return size;
    }

    public Class<T> getObjectClass() {
    return objectClass;
    }

}

我们利用了一个线程安全的FIFO队列来实现对象的缓存，利用使用数量和创建数量两个实时变量来保证多线程下的可读性和对象的获取回收操作前的必要判断。

使用一个不算太复杂的例子来测试一下对象池是否好用

package cc.eguid.test.SimulationServer;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.SocketTimeoutException;

import cc.eguid.test.SimulationServer.handler.CommonHandler;
import cc.eguid.test.SimulationServer.log.CommonParent;
import cc.eguid.test.SimulationServer.service.ServiceManager;

/**
 * 套接字服务
 *
 * @author eguid
 * @date 2018-01-08
 */
public class ServerService extends CommonParent {
    private static final long serialVersionUID = 1L;
    int port;
    int backlog = 1000;// 连接等待队列
    int size = 1000;// 任务线程总数（默认线程数1000）
    ServerSocket server = null;
    ServiceManager manager = null;

    public ServerService(int port) {
    initServerSocket(port, null, null);
    }

    public ServerService(int port, int size) {
    initServerSocket(port, size, null);
    }

    public ServerService(int port, int size, int backlog) {
    initServerSocket(port, size, backlog);
    }

    /**
     * 初始化服务（立即失败模式，如果启动任意服务初始化失败，则立刻抛出异常终止服务）
     *
     * @param port
     * @param size
     * @param backlog
     * @return
     */
    private ServerSocket initServerSocket(int port, Integer size, Integer backlog) {
    this.port = port;
    this.size = size;
    try {
        server = new ServerSocket();
        // 该方法必须在套接字创建之前确定，否则无效
        // 性能首选项（短连接优先级最低，低延迟优先级最高，高带宽为次重要）
        server.setPerformancePreferences(0, 2, 1);
        SocketAddress sa = new InetSocketAddress(port);
        server.bind(sa, backlog);
        manager = new ServiceManager(size+backlog);
        return server;
    } catch (Exception e) {
        // 如果端口被占用应该立即失败
        log.error("服务启动失败", e);
        e.printStackTrace();
    }
    return server;
    }

    public ServerSocket getServer() {
    return server;
    }

    /**
     * 开始监听处理连接请求
     *
     * @param handler
     */
    public void start(CommonHandler handler) {
    if (server != null && !server.isClosed()) {
        Socket soc = null;
        for (;;) {
        try {
            soc = waitConnect();
            if(soc!=null){
             manager.execute(soc, handler);
            }
        } catch (Exception e) {// 屏蔽异常，防止单个连接异常影响主程序稳定运行
            // 单个线程的连接失败不应该影响整体
            log.warn("等待新的连接失败", e);
        }
        }

    }
    }

    /**
     * 等待连接(立即失败模式，除了超时异常以外，其他异常会立即抛出)
     *
     * @return
     * @throws IOException
     */
    private Socket waitConnect() throws IOException {
    Socket soc = null;
    try {
        if ((soc = server.accept()) != null) {
        if (soc != null && soc.isConnected()) {
            log.info("建立了一个连接");
            return soc;
        }
        }
    } catch (SocketTimeoutException se) {
        log.warn("套接字连接等待超时", se);
        // 连接等待超时，继续等待
        return null;
    } catch (IOException e) {// 屏蔽单个连接错误
        log.error("创建一个新连接请求失败", e);
        return null;
    }
    return soc;
    }
}

package cc.eguid.test.SimulationServer.service;

import java.io.IOException;
import java.net.Socket;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor;

import cc.eguid.test.SimulationServer.handler.CommonHandler;
import cc.eguid.test.SimulationServer.handler.Tasker;
import cc.eguid.test.SimulationServer.log.CommonParent;
import cc.eguid.test.SimulationServer.pool.BaseObjectPool;
import cc.eguid.test.SimulationServer.pool.CreateObjectFactory;

/**
 * 任务管理器
 *
 * @author eguid
 * @date 2018-01-08
 */
public class ServiceManager extends CommonParent {
    private static final long serialVersionUID = 1L;
    private ThreadPoolExecutor excutor = null;

    public static BaseObjectPool<Tasker> pool = null;

    public static void returnObj(Tasker obj) {
    pool.returnObject(obj);
    }

    public ServiceManager(int size) {
    excutor = new ScheduledThreadPoolExecutor(size);
    //重新实现对象创建、销毁和重置方式
    pool = new BaseObjectPool<Tasker>(new CreateObjectFactory<Tasker>() {
        @Override
        public Tasker create(Class<Tasker> objectClass) {
        return new Tasker();
        }

        @Override
        public void detory(Tasker obj) {
        // 先销毁内部的连接
        Socket soc = obj.getSocket();
        if (soc != null && !soc.isClosed()) {
            try {
            soc.close();
            } catch (IOException e) {
            soc = null;
            }
        }
        obj = null;
        }

        @Override
        public Tasker reset(Tasker obj) {
        Socket soc = obj.getSocket();
        if (soc != null && !soc.isClosed()) {
            try {
            soc.close();
            } catch (IOException e) {
            soc = null;
            }
        }
        soc = null;
        obj.setSocket(null);// 重置只需要销毁socket即可
        obj.setHandler(null);
        return obj;
        }

    }, size, Tasker.class);
    }

    public void execute(Socket socket, CommonHandler handler) {
    Tasker task = pool.getObject();
    if (task == null) {
        log.warn("没有空闲对象");
        return;
    }
    task.setHandler(handler);
    task.setSocket(socket);
    excutor.execute(task);
    }

}

package cc.eguid.test.SimulationServer.handler;

import java.io.IOException;
import java.net.Socket;
import cc.eguid.test.SimulationServer.log.CommonParent;
import cc.eguid.test.SimulationServer.service.ServiceManager;
//重新实现了Runnable接口，方便处理网络流
public class Tasker extends CommonParent implements Runnable {
    private static final long serialVersionUID = 1L;

    Socket socket = null;
    CommonHandler handler = null;

    public Tasker() {
    }

    private Tasker(Socket socket, CommonHandler handler) {
    this.socket = socket;
    this.handler = handler;
    }

    public Socket getSocket() {
    return socket;
    }

    public void setSocket(Socket socket) {
    this.socket = socket;
    }

    public CommonHandler getHandler() {
    return handler;
    }

    public void setHandler(CommonHandler handler) {
    this.handler = handler;
    }

    @Override
    public void run() {
    try {
        handler.handler(socket);
    } catch (Exception e) {// 允许通过抛出异常方式退出线程
        log.warn("处理异常结束，正在试图正常关闭连接", e);
        if (socket != null && !socket.isClosed()) {
        try {
            socket.close();
        } catch (IOException e1) {
            socket = null;
            log.warn("线程意外结束，尝试关闭连接失败", e1);
        }
        }
    } finally {
        ServiceManager.returnObj(this);// 回收对象到对象池
    }
    }
}

package cc.eguid.test.SimulationServer;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.Socket;
import java.nio.charset.Charset;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import cc.eguid.test.SimulationServer.handler.CommonHandler;
/**
 * 启动
 * @author eguid
 * @date 2018-01-09
 */
public class App {
    final static Logger log = LoggerFactory.getLogger(App.class);

    public static void main(String[] args) {
    System.out.println("Hello World!");
    // 监听8181端口，最多同时10个任务线程，连接等待队列最多允许20个连接同时等待
    ServerService server = new ServerService(8181, 10, 20);
    //处理器只创建一次
    server.start(new CommonHandler() {
        @Override
        public void handler(Socket socket) throws Exception {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(
                new InputStreamReader(socket.getInputStream(), Charset.forName("utf-8")));
            String msg = null;
            for (;;) {
            if (null != (msg = reader.readLine())) {
                log.info(Thread.currentThread().getName()+":"+msg);
            }
             Thread.yield();
             Thread.sleep(50);
            }
        } catch (Exception e) {// 获取连接失败，直接停止
            log.error("无法获取连接，连接可能已经终止，正在推出线程", e);
            // TODO Auto-generated catch block
            throw e;
        }
        }
    });
    }
}

除了本篇文章实现的简单的对象池外，平时开发中常见的对象池有Apache-commons-pool和2，Apache-commons-pool常用于DBCP，c3p0，druid等等常见的数据库连接池中。