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的析构函数以相反的顺序被调用。

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

1 个答案: