스레드에서 예외를 throw하는 것이 예상 결과를 제공하지 않습니다.

Question

아래 코드에서 동일한 예외를 다시 throw 한 후에 예외를 catch하려고 시도하지만 동일한 결과를 얻을 수 없습니다. 나는 current_exception()을 통해 현재 teptr 상태를 보존했기 때문에 무엇이 잘못되었는지 확신하지 못한다. 스레드가 연속 루프에서 실행되므로 해당 값이 큰 2에 도달하면 catch 블록이 실행되고 제어가 루프에서 벗어나지 만 예상대로 계속 첫 번째 시도에서 다른 catch 블록에 도달 할 수 없습니다.

#include <boost/thread.hpp> 
#include <boost/thread/scoped_thread.hpp> 
#include <boost/chrono.hpp> 
#include <iostream> 
#include <boost/exception/all.hpp> 
#include <exception> 
using namespace std; 
boost::exception_ptr teptr; 

class myexception : public exception 
{ 
    virtual const char* what() const throw() 
    { 
     return "My exception happened"; 
    } 
} myex; 

class ABC 
{ 
public: 
    void start(); 

}; 

void ABC::start() 
{ 
    int i = 0; 
    cout << "running the thread" << std::endl; 

    while (1) 
    { 
     try 
     { 
      std::cout << "value of " << i << '\n'; 

      if (i > 2) 
      { 
       throw boost::enable_current_exception(myex); 
      } 
      i++; 
     } 
     catch (exception& e) 
     { 
      cout << "actual exception is" << e.what() << '\n'; 
      teptr = boost::current_exception(); 
      break; 
      //throw myex; 
     } 
    } 
} 

int main() 
{ 
    ABC abc; 
    boost::thread thread_point; 

    while (1) 
    { 
     boost::thread thread_point; 
     thread_point = boost::thread(&ABC::start, abc); 

     if (teptr) { 

      try { 
       boost::rethrow_exception(teptr); 
      } 
      catch (const std::exception &ex) 
      { 
       std::cerr << "Thread exited with exception: " << ex.what() << "\n"; 
       exit(0); 
      } 
     } 
    } 
} 

Answer 1

프로그램은 동기없이 여러 스레드에서 변수 teptr (및 myex)을 동시에 액세스합니다. 동작은 정의되지 않습니다.

더 나쁜 것은 thread_point을 섀도 잉하고 결합되지 않은 많은 스레드를 만드는 것입니다. 말 그대로 무제한의 쓰레드가 같은 글로벌 데이터를 공유하고 있습니다.

실제로 어디서나 값이나 예외를 반환 할 수있는 future을 찾고 있다고 가정합니다. 모든 예외 처리 마법은 당신을 위해 수행됩니다

Live On Coliru

#include <thread> 
#include <future> 
#include <iostream> 
#include <sstream> 

struct ABC { 
    int task(int until) { 
     for (int i = 0; i<10; ++i) { 
      if (i > until) { 
       std::ostringstream oss; 
       oss << "My exception happened in thread " << std::this_thread::get_id() << " at i=" << i; 
       throw std::runtime_error(oss.str()); 
      } 
     } 

     return 42; 
    } 
}; 

int main() { 
    for (int runs = 0; runs < 10; ++runs) { 
     ABC abc; 
     std::future<int> result = std::async(&ABC::task, &abc, rand()%20); 

     try { 
      std::cout << "Task returned " << result.get() << "\n"; 
     } catch (const std::exception &ex) { 
      std::cout << "Task exited with exception: " << ex.what() << "\n"; 
      std::cerr << "Thread exited with exception: " << ex.what() << "\n"; 
     } 
    } 
} 

인쇄 (예를)

(teptr가)`하기 전에 실행하면`중지 거기에 아무것도 여기

Task returned Task exited with exception: My exception happened in thread 140288972076800 at i=4 
Thread exited with exception: My exception happened in thread 140288972076800 at i=4 
Task returned Task exited with exception: My exception happened in thread 140288972076800 at i=7 
Thread exited with exception: My exception happened in thread 140288972076800 at i=7 
Task returned 42 
Task returned 42 
Task returned 42 
Task returned 42 
Task returned Task exited with exception: My exception happened in thread 140288972076800 at i=7 
Thread exited with exception: My exception happened in thread 140288972076800 at i=7 
Task returned 42 
Task returned 42 
Task returned Task exited with exception: My exception happened in thread 140288972076800 at i=2 
Thread exited with exception: My exception happened in thread 140288972076800 at i=2 

Answer 2

업데이트 내 대답은 결핍과 오류, sehe의 의견을 참조하십시오.

최종 목표는 무엇인지 모르겠지만 스레드에서 던지기를 처리하는 방법을 알아 내려고합니다. 예, Boost Exception을 사용하여 컴파일러가 스레드간에 던지지 못하게 할 수 있습니다.

#include <boost/thread.hpp> 
#include <boost/thread/scoped_thread.hpp> 
#include <boost/chrono.hpp> 
#include <iostream> 
#include <boost/exception/all.hpp> 
#include <exception> 

boost::exception_ptr teptr; 
class myexception: public std::exception 
{ 
    virtual const char* what() const throw() 
    { 
     return "My exception happened"; 
    } 
} myex; 


class ABCc 
{ 
public: 
    void start(); 
}; 

void ABCc::start() 
{ 
    int i=0; 
    std::cout<<"running the thread"<<std::endl; 

    while (1) 
    { 
     try 
     { 
      std::cout << "value of "<<i << '\n'; 

      if(i>2) 
      { 
       throw boost::enable_current_exception(myex); 
      } 
      i++; 
     } 
     catch (std::exception& e) 
     { 
      std::cout << "actual exception is"<<e.what() << '\n'; 
      teptr=boost::current_exception(); 
      break; 
      // where were you going here??????? 
      //throw myex; 
     } 
    } 
} 

int main() 
{ 
    ABCc abc; 
    boost::thread thread_point; 
    thread_point = boost::thread(&ABCc::start,abc); 
    while(1) 
    { 
     if (teptr) { 
      try { 
       boost::rethrow_exception(teptr); 
      } 
      catch(const std::exception &ex) { 
       std::cerr << "Thread may have exited; exception thrown: " << ex.what() << "\n"; 
       break; 
      } 
     } 
    } 
    std::cout << "exception should have been caught" << std::endl; 
    return 0; 
} 

주를 던지거나 캐치 할 필요가 없습니다. 루프 내에서 boost :: thread를 사용하여 다중 쓰레드를 생성하는 것은 의도였습니까?