设计模式-对象池模式

设计模式专栏

---

---

模式介绍

对象池模式是一种创建型设计模式，它将对象预先创建并初始化后放入一个池中，以供其他对象使用。这种模式的主要目的是减少频繁创建和销毁对象所占用的内存空间和初始化时间。

一个对象池包含一组已经初始化并且可以使用的对象。当某个对象需要使用这些对象时，可以从池中获取一个对象，对其进行操作处理，并在使用完毕后将该对象归还给池子，而不是直接销毁。这样可以避免频繁地创建和销毁对象，提高内存管理效率。

总之，对象池模式通过预先创建和初始化对象并放入池中，使得其他对象可以重复使用这些对象，提高了内存管理效率，减少了对象的创建和销毁开销。

模式特点

• 对象池模式的优点主要包括以下几点：

1. 复用池中对象，没有分配内存和创建堆中对象的开销，没有释放内存和销毁堆中对象的开销，进而减少垃圾收集器的负担，避免内存抖动。
2. 不必重复初始化对象状态，对于比较耗时的constructor和finalize来说非常合适。
3. 可以避免频繁地创建和销毁对象，提高内存管理效率。
4. 可以更好地管理和控制对象的数量，例如线程池或数据库连接池。

• 然而，对象池模式也存在一些缺点：

1. 增加了分配/释放对象的开销。
2. 在并发环境中，多个线程可能同时需要获取池中对象，需要在堆数据结构上进行同步或因为锁竞争而产生阻塞，这种开销要比创建销毁对象的开销高数百倍。
3. 由于池中对象的数量有限，势必成为一个可伸缩性瓶颈。
4. 很难正确地设定对象池的大小，如果太小则起不到作用，如果过大，则占用内存资源高。

因此，使用对象池模式时需要根据具体情况权衡利弊，并根据应用场景选择合适的实现方式。

应用场景

对象池模式主要适用于以下应用场景：

1. 资源受限的场景 ：在不需要可伸缩性的环境（如CPU、内存等物理资源有限）中，如果CPU性能不够强劲或内存比较紧张，垃圾收集和内存抖动可能会造成较大影响，需要提高内存管理效率，响应性比吞吐量更为重要。
2. 创建成本高的对象 ：对于那些创建成本高的对象，可以考虑将其池化，以减少创建和销毁对象的开销。
3. 在内存中数量受限的对象 ：对于那些在内存中数量受限的对象，例如线程池或数据库连接池，使用对象池模式可以更好地管理和控制对象的数量。

对象池模式和工厂模式的区别

对象池模式和工厂模式都是常用的设计模式，但它们有不同的应用场景和特点。

对象池模式主要适用于一些创建成本较高的对象，比如数据库连接、线程池等。在创建这些对象时，需要进行一些繁琐的初始化操作，并且创建和销毁的成本较高。通过使用对象池，我们可以重复利用这些对象，避免浪费资源，提高系统性能。

而工厂模式主要适用于需要创建不同类型对象的场景。当一个类需要创建某个类型的对象时，可以调用工厂方法来创建对象，而不是直接使用new关键字创建对象。这样可以提高代码的灵活性和可维护性，因为如果需要改变对象的创建方式，只需要修改工厂方法的实现即可，而不需要修改使用new关键字创建对象的代码。

对象池模式和工厂模式都可以提高系统性能和可伸缩性，但它们的应用场景和特点不同。在实际应用中，可以根据具体需求选择合适的设计模式。

代码示例

Java实现对象池模式

下面是一个简单的Java实现对象池模式的示例：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class ObjectPool<T> {
    private final int maxPoolSize;
    private final BlockingQueue<T> pool;

    public ObjectPool(int maxPoolSize) {
        this.maxPoolSize = maxPoolSize;
        this.pool = new LinkedBlockingQueue<>(maxPoolSize);
    }

    public synchronized T acquire() throws InterruptedException {
        while (pool.isEmpty()) {
            if (pool.size() < maxPoolSize) {
                T newObj = createObject(); // 创建对象的方法，可以根据需要自定义
                pool.add(newObj); // 添加新对象到池中
            } else {
                wait(); // 等待对象可用
            }
        }
        return pool.take(); // 从池中获取对象
    }

    public synchronized void release(T obj) {
        if (pool.size() < maxPoolSize) {
            pool.add(obj); // 将对象放回池中
            notifyAll(); // 唤醒等待的线程
        } else {
            destroyObject(obj); // 销毁对象的方法，可以根据需要自定义
        }
    }

    private T createObject() {
        // 创建对象的逻辑，可以根据需要自定义
        return null;
    }

    private void destroyObject(T obj) {
        // 销毁对象的逻辑，可以根据需要自定义
    }
}

使用示例：

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ObjectPool<MyObject> pool = new ObjectPool<>(5); // 创建一个最大容量为5的对象池
        for (int i = 0; i < 10; i++) {
            MyThread thread = new MyThread(pool); // 使用对象池的线程类MyThread进行任务处理
            thread.start(); // 启动线程进行任务处理
        }
    }
}

Python实现对象池模式

下面是一个Python实现对象池模式的示例：

import threading

class ObjectPool:
    def __init__(self, max_pool_size):
        self.max_pool_size = max_pool_size
        self.pool = []
        self.lock = threading.Lock()

    def acquire(self):
        with self.lock:
            while len(self.pool) == 0:
                if len(self.pool) < self.max_pool_size:
                    new_obj = self.create_object()
                    self.pool.append(new_obj)
                else:
                    threading.Condition(self.lock).wait()
            obj = self.pool.pop(0)
            return obj

    def release(self, obj):
        with self.lock:
            if len(self.pool) < self.max_pool_size:
                self.pool.append(obj)
                threading.Condition(self.lock).notify()
            else:
                self.destroy_object(obj)

    def create_object(self):
        # 创建对象的逻辑，可以根据需要自定义
        return None

    def destroy_object(self, obj):
        # 销毁对象的逻辑，可以根据需要自定义
        pass

使用示例：

if __name__ == '__main__':
    pool = ObjectPool(5) # 创建一个最大容量为5的对象池
    for i in range(10):
        thread = MyThread(pool) # 使用对象池的线程类MyThread进行任务处理
        thread.start() # 启动线程进行任务处理

对象池模式在spring中的应用

在Spring框架中，并没有直接实现对象池模式，但它提供了相关的支持，使得我们可以方便地实现该模式。例如，Spring的Bean生命周期管理和依赖注入特性可以用于实现自定义的对象池。此外，Spring也提供了与一些常见对象池（如数据库连接池）的集成。

具体来说，Spring中的对象池设计模式主要用于在一个池中保存特定数量的对象，并根据需要重新使用。通过这种方式，可以改善使用巨型对象的响应时间。巨型对象指的是那些构造需要很多时间的对象，例如持有数据库连接的对象。最好重用已经存在的和未获取的对象，而不是创建新对象。

在Spring中，数据库连接池不是由Spring直接实现的，而是适用于Spring工作方式的连接池，例如C3P0或Jakarta Commons DBCP连接池。这些连接池作为组件被使用时，会从池中借出对象，用它来完成一些任务并当任务完成时归还该对象。被归还的对象接着满足请求，不管是同一个组件还是其他组件的请求。

Spring中的对象池模式主要是通过集成第三方库来使用和管理对象池，以提高系统的性能和响应时间。

设计模式-适配器模式

设计模式-工厂模式

设计模式-代理模式