clearing a grid with multhithreading

Question

I am trying to clear a (game) grid, but whenever I multithread it, the time it takes to clear the grid increases with 3 seconds. To my own logic this should not be the case since each Y value of the array hold a lot of X values (the X values store a class) which then should iterate through a so called objects property and perform objects.clear() on it, which also iterates through every element.

My code:

    const int NUM_OF_AVAIL_THREADS = std::thread::hardware_concurrency() * 2;
    ThreadPool* pool = new ThreadPool(NUM_OF_AVAIL_THREADS);
    vector<future<void>> threads;

    void Terrain::clear_grid()
    {
        for (int y = 0; y < tiles.size(); y++)
        {
            threads.push_back(pool->enqueue([&]()
                {
                    array<TerrainTile, terrain_width>& h = tiles.at(y);
                    for (int x = 0; x < h.size(); x++)
                    {
                        h.at(x).objects.clear();
                    }
                }));
        }
        pool->wait_and_clear_threads(threads);
    }

TerrainTile looks like this:

    class TerrainTile
    {
    public:
        //TerrainTile *up, *down, *left, *right;
        vector<TerrainTile*> exits;
        bool visited = false;
        size_t position_x;
        size_t position_y;
        TileType tile_type;
        vector<TerrainTile*> neighbors;

        vector<MovingAsset*> objects;
        vector<Tank*> tanks;
        vector<MovingAsset*> beams;
        vector<MovingAsset*> get_collidable_assets();
        void add_collidable_assets(MovingAsset* asset);
        void add_neighbor(TerrainTile* neighbor);
    };

How the tiles array looks like:

static constexpr size_t terrain_width = 80;
static constexpr size_t terrain_height = 45;
std::array<std::array<TerrainTile, terrain_width>, terrain_height> tiles;

am I missing out on something crucial here, or does the cost of creating a thread simply outweigh the time it takes to iterate through the arrays?

EDIT: THIS IS THE THREADPOOL

#pragma once

namespace Tmpl8
{

    class ThreadPool; //Forward declare

    class Worker;

    class Worker
    {
    public:
        //Instantiate the worker class by passing and storing the threadpool as a reference
        Worker(ThreadPool& s) : pool(s) {}

        inline void operator()();

    private:
        ThreadPool& pool;
    };

    class ThreadPool
    {
    public:
        ThreadPool(size_t numThreads) : stop(false)
        {
            for (size_t i = 0; i < numThreads; ++i)
                workers.push_back(std::thread(Worker(*this)));
        }

        ~ThreadPool()
        {
            stop = true; // stop all threads
            condition.notify_all();

            for (auto& thread : workers)
                thread.join();
        }

        void wait_and_clear_threads(vector<future<void>>& threads)
        {
            for (future<void>& t : threads)
            {
                t.wait();
            }
            threads.clear();
        }

        template <class T>
        auto enqueue(T task) -> std::future<decltype(task())>
        {
            //Wrap the function in a packaged_task so we can return a future object
            auto wrapper = std::make_shared<std::packaged_task<decltype(task())()>>(std::move(task));

            //Scope to restrict critical section
            {
                //lock our queue and add the given task to it
                std::unique_lock<std::mutex> lock(queue_mutex);

                tasks.push_back([=]
                    {
                        (*wrapper)();
                    });
            }

            //Wake up a thread to start this task
            condition.notify_one();

            return wrapper->get_future();
        }

    private:
        friend class Worker; //Gives access to the private variables of this class

        std::vector<std::thread> workers;
        std::deque<std::function<void()>> tasks;

        std::condition_variable condition; //Wakes up a thread when work is available

        std::mutex queue_mutex; //Lock for our queue
        bool stop = false;
    };

    inline void Worker::operator()()
    {
        std::function<void()> task;
        while (true)
        {
            //Scope to restrict critical section
            //This is important because we don't want to hold the lock while executing the task,
            //because that would make it so only one task can be run simultaneously (aka sequantial)
            {
                std::unique_lock<std::mutex> locker(pool.queue_mutex);

                //Wait until some work is ready or we are stopping the threadpool
                //Because of spurious wakeups we need to check if there is actually a task available or we are stopping
                pool.condition.wait(locker, [=] { return pool.stop || !pool.tasks.empty(); });

                if (pool.stop) break;

                task = pool.tasks.front();
                pool.tasks.pop_front();
            }

            task();
        }
    }

} // namespace Tmpl8