⼿写⼀个对象池

实现一个对象池时，你需要考虑几个关键方面：对象的创建、对象的管理、对象的重用、线程安全等。

以下是一个简单的Java示例，演示如何手动实现一个简单的对象池：

import cn.hutool.json.JSONObject;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ObjectPool {

    private final int maxSize;
    private final BlockingQueue pool;

    public ObjectPool(int maxSize, ObjectFactory factory) {
        this.maxSize = maxSize;
        this.pool = new ArrayBlockingQueue<>(maxSize);
        for (int i = 0; i < maxSize; i++) {
            pool.offer(factory.create());
        }
    }

    /**
     * 从池中获取对象
     *
     * @return
     * @throws InterruptedException
     */
    public T borrowObject() throws InterruptedException {
        return pool.take();
    }

    /**
     * 将对象归还到池中
     *
     * @param object
     * @throws InterruptedException
     */
    public void returnObject(T object) throws InterruptedException {
        if (object != null && pool.size() < maxSize) {
            pool.offer(object);
        }
    }

    public int size() {
        return pool.size();
    }

    /**
     * 通过接口来创建对象
     *
     * @param 
     */
    public interface ObjectFactory {
        T create();
    }

    public static void main(String[] args) {
        ObjectPool objectPool = new ObjectPool<>(10, () -> new JSONObject());

        try {
            JSONObject obj1 = objectPool.borrowObject();
            System.out.println("Borrowed: " + obj1);

            JSONObject obj2 = objectPool.borrowObject();
            System.out.println("Borrowed: " + obj2);

            objectPool.returnObject(obj1);
            objectPool.returnObject(obj2);

            System.out.println("Pool size: " + objectPool.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

这是一个简单的对象池示例，使用了 BlockingQueue 来管理对象池中的对象。这样可以避免频繁地创建和销毁对象，提高系统性能和资源利用率。

在实际应用中，你可能需要根据需求进行更复杂的实现，例如对象的生命周期管理、超时处理等。