Generic object pool implementation in C++ ( Draft only, untested, might contain errors!)

ObjectPool.hpp

// Draft only, untested, might contain errors!!!

// Note: spin-lock implementation taken from https://en.cppreference.com/w/cpp/atomic/atomic_flag.html

#include <atomic>
#include <vector>

template <class T> class ObjectPool {
public:
    std::function<T*()> factory;

private:
    std::atomic_flag _m;
    std::vector<T*> _pool;

public:
    explicit ObjectPool(std::function<T*()> f) : factory(std::move(f)) {
        _m.clear();
    }

    ~ObjectPool() {
        clear();
    }

    size_type size() const {
        // Note: No need to lock here, std::vector itself is thread-safe
        return _pool.size();
    }

    T* get() {
        T* result = nullptr;

        lock();
        if (!_pool.empty()) {
            result = _pool.back();
            _pool.pop_back();
        }
        unlock();

        return result ? result : factory();
    }
    
    void release(T* obj) {
        lock();
        _pool.push_back(obj);
        unlock();
    }

    void clear() {
        lock();
        for (const T* obj : _pool) {
            delete obj;
        }
        _pool.clear();
        unlock();
    }

private:
    void lock() noexcept {
        // Note: Spin-lock can be a lot more efficient when remaining locked for a short amount of time
        while (_m.test_and_set(std::memory_order_acquire)) {
            // Do nothing
        }
    }

    void unlock() noexcept {
        _m.clear(std::memory_order_release);
    }
};