C++ 线程死锁互斥锁中止

Question

我正在尝试从程序中消除死锁。问题是程序一直让我中止。重点是将数据写入文件。但是当发生死锁时，线程应该等待并稍后继续，而不是中止。

#include <iostream>
#include <unistd.h>
#include <fstream>
#include <vector>
#include <thread>
#include <mutex>
#include <exception>
#include <condition_variable>

using namespace std;

std::mutex mtx;
ofstream myfile;
condition_variable cv;

void lock()
{
  mtx.lock();
}

void unlock()
{
  mtx.unlock();
}

void writeToFile(int threadNumber){
 myfile << "[";
    for(int j =1; j <= 10; j++){
        int num = j * threadNumber;
        string line = std::to_string(num) + " ";
        myfile << line;
    }
    myfile << "]";
//mtx.unlock();
}

void threadFunction(int threadNumber)
{
//  int x = 0;
//  int y = 0;

  try{
    lock();
    if (threadNumber % 2 == 0)
      sleep(rand() % 4 + 1);
    writeToFile(threadNumber);
    throw exception();
   unlock();
  } 
  catch(...){
    cout << "Something went wrong!" << endl;
    throw exception();
  }
}


int main (int argc, char const *argv[]) {
myfile.open ("mutex.txt");
    std::set_terminate([](){
    std::cout << "Unhandled exception\n";
    // Here I want to fix the deadlock if something goes wrong. But I keep getting Abroted

    });
        int len;
        cout << "Enter Number of threads : ";
        cin >> len;
        std::thread t[len + 1];
         for(int i =1; i <= len;i++){
            t[i] = std::thread(threadFunction, i);
            cout << "Created Thread : " <<t[i].get_id()<<endl;
           }

            for(int i =1; i <= len;i++){
             t[i].join();
             }
        myfile.close();
        return 0;
}

输出

   Enter Number of threads : 5
Created Thread : 1992414288
Created Thread : 1982854224
Created Thread : 1974465616
Created Thread : 1966077008
Created Thread : 1957688400
Something went wrong!
Unhandled exception
Aborted

如何避免中止，让线程等待。

更新：包含所有相关代码...

Answer 1

不要手动 lock() / unlock() 互斥锁。这很容易出错。请改用guards。 mtx.unlock(); 抛出异常后不会被调用。

您的代码应如下所示：

  try{
    std::lock_guard<std::mutex> lock(mtx);
    if (threadNumber % 2 == 0)
      sleep(rand() % 4 + 1);
    writeToFile(threadNumber);
    throw exception();
  } 
  catch(...){
    cout << "Something went wrong!" << endl;
    throw exception();
  }

---

为了避免死锁，通常需要以相反的顺序对多个互斥锁进行锁定和解锁。所以如果一个线程使用类似的东西

{
    std::lock_guard<std::mutex> lock1(mtx1);
    std::lock_guard<std::mutex> lock2(mtx2);
    // ... exception thrown somewhere
}

这是有保证的，因为std::lock_guard 的析构函数保证会以与构造相反的顺序被调用。