detached thread crashing on exiting

I am using a simple thread pool as below-

template<typename T>
class thread_safe_queue // thread safe worker queue.
{
private:
    std::atomic<bool> finish;
    mutable std::mutex mut;
    std::queue<T> data_queue;
    std::condition_variable data_cond;
public:
    thread_safe_queue() : finish{ false }
    {}

    ~thread_safe_queue()
    {}

    void setDone()
    {
        finish.store(true);
        data_cond.notify_one();
    }
    void push(T new_value)
    {
        std::lock_guard<std::mutex> lk(mut);
        data_queue.push(std::move(new_value));
        data_cond.notify_one();
    }

    void wait_and_pop(T& value)
    {
        std::unique_lock<std::mutex> lk(mut);
        data_cond.wait(lk, [this]
        {
            return false == data_queue.empty();
        });
        if (finish.load() == true)
            return;
        value = std::move(data_queue.front());
        data_queue.pop();
    }
    bool empty() const
    {
        std::lock_guard<std::mutex> lk(mut);
        return data_queue.empty();
    }
};

//Thread Pool
class ThreadPool
{
private:
    std::atomic<bool> done;
    unsigned thread_count;
    std::vector<std::thread> threads;

public:
    explicit ThreadPool(unsigned count = 1);

    ThreadPool(const ThreadPool & other) = delete;
    ThreadPool& operator = (const ThreadPool & other) = delete;

    ~ThreadPool()
    {
        done.store(true);
        work_queue.setDone();
        // IF thread is NOT marked detached and this is uncommented the worker threads waits infinitely.
        //for (auto &th : threads)
        //{
         //     if (th.joinable())
         //     th.join();
        // }
    }

    void init()
    {
        try
        {
            thread_count = std::min(thread_count, std::thread::hardware_concurrency());
            for (unsigned i = 0; i < thread_count; ++i)
            {
                threads.emplace_back(std::move(std::thread(&ThreadPool::workerThread, this)));
                threads.back().detach();
              // here the problem is if i dont mark it detatched thread infinitely waits for condition.
             // if i comment out the detach line and uncomment out comment lines in ~ThreadPool main threads waits infinitely.
            }
        }
        catch (...)
        {
            done.store(true);
            throw;
        }
    }

    void workerThread()
    {
        while (true)
        {
            std::function<void()> task;
            work_queue.wait_and_pop(task);
            if (done == true)
                break;
            task();
        }
    }
    void submit(std::function<void(void)> fn)
    {
        work_queue.push(fn);
    }
};

The usage is like :

struct start
{
public:
    ThreadPool::ThreadPool m_NotifPool;
    ThreadPool::ThreadPool m_SnapPool;
    start()
    {
        m_NotifPool.init();
        m_SnapPool.init();
    }
};    
int main()
{
    start s;
    return 0;
}    

I am running this code on visual studio 2013. The problem is when main thread exits. The program crashes. It throws exception. Please help me with what am i doing wrong? How do i stop the worker thread properly? I have spent quite some time but still figuring out what is the issue.

Thanks for your help in advance.