Mutex destroyed while busy

#include <iostream>
#include "SuperLongInt.h"
#include <mutex>
#include <thread>
#include <fstream>
#include <locale>
#include <time.h>
 
const int DIGITSLEN = 10000;
const int QUEUELEN = 100;
 
std::mutex mutex;
 
void threads(SuperLongInt& exp, SuperLongInt& d1, long long int& n, std::mutex& finishMutex)
{
    finishMutex.lock();
    SuperLongInt Queue[QUEUELEN];
    int i;
 
    while(d1.isNotZero())
    {
        mutex.lock();
        for(i = 0; i < QUEUELEN && d1.isNotZero(); i++)
        {
            d1 /= n++;
            Queue[i] = d1;
        }
        mutex.unlock();
 
        for(int j = 0; j < i; j++)
        {
            exp += Queue[j];
        }
    }
    finishMutex.unlock();
}
 
 
 
int main(int argc, char** argv)
{
    setlocale(LC_ALL, "rus");
    clock_t start, end;
    start = clock();
    std::ofstream f("digit.txt");
 
    SuperLongInt exp(DIGITSLEN, 1);
    SuperLongInt d1(DIGITSLEN, 1);
    long long int n = 1;
    
    int quantityThreads = std::thread::hardware_concurrency();
    if (!quantityThreads)
    {
        quantityThreads = 2;
    }
    std::cout << "Запущено в " << quantityThreads << " потока" << std::endl;
 
    std::mutex* finishMutexes = new std::mutex [quantityThreads];
    SuperLongInt* exps = new SuperLongInt [quantityThreads];
 
    for (int i = 0; i < quantityThreads; i++)
    {
        exps[i].setLen(DIGITSLEN, 0);
        std::thread th(threads, std::ref(exps[i]), std::ref(d1),
                       std::ref(n), std::ref(finishMutexes[i]));
        if (quantityThreads - 1 == i)
        {
            th.join();
        }
        else
        {
            th.detach();
        }
    }
 
    for (int i = 0; i < quantityThreads; i++)
    {
        finishMutexes[i].lock();
    }
 
    for(int i = 0; i < quantityThreads; i++)
    {
        exp += exps[i];
    }
 
    end = clock();
    f << exp;
 
    delete [] finishMutexes;
    delete [] exps;
 
    std::cout << "Времени затрачено = " << end - start << std::endl;
    return 0;
}

~mutex();
Destroys the mutex.
The behavior is undefined if the mutex is owned by any thread or if any thread terminates while holding any ownership of the mutex.