Долго отрабатывает деструктор класса после заполнения из нескольких потоков

#include <thread>
#include <iostream>
#include <functional>
#include <vector>
 
 
class item
{
public:
    int data[10000];
};
 
class container
{
    int size;
    item*** data;
public:
    container(int size) : size(size)
    {
        data = new item * *[size];
        for (auto i = 0; i < size; ++i)
        {
            data[i] = new item * [size];
        }
    }
 
    void set_item(item* item, int x, int y)
    {
        data[x][y] = item;
    }
 
    ~container()
    {
        for (auto i = 0; i < size; ++i)
        {
            for (auto j = 0; j < size; ++j)
            {
                delete data[i][j];
            }
            delete[] data[i];
        }
        delete[] data;
    }
};
 
 
class test_class
{
    container* container;
    int size;
 
public:
    test_class(int size) : size(size)
    {
        container = new class container(size);
    }
 
    void fill()
    {
        for (auto x = 0; x < size; ++x)
        {
            for (auto y = 0; y < size; ++y)
            {
                auto item0 = new item();
                container->set_item(item0, x, y);
            }
        }
    }
 
    void fill_2_threads()
    {
        std::thread t1{ [this]
        {
            for (auto x = 0; x < size / 2; ++x)
            {
                for (auto y = 0; y < size; ++y)
                {
                    container->set_item(new item(), x, y);
                }
            }
        } };
 
        std::thread t2{ [this]
        {
            for (auto x = size / 2; x < size; ++x)
            {
                for (auto y = 0; y < size; ++y)
                {
                    container->set_item(new item(), x, y);
                }
            }
        } };
 
        t1.join();
        t2.join();
    }
 
    void rm_container()
    {
        delete container;
    }
};
 
void log_time(std::function<void()> fn, std::string dsc)
{
    auto t0 = std::chrono::high_resolution_clock::now();
    fn();
    auto t1 = std::chrono::high_resolution_clock::now();
    std::cout << dsc << "\t " << (t1 - t0).count() * 1e-6 << " ms" << std::endl;
}
 
 
void test()
{
    auto size = 200;
    test_class tc{ size };
    log_time([&tc] {tc.fill(); }, "fill");
    log_time([&tc] {tc.rm_container(); }, "rm fill");
    std::cout << std::endl;
    test_class tc1{ size };
    log_time([&tc1] {tc1.fill_2_threads(); }, "fill 2 threads");
    log_time([&tc1] {tc1.rm_container(); }, "rm 2 threads");
 
}
 
 
int main() {
 
    test();
    system("pause");
    return 0;
}

#include <iostream>
using namespace std;
 
class Fish
{
  public:
  virtual void Swim()
  {
    cout << "Fish swims in water" << endl;
  }
 
  // базовый класс всегда должен иметь виртуальный деструктор
  virtual -Fish() {}
};
 
class Tuna: public Fish
{
    public:
    void Swim()
    {
    cout << "Tuna swims real fast in the sea" << endl;
    }
 
    void BecomeDinner()
    {
    cout << "Tuna became dinner in Sushi" << endl;
    }
};
 
class Carp: public Fish
{
    public:
    void Swim()
    {
    cout << "Carp swims real slow in the lake" << endl;
    }
 
    void Talk()
    {
    cout << "Carp talked crap" << endl;
    }
};
 
void DetectFishType(Fish* InputFish)
{
    Tuna* pIsTuna = dynamic_cast <Tuna*>(InputFish);
    if (pIsTuna)
    {
        cout << "Detected Tuna. Making Tuna dinner: " << endl;
        pIsTuna->BecomeDinner(); // вызов Tuna::BecomeDinner
    }
 
    Carp* plsCarp = dynamic_cast <Carp*>(InputFish);
    if(plsCarp)
    {
        cout << "Detected Carp. Making carp talk: " << endl;
        pIsCarp->Talk(); // вызов Carp::Talk
    }
 
    cout << "Verifying type using virtual Fish::Swim: " << endl;
    InputFish->Swim(); // вызов виртуальной функции Swim
}
 
int main()
{
    Carp myLunch;
    Tuna myDinner;
    DetectFishType(SmyDinner);
    cout << endl;
    Операторы приведения C++ 345
    DetectFishType(&myLunch);
    return 0;
}