I’m making a program that creates some random arrays and then uses two different sorting functions to sort them. First, I create a vector of Fleet objects with different sizes. Then, for each fleet I create an array of threads and in each thread I put a lambda function that copies a fleet and sorts it. It works fine but when it comes to joining threads I get “Process finished with exit code -1073741819 (0xC0000005)”. It successfully joins the first thread but not the second. What might be the problem?

#include <vector>
#include <random>
#include <algorithm>
#include <thread>

using namespace std;

class Fleet {
private:
    int fleet_size;
    vector<int> fleet;
    int rnd_lower = 100;
    int rnd_upper = 1000;
public:
    Fleet(int size) {
        fleet_size = size;
        fleet.resize(fleet_size);

        random_device rd;
        mt19937 gen(rd());
        uniform_int_distribution<int> dist(rnd_lower, rnd_upper);

        for (int i = 0; i < size; ++i) {
            fleet[i] = dist(rd);
        }
    }
    void Print() {
        if (fleet_size < 30) {
            for (int i = 0; i < fleet_size; ++i) {
                cout << fleet[i] << " ";
            }
        }
        else {
            for (int i = 0; i < fleet_size; ++i) {
                if (i == 4) {
                    cout << ". . . ";
                    i = fleet_size - 4;
                }
                cout << fleet[i] << " ";
            }
        }
        cout << endl;
    }
    void LSDSort();
    void BucketSort();
};

int main() {
    vector<Fleet> fleets;
    for (int i = 100, j = 2; i < 1000000; i *= j) {
        fleets.emplace_back(i);
    }

    void (Fleet::*sortingFunctions[])() {
            &Fleet::BucketSort,
            &Fleet::LSDSort
    };

    int sortings = sizeof(sortingFunctions) / sizeof(sortingFunctions[0]);

    for (int i = 0; i < fleets.size(); ++i) {
        thread threads[sortings];
        for (int j = 0; j < sortings; ++j) {
            threads[j] = thread([=]() {
                Fleet tempFleet = fleets[i];
                (tempFleet.*sortingFunctions[j])();
                tempFleet.Print();
            });
        }

        for (auto &thread: threads) {
            thread.join();
        }
    }

    return 0;
}

void Fleet::LSDSort() {
    int max_value = *max_element(fleet.begin(), fleet.end());
    int max_digits = log10(max_value) + 1;

    vector<int> sorted(fleet_size);

    for (int digit = 0; digit < max_digits; ++digit) {
        vector<int> count(10, 0);

        for (const auto &value : fleet) {
            int digit_value = (value / static_cast<int>(pow(10, digit))) % 10;
            count[digit_value]++;
        }

        for (int i = 1; i < 10; ++i) {
            count[i] += count[i - 1];
        }

        for (int i = fleet_size - 1; i >= 0; --i) {
            int digit_value = (fleet[i] / static_cast<int>(pow(10, digit))) % 10;
            sorted[count[digit_value] - 1] = fleet[i];
            count[digit_value]--;
        }

        fleet = sorted;
    }
}

void Fleet::BucketSort() {
    int num_buckets = 10;
    vector<vector<int>> buckets(num_buckets);

    int max_value = *max_element(fleet.begin(), fleet.end());
    int min_value = *min_element(fleet.begin(), fleet.end());
    int range = max_value - min_value + 1;

    for (const auto &value : fleet) {
        int bucket_index = (value - min_value) / (range / num_buckets);
        buckets[bucket_index].push_back(value);
    }

    fleet.clear();
    for (auto &bucket : buckets) {
        sort(bucket.begin(), bucket.end());
        fleet.insert(fleet.end(), bucket.begin(), bucket.end());
    }
}

Tried used vector, changing the lambda function but with no success.