Реализация блокировки на C++

Вот наивный фрагмент, иллюстрирующий один из возможных подходов:

#include <mutex>

template <typename T>
class SyncStack
{
   T         * m_data;
   std::size_t m_size;
   std::size_t m_count;
   std::mutex  m_lock;

public:
  T get()
  {
    std::lock_guard<std::mutex> lock(m_lock);

    if (m_count == 0) { throw UnderrunException; }

    --m_count;
    T x(m_data[m_count]);
    m_data[m_count].~T();

    return x;
  }

  void put(T x)
  {
    std::lock_guard<std::mutex> lock(m_lock);
    ::new (m_data + m_count) T(std::move(x));
    ++m_count;
  }
};

В этом примере предполагается, что m_data указывает на бесконечную память. Перераспределение немного сложнее и требует создания большого количества копий.

Более простым подходом было бы обернуть вашу синхронизированную структуру вокруг другого существующего стандартного контейнера, такого как std::vector<T>.

1) Как мне реализовать это ограничение на общий параметр T в С++? (класс, новый())

В общем, не надо. Если он не соответствует ограничениям, он не сможет скомпилироваться. Достаточно просто. Есть хитрые способы улучшить сообщения об ошибках, но я забыл о них навскидку, потому что никогда не беспокоился.

2) Есть ли простой способ реализовать блокировку мьютекса?

Используйте boost::mutex.

3) Будет ли более эффективно определять _pool как вектор вместо T[] в C++?

Учитывая, что у вас не может быть локального T[] без размера, да. Используйте std::vector. (Вы можете иметь его в качестве параметра, но не в определении переменной.)

Вот как бы я это реализовал. Вы можете заменить tbb::concurrenct_queue на std::mutex защищенный std::queue, хотя это будет менее эффективно. С этой реализацией вам нужно беспокоиться о «возвращении» объектов обратно в пул, это обрабатывается автоматически.

#include <memory>
#include <tbb/concurrent_queue.h>

namespace FastRank
{
    template<typename T>
    class object_pool
    {
        typedef tbb::concurrent_bounded_queue<std::shared_ptr<T>> pool_t;       
        std::shared_ptr<pool_t> pool_;
    public:

        object_pool() : pool_(new pool_t())
        {
        }

        std::shared_ptr<T> get()
        {
            std::shared_ptr<T> ptr;
            if(!pool_.try_pop(ptr))
                ptr = std::make_shared<T>();

            auto pool = pool_;
            return std::shared_ptr<T>(ptr.get(), [pool, ptr](T*){pool->push(ptr);});
        }
    }
}

Без concurrent_queue

#include <memory>
#include <queue>
#include <boost/mutex.hpp>

namespace FastRank
{
    template<typename T>
    class object_pool
    {
        typedef std::pair<std::queue<std::shared_ptr<T>>, boost::mutex> pool_t;     
        std::shared_ptr<pool_t> pool_;
    public:

        object_pool() : pool_(new pool_t())
        {
        }

        std::shared_ptr<T> get()
        {
            std::shared_ptr<T> ptr;
            {
                boost::scoped_lock<boost::mutex> lock(pool_->second);
                if(!pool_->first.empty())
                {
                     ptr = std::move(pool->first.front());
                     pool->first.pop()
                }
            }

            if(!ptr)
                ptr = std::make_shared<T>();

            auto pool = pool_;
            return std::shared_ptr<T>(ptr.get(), [pool, ptr](T*)
            {
                boost::scoped_lock<boost::mutex> lock(pool->second);                    
                pool->push(ptr);
            });
        }
    }
}