一文搞懂Java中对象池的实现

什么是对象池？

对象池是一种用于缓存和重复利用对象的技术。Java中，我们可以利用对象池来减少系统中对象的创建和销毁，提升系统性能和效率。利用对象池可以避免频繁地创建和销毁对象，降低了系统中对象的创建和垃圾回收造成的开销，同时也可以重复利用对象，提高了系统的效率。

Java中对象池的实现

Java中，我们可以通过下面三种方式实现对象池：

1.手动实现对象池

手动实现对象池需要自行维护对象的状态和状态转移，需要程序员自己掌控对象的生命周期，所以需要比较完整的编程经验和技术。

示例代码：

public class ObjectPool {
    private static ObjectPool instance = null;
    private List<Connection> connectionPool = new ArrayList<>();

    private ObjectPool() {
        for (int i = 0; i < 10; i++) {
            connectionPool.add(createConnection());
        }
    }

    public static ObjectPool getInstance() {
        if(instance == null) {
            synchronized (ObjectPool.class) {
                if(instance == null) {
                    instance = new ObjectPool();
                }
            }
        }
        return instance;
    }

    public synchronized Connection getConnection() {
        if(connectionPool.size() > 0) {
            Connection conn = connectionPool.get(0);
            connectionPool.remove(0);
            return conn;
        }
        else {
            return createConnection();
        }
    }

    public synchronized void releaseConnection(Connection conn) {
        connectionPool.add(conn);
    }

    private Connection createConnection() {
        Connection conn = null;
        try {
            conn = DriverManager.getConnection("url", "username", "password");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }
}

在上面的代码中，我们创建了一个名为ObjectPool的对象池，使用单例模式来实现整个应用中只有一个对象池实例。在对象池中，我们使用List来存储连接对象Connection，使用synchronized关键字来保证线程安全。在getConnection方法中，我们通过判断连接池中是否有可用连接，如果有则从连接池中返回连接，否则创建新的连接。在releaseConnection方法中，我们将使用完毕的连接归还给连接池。

2.使用Apache Commons Pool

Apache Commons Pool是一个通用的对象池，可以重复使用各种Java对象。使用Apache Commons Pool可以避免手动实现对象池时遇到的各种问题，提升程序员的开发效率。

示例代码：

public class ObjectPool {
    private static ObjectPool instance = null;
    private Pool<Connection> connectionPool;

    private ObjectPool() {
        ObjectPoolConfig config = new GenericObjectPoolConfig();
        config.setMaxTotal(10);
        config.setMaxIdle(5);
        config.setMinIdle(1);

        connectionPool = new GenericObjectPool<>(new ConnectionFactory(), config);
    }

    public static ObjectPool getInstance() {
        if(instance == null) {
            synchronized (ObjectPool.class) {
                if(instance == null) {
                    instance = new ObjectPool();
                }
            }
        }
        return instance;
    }

    public Connection getConnection() throws Exception {
        return connectionPool.borrowObject();
    }

    public void releaseConnection(Connection conn) throws Exception {
        connectionPool.returnObject(conn);
    }

    class ConnectionFactory extends BasePooledObjectFactory<Connection> {
        @Override
        public Connection create() throws Exception {
            return DriverManager.getConnection("url", "username", "password");
        }

        @Override
        public PooledObject<Connection> wrap(Connection conn) {
            return new DefaultPooledObject<>(conn);
        }
    }
}

在上述代码中，我们使用了Apache Commons Pool来实现对象池。在ObjectPool构造方法中，我们通过设置ObjectPoolConfig来配置对象池的属性，例如最大连接数、最大空闲数、最小空闲数等。在connectionPool中，我们通过GenericObjectPool来创建对象池，并使用我们刚才配置的ObjectPoolConfig。在getConnection方法中，我们使用borrowObject从连接池中获取可用连接，在releaseConnection方法中，使用returnObject将使用完毕的连接返回给连接池。

3.使用Spring容器对象池

在Spring中，我们可以使用容器对象池来管理对象的生命周期，避免手动创建对象池带来的各种问题。

示例代码：

@Configuration
public class ObjectPoolConfig {

    @Bean
    public GenericObjectPool<Connection> connectionPool() {
        GenericObjectPool<Connection> pool = new GenericObjectPool<>(new ConnectionFactory());
        pool.setMaxTotal(10);
        pool.setMaxIdle(5);
        pool.setMinIdle(1);
        return pool;
    }

    class ConnectionFactory implements PooledObjectFactory<Connection> {
        @Override
        public PooledObject<Connection> makeObject() throws Exception {
            return new DefaultPooledObject<>(DriverManager.getConnection("url", "username", "password"));
        }

        @Override
        public void destroyObject(PooledObject<Connection> pooledObject) throws Exception {
            pooledObject.getObject().close();
        }

        @Override
        public boolean validateObject(PooledObject<Connection> pooledObject) {
            try {
                return !pooledObject.getObject().isClosed();
            } catch (Exception e) {
                return false;
            }
        }
    }
}

在上述代码中，我们使用@Configuration来标记一个配置类，使用@Bean来创建连接池对象。在connectionPool方法中，我们使用GenericObjectPool来创建对象池，并设置最大连接数、最大空闲数、最小空闲数等属性。在getConnection方法中，我们使用borrowObject从连接池中获取可用连接，在releaseConnection方法中，使用returnObject将使用完毕的连接返回给连接池。

总结

通过这篇文章，我们全面了解了Java中对象池的实现，介绍了手动实现对象池、使用Apache Commons Pool和使用Spring容器对象池三种方式。通过对象池的使用，我们可以减少系统中对象的创建和销毁，提升系统性能和效率。