향후 변환을위한 패턴

Question

현재 비동기 값을 매우 많이 사용하고 있습니다. 이 같은 (WORKER_QUEUE을 - 우리는 packaged_task에 의해 설정 될 것 같은 int 값에 미래를 만드는 작업을 생성 코드에서 어떤 시점에서

int do_something(const boost::posix_time::time_duration& sleep_time) 
{ 
    BOOST_MESSAGE("Sleeping a bit"); 
    boost::this_thread::sleep(sleep_time); 
    BOOST_MESSAGE("Finished taking a nap"); 

    return 42; 
} 

: 내가 이런 일을하는 기능을 가지고 있다고 가정

boost::unique_future<int> createAsynchronousValue(const boost::posix_time::seconds& sleep) 
{ 
    boost::shared_ptr< boost::packaged_task<int> > task(
     new boost::packaged_task<int>(boost::bind(do_something, sleep))); 
    boost::unique_future<int> ret = task->get_future(); 

    // Trigger execution 
    working_queue.post(boost::bind(&boost::packaged_task<int>::operator(), task)); 

    return boost::move(ret); 
} 

코드의 다른 지점에서 나는 또한 앞으로해야합니다 몇 가지 높은 수준의 객체를 반환하기 위해이 기능을 포장 할 : 부스트 ::이 예에서는 ASIO :: io_service)입니다. 첫 번째 값을 가져 와서 다른 값으로 변환하는 변환 함수가 필요합니다. 실제 코드에서는 레이어를 만들고 응답에 미래를 반환하는 비동기 RPC를 수행합니다.이 응답은 실제 개체, POD 또는 무효로 변환되어야합니다. 그것을 기다리거나 예외를 잡을 수있는 미래). 그때가

void invoke_lazy_task(boost::packaged_task<float>& task) 
{ 
    try 
    { 
     task(); 
    } 
    catch(boost::task_already_started&) 
    {} 
} 

그리고 :

float converter(boost::shared_future<int> value) 
{ 
    BOOST_MESSAGE("Converting value " << value.get()); 
    return 1.0f * value.get(); 
} 

그럼 내가 원하는 경우에만이 변환을 수행 할 부스트 문서에 설명 된대로 게으른 미래를 만드는 생각 : 그래서 이것은이 예에서 변환 기능입니다 나는이 같이 사용할 수 있도록하려면 끝에서

boost::unique_future<float> createWrappedFuture(const boost::posix_time::seconds& sleep) 
{ 
    boost::shared_future<int> int_future(createAsynchronousValue(sleep)); 
    BOOST_MESSAGE("Creating converter task"); 
    boost::packaged_task<float> wrapper(boost::bind(converter, int_future)); 

    BOOST_MESSAGE("Setting wait callback"); 
    wrapper.set_wait_callback(invoke_lazy_task); 

    BOOST_MESSAGE("Creating future to converter task"); 
    boost::unique_future<float> future = wrapper.get_future(); 

    BOOST_MESSAGE("Returning the future"); 
    return boost::move(future); 
} 

: 함수는 포장 미래를 창조하는 (높은 수준의 API 수 있습니다)

{  
    boost::unique_future<float> future = createWrappedFuture(boost::posix_time::seconds(1)); 
    BOOST_MESSAGE("Waiting for the future"); 
    future.wait(); 
    BOOST_CHECK_EQUAL(future.get(), 42.0f); 
} 

하지만 여기에서는 끝내주는 약속에 대한 예외가 발생합니다. 그 이유는 변환 작업을 수행하는 packaged_task가 범위를 벗어나기 때문에 나에게 꽤 분명해 보입니다.

내 탐구는 다음과 같습니다. 어떻게 이런 상황을 처리합니까? 작업이 파괴되지 않게하려면 어떻게합니까? 이 패턴이 있습니까?

Bests,

로니

Answer 1

당신은 제대로 작업 개체의 수명을 관리해야합니다.

boost::unique_future<float> 대신 boost::packaged_task<float>을 createWrappedFuture()에서 반환하는 것이 가장 올바른 방법입니다. 호출자는 미래의 객체를 얻고 미래의 가치가 준비 될 때까지 작업 수명을 연장해야 할 책임이 있습니다.

또는 작업 객체를 createAsynchronousValue에서와 비슷한 방식으로 '보류 중'대기열 (전역 또는 클래스 멤버)에 배치 할 수 있습니다. 그러나이 경우에는 작업 수명을 명시 적으로 관리하고 완료 후 대기열에서 제거해야합니다. 따라서이 솔루션에는 작업 객체 자체를 반환하는 것에 대한 이점이 있다고 생각하지 마십시오.