Question

我无法弄清楚这个简单代码的问题在哪里，我认为这是输出到控制台的问题可能是死锁或其他什么的，有人可以帮忙。

#include <iostream>
#include <string>
#include <sstream>
#include <boost/thread.hpp>

using namespace std;
struct IntegrateTask
{
   int id;
   double from, to, step, result;

   IntegrateTask(int id, double from, double to, double step)
   {
       this -> id;
       this -> from = from;
       this -> to = to;
       this -> step = step;
   }

   ~IntegrateTask()
   {}
};

vector<IntegrateTask> * tasks = new vector<IntegrateTask>();
boost::mutex mutlist;
boost::mutex iomutex;
boost::condition_variable condtask;

bool isInterrupted = false;

double foo(double x)
{
    return x * x;
}

void integrate(IntegrateTask * task)
{
   double result = 0;
   double step = task -> step;
   for(double i = task -> from ; i != task -> to; i =+ step)
   {
       result += foo(i) * step;
   }
   task -> result = result;
}

void integrateThread()
{

   boost::thread::id id = boost::this_thread::get_id();

   try
   {
       {
           boost::mutex::scoped_lock iolock(iomutex);
           cout << "Thread #" << id << " is working!" << endl;
       }
       while(!isInterrupted)
       {
           IntegrateTask * currtask = NULL;

           {
               boost::mutex::scoped_lock lock(mutlist);                  
               while(!isInterrupted && tasks -> empty())
               {
                   condtask.wait(lock);
               }
               if (!tasks -> empty())
               {
                   currtask = &tasks->back();
                   tasks->pop_back();
               }    
           }
           if (currtask != NULL)
           {
               integrate(currtask);
               boost::mutex::scoped_lock iolock(iomutex);    
               cout << "Task #" << (currtask->id) << "; result = " << (currtask->result) << endl;     
           }
       }
       boost::mutex::scoped_lock iolock(iomutex);
       cout << "Thread # " << id << " stoped working normal!" << endl;    
   }
   catch(boost::thread_interrupted)
   {
       boost::mutex::scoped_lock ioLock(iomutex);
       cout << "Thread # " << id << " stoped working by interruption!" << endl;
   }
   catch(exception & e)
   {
       boost::mutex::scoped_lock iolock(iomutex);
       cout << "Error: " << e.what() << endl;        
   }
}

int main()
{

   cout << "Function for integration: f(x)=x*x" << endl;
   cout << "For stopping program press EXIT" << endl;

   int thcount = 6;// or boost::thread::hardware_concurrency()
   boost::thread_group thgroup;
   for (int i = 1; i <= thcount; i++){
       thgroup.create_thread(&integrateThread);
   }

   int id = 0;

   while (true)
   {
       string line;
       {
           boost::mutex::scoped_lock iolock(iomutex);
           cout << "Task #" << ++id << "; left bound, right bound and step: ";
           getline(cin, line);
       }

       if (line.find("e") != string::npos)
       {
           isInterrupted = true;
           condtask.notify_all();
           thgroup.interrupt_all();
           thgroup.join_all();    
           return 0;
       }

       double from, to, step;
       istringstream input(line);
       input >> from >> to >> step;    

       IntegrateTask * task = new IntegrateTask(id, from, to, step);        
       {
           boost::mutex::scoped_lock lock(mutlist);
           tasks->push_back(*task);            
       }    
       condtask.notify_one();    
   }

}

Answer 1

我没有尝试遵循你想要达到的目标的逻辑，但有两个问题（至少）：

您未在id的构造函数中使用IntegrateTask。您通常应该优先使用初始化列表而不是构造函数体中的赋值，并且在函数签名中使用类成员变量名称也是一种灾难，因此我将构造函数更改为：
```
IntegrateTask(int id_init, double from_init, double to_init, double step_init)
    : from(from_init), to(to_init), step(step_init), id(id_init) {}
```
挂起的可能原因是您在!=的{{1}}循环中使用了for。如果你改为integrate你的程序不应该挂起，但我不确定这是否会破坏程序的逻辑。

升压错误锁定问题

1 个答案: