QFuture Class

멤버 함수 문서

QFuture::QFuture()

취소된 비어 있는 미래를 구성합니다.

QFuture::QFuture(const QFuture<T> &other)

other 의 복사본을 생성합니다.

operator=()도 참조하세요 .

QFuture::~QFuture()

미래를 파괴합니다.

비동기 계산을 기다리거나 취소하지 않는다는 점에 유의하세요. 미래가 파괴되기 전에 계산이 완료되었는지 확인해야 하는 경우 waitForFinished() 또는 QFutureSynchronizer 을 사용하세요.

template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> QFuture<T>::const_iterator QFuture::begin() const

미래의 첫 번째 결과를 가리키는 상수 STL 스타일 이터레이터를 반환합니다.

constBegin() 및 end()도 참조하세요 .

void QFuture::cancel()

이 미래로 표시되는 비동기 계산을 취소합니다. 취소는 비동기식이라는 점에 유의하세요. 동기식 취소가 필요한 경우 취소() 호출 후 waitForFinished()를 사용하세요.

현재 사용 가능한 결과는 취소된 미래에서도 계속 액세스할 수 있지만 이 함수를 호출한 후에는 새 결과를 사용할 수 없게 됩니다. 이 미래를 보고 있는 QFutureWatcher 객체는 취소된 미래에 진행 상황 및 결과 준비 신호를 전달하지 않습니다.

실행 중인 모든 비동기 계산을 취소할 수 있는 것은 아니라는 점에 유의하세요. 예를 들어, QtConcurrent::run()이 반환한 퓨처는 취소할 수 없지만, QtConcurrent::mappedReduced()가 반환한 퓨처는 취소할 수 있습니다.

template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> QFuture<T>::const_iterator QFuture::constBegin() const

미래의 첫 번째 결과를 가리키는 상수 STL 스타일 이터레이터를 반환합니다.

begin() 및 constEnd()도 참조하세요 .

template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> QFuture<T>::const_iterator QFuture::constEnd() const

미래의 마지막 결과 이후의 가상의 결과를 가리키는 상수 STL 스타일 이터레이터를 반환합니다.

constBegin() 및 end()도 참조하세요 .

template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> QFuture<T>::const_iterator QFuture::end() const

미래의 마지막 결과 이후의 가상의 결과를 가리키는 상수 STL 스타일 이터레이터를 반환합니다.

begin() 및 constEnd()도 참조하세요 .

bool QFuture::isCanceled() const

비동기 계산이 cancel() 함수로 취소된 경우 true 를 반환하고, 그렇지 않으면 false 를 반환합니다.

이 함수가 true 을 반환하더라도 계산이 계속 실행 중일 수 있다는 점에 유의하세요. 자세한 내용은 cancel()를 참조하세요.

bool QFuture::isFinished() const

이 미래로 표현된 비동기 계산이 완료되면 true 을 반환하고, 그렇지 않으면 false 을 반환합니다.

template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> bool QFuture::isResultReadyAt(int index) const

index 의 결과를 즉시 사용할 수 있으면 true 을 반환하고, 그렇지 않으면 false 을 반환합니다.

resultAt(), resultCount() 및 takeResult()도 참조하세요 .

bool QFuture::isRunning() const

이 미래가 나타내는 비동기 계산이 현재 실행 중이면 true 을 반환하고, 그렇지 않으면 false 을 반환합니다.

bool QFuture::isStarted() const

이 미래로 표시되는 비동기 계산이 시작되면 true 을 반환하고, 그렇지 않으면 false 을 반환합니다.

[since 6.0] bool QFuture::isSuspended() const

비동기 계산의 일시 중지가 요청되었고, 더 이상 결과나 진행 상황의 변경이 예상되지 않는다는 의미로 유효할 경우 true 을 반환합니다.

이 함수는 Qt 6.0에 도입되었습니다.

setSuspended(), toggleSuspended() 및 isSuspending()도 참조하십시오 .

[since 6.0] bool QFuture::isSuspending() const

비동기 계산이 suspend() 함수로 일시 중단되었지만 아직 작업이 일시 중단되지 않았고 계산이 계속 실행 중인 경우 true 을 반환합니다. 그렇지 않으면 false 을 반환합니다.

일시 중단이 실제로 적용되고 있는지 확인하려면 isSuspended() 대신 사용하세요.

이 함수는 Qt 6.0에 도입되었습니다.

setSuspended(), toggleSuspended() 및 isSuspended()도 참조하십시오 .

[since 6.0] bool QFuture::isValid() const

이 QFuture 객체에서 하나 이상의 결과에 액세스하거나 결과를 가져올 수 있으면 true 을 반환합니다. 미래에서 결과를 가져온 후에는 false를 반환합니다.

이 함수는 Qt 6.0에 도입되었습니다.

takeResult(), result(), results() 및 resultAt()도 참조하세요 .

[since 6.0] template <typename Function, typename = std::enable_if_t<std::is_invocable_r_v<T, Function>>> QFuture<T> QFuture::onCanceled(Function &&handler)

이 퓨처에 취소 handler 를 첨부합니다. 반환된 퓨처는 이 퓨처가 취소되지 않는 한 이 퓨처와 정확히 동작합니다(동일한 상태와 결과를 가짐). handler 은 인수를 받지 않고 이 퓨처가 패키징한 타입의 값을 반환하는 콜러블입니다. 취소 후 반환된 퓨처는 handler 에서 반환한 값을 패키징합니다.

취소 전에 첨부된 경우, 취소 후 완료된 것으로 퓨처를 보고하는 동일한 스레드에서 handler 가 호출됩니다. 이 퓨처가 이미 취소된 후에 핸들러가 첨부되면 onCanceled() 을 실행하는 스레드에서 즉시 호출됩니다. 따라서 핸들러는 항상 어떤 스레드에서 실행될지 가정할 수 없습니다. 처리기가 어떤 스레드에서 호출되는지 제어하려면 컨텍스트 객체를 받는 오버로드를 사용하세요.

아래 예는 취소 처리기를 첨부하는 방법을 보여줍니다:

QFuture<int> testFuture = ...;
auto resultFuture = testFuture.then([](int res) {
    // Block 1
    ...
    return 1;
}).then([](int res) {
    // Block 2
    ...
    return 2;
}).onCanceled([] {
    // Block 3
    ...
    return -1;
});

testFuture 가 취소되면 Block 3 가 호출되고 resultFuture 는 그 결과로 -1 를 갖게 됩니다. testFuture 와는 달리 Canceled 상태가 되지 않습니다. 즉, 결과를 가져오고 카운트다운을 첨부하는 등의 작업을 할 수 있습니다.

또한 연속 체인이 실행되는 동안 체인을 시작한 퓨처를 통해 연속 체인을 취소할 수 있다는 점에 유의하세요. Block 1 이 이미 실행되고 있는 동안 testFuture.cancel() 이 호출되었다고 가정해 보겠습니다. 다음 연속은 취소가 요청되었음을 감지하여 Block 2 을 건너뛰고 취소 핸들러(Block 3)를 호출합니다.

이 함수는 Qt 6.0에 도입되었습니다.

then() 및 onFailed()도 참조하십시오 .

[since 6.1] template <typename Function, typename = std::enable_if_t<std::is_invocable_r_v<T, Function>>> QFuture<T> QFuture::onCanceled(QObject *context, Function &&handler)

과부하가 걸린 함수입니다.

이 퓨처에 취소 handler 를 첨부하여 퓨처가 취소될 때 호출합니다. handler 은 인수를 받지 않는 콜러블입니다. context 객체의 스레드에서 호출됩니다. 특정 스레드에서 취소를 처리해야 하는 경우 유용할 수 있습니다.

체인이 완료되기 전에 context 가 파괴되면 미래가 취소됩니다. 자세한 내용은 then()를 참조하세요.

handler 에 대한 자세한 내용은 다른 오버로드 문서를 참조하세요.

이 함수는 Qt 6.1에 도입되었습니다.

then() 및 onFailed()도 참조하세요 .

[since 6.0] template <typename Function, typename = std::enable_if_t<!QtPrivate::ArgResolver<Function>::HasExtraArgs>> QFuture<T> QFuture::onFailed(Function &&handler)

예외를 처리하기 위해 이 퓨처에 실패 핸들러를 첨부합니다. 반환된 퓨처는 이 퓨처가 예외로 실패하지 않는 한 이 퓨처와 정확히 동작합니다(동일한 상태와 결과를 가짐).

handler 은 인수가 없거나 하나의 인수를 받아 catch 문과 유사하게 특정 오류 유형별로 필터링하는 콜러블입니다. 이 퓨처가 패키징한 유형의 값을 반환합니다. 실패 후 반환된 퓨처는 handler 에서 반환한 값을 패키징합니다.

핸들러는 예외가 발생한 경우에만 호출됩니다. 이 핸들러가 첨부된 후에 예외가 발생하면 예외의 결과로 퓨처가 완료된 것으로 보고하는 스레드에서 핸들러가 실행됩니다. 이 퓨처가 이미 실패한 후에 핸들러가 첨부되면 onFailed() 을 실행하는 스레드에서 즉시 호출됩니다. 따라서 처리기는 항상 어떤 스레드에서 실행될지 가정할 수 없습니다. 처리기가 어떤 스레드에서 호출되는지 제어하려면 컨텍스트 객체를 받는 오버로드를 사용하세요.

아래 예제는 장애 처리기를 첨부하는 방법을 보여줍니다:

QFuture<int> future = ...;
auto resultFuture = future.then([](int res) {
    ...
    throw Error();
    ...
}).onFailed([](const Error &e) {
    // Handle exceptions of type Error
    ...
    return -1;
}).onFailed([] {
    // Handle all other types of errors
    ...
    return -1;
});

auto result = resultFuture.result(); // result is -1

처리기가 여러 개 첨부되어 있는 경우 던져진 예외 유형과 일치하는 첫 번째 처리기가 호출됩니다. 예를 들어

QFuture<int> future = ...;
future.then([](int res) {
    ...
    throw std::runtime_error("message");
    ...
}).onFailed([](const std::exception &e) {
    // This handler will be invoked
}).onFailed([](const std::runtime_error &e) {
    // This handler won't be invoked, because of the handler above.
});

처리기 중 던져진 예외 유형과 일치하는 처리기가 없는 경우 예외는 나중에 발생한 예외로 전파됩니다:

QFuture<int> future = ...;
auto resultFuture = future.then([](int res) {
    ...
    throw Error("message");
    ...
}).onFailed([](const std::exception &e) {
    // Won't be invoked
}).onFailed([](const QException &e) {
    // Won't be invoked
});

try {
    auto result = resultFuture.result();
} catch(...) {
    // Handle the exception
}

이 함수는 Qt 6.0에 도입되었습니다.

then() 및 onCanceled()도 참조하십시오 .

[since 6.1] template <typename Function, typename = std::enable_if_t<!QtPrivate::ArgResolver<Function>::HasExtraArgs>> QFuture<T> QFuture::onFailed(QObject *context, Function &&handler)

오버로드된 함수입니다.

이 퓨처에 오류 처리기를 첨부하여 퓨처가 발생하거나 이미 발생시킨 예외를 처리합니다. 이 퓨처와 같은 유형의 QFuture 을 반환합니다. 처리기는 예외가 발생한 경우에만 context 객체의 스레드에서 호출됩니다. 특정 스레드에서 오류를 처리해야 하는 경우 유용할 수 있습니다. 예를 들어

// somewhere in the main thread
auto future = QtConcurrent::run([] {
    // This will run in a separate thread
    ...
    throw std::exception();
}).onFailed(this, [] {
   // Update UI elements
});

QtConcurrent::run 에 첨부된 오류 처리기는 UI 요소를 업데이트하므로 GUI가 아닌 스레드에서는 호출할 수 없습니다. 따라서 this 은 .onFailed() 에 컨텍스트로 제공되어 메인 스레드에서 호출될 수 있도록 합니다.

체인이 완료되기 전에 context 이 파괴되면 미래가 취소됩니다. 자세한 내용은 then()를 참조하세요.

handler 에 대한 자세한 내용은 다른 오버로드 문서를 참조하세요.

이 함수는 Qt 6.1에 도입되었습니다.

then() 및 onCanceled()도 참조하세요 .

int QFuture::progressMaximum() const

최대 progressValue()를 반환합니다.

progressValue() 및 progressMinimum()도 참조하세요 .

int QFuture::progressMinimum() const

최소 progressValue()를 반환합니다.

progressValue() 및 progressMaximum()도 참조하십시오 .

QString QFuture::progressText() const

비동기 계산에서 보고된 진행률의 (선택 사항) 텍스트 표현을 반환합니다.

모든 계산이 진행 상황을 텍스트로 표현하는 것은 아니므로 이 함수는 빈 문자열을 반환할 수 있다는 점에 유의하세요.

int QFuture::progressValue() const

progressMinimum()와 progressMaximum() 사이에 있는 현재 진행률 값을 반환합니다.

progressMinimum() 및 progressMaximum()도 참조하세요 .

template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> T QFuture::result() const

향후 첫 번째 결과를 반환합니다. 결과를 즉시 사용할 수 없는 경우 이 함수는 결과를 차단하고 사용할 수 있을 때까지 기다립니다. resultAt (0)을 호출할 때 편리하게 사용할 수 있는 방법입니다. result() 은 내부적으로 저장된 결과의 사본을 반환합니다. T 이 이동 전용 유형이거나 결과를 복사하지 않으려면 takeResult()을 대신 사용하세요.

resultAt(), results() 및 takeResult()도 참조하세요 .

template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> T QFuture::resultAt(int index) const

나중에 index 에서 결과를 반환합니다. 결과를 즉시 사용할 수 없는 경우 이 함수는 차단하고 결과를 사용할 수 있을 때까지 기다립니다.

result(), results(), takeResult() 및 resultCount()도 참조하세요 .

int QFuture::resultCount() const

이 미래에 사용할 수 있는 연속 결과의 수를 반환합니다. 결과 집합의 간격으로 인해 저장된 실제 결과 수는 이 값과 다를 수 있습니다. 0에서 resultCount()까지 결과를 반복하는 것이 항상 안전합니다.

result(), resultAt(), results() 및 takeResult()도 참조하세요 .

template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> QList<T> QFuture::results() const

미래의 모든 결과를 반환합니다. 결과를 즉시 사용할 수 없는 경우 이 함수는 결과를 차단하고 사용할 수 있게 될 때까지 기다립니다. results() 은 내부에 저장된 결과의 사본을 반환합니다. 이동 전용 유형 T 의 모든 결과 가져오기는 현재 지원되지 않습니다. 그러나 STL 스타일 이터레이터 또는 읽기 전용 Java 스타일 이터레이터를 사용하여 이동 전용 결과 목록을 계속 반복할 수 있습니다.

result(), resultAt(), takeResult(), resultCount() 및 isValid()도 참조하세요 .

void QFuture::resume()

future()로 표현되는 비동기 계산을 재개합니다. setSuspended (false)를 호출하기만 하면 되는 편리한 메서드입니다.

suspend()도 참조하세요 .

[since 6.0] void QFuture::setSuspended(bool suspend)

suspend 가 참이면 이 함수는 future()로 표현되는 비동기 계산을 일시 중단합니다. 계산이 이미 일시 중단된 경우 이 함수는 아무 작업도 수행하지 않습니다. QFutureWatcher 미래가 일시 중단되면 진행률 및 결과 준비 신호 전달을 즉시 중단하지 않습니다. 일시 중단하는 순간에도 여전히 진행 중이며 중지할 수 없는 계산이 있을 수 있습니다. 이러한 계산에 대한 신호는 계속 전달됩니다.

suspend 이 거짓이면 이 함수는 비동기 계산을 재개합니다. 이전에 계산이 일시 중단되지 않은 경우 이 함수는 아무 작업도 수행하지 않습니다.

모든 계산이 일시 중단될 수 있는 것은 아니라는 점에 유의하세요. 예를 들어, QtConcurrent::run()이 반환하는 QFuture 은 일시 중단할 수 없지만, QtConcurrent::mappedReduced()가 반환하는 QFuture 은 일시 중단할 수 있습니다.

이 함수는 Qt 6.0에 도입되었습니다.

isSuspended(), suspend(), resume() 및 toggleSuspended()도 참조하십시오 .

[since 6.0] void QFuture::suspend()

이 미래로 표현되는 비동기 계산을 일시 중단합니다. setSuspended (참)을 호출하기만 하면 되는 편리한 메서드입니다.

이 함수는 Qt 6.0에 도입되었습니다.

resume()도 참조하십시오 .

[since 6.0] template <typename U = T, typename = QtPrivate::EnableForNonVoid<U>> T QFuture::takeResult()

isValid()가 true 을 반환하는 경우에만 이 함수를 호출하고 그렇지 않으면 동작이 정의되지 않습니다. 이 함수는 결과가 하나만 예상되는 경우 QFuture 객체에서 첫 번째 결과를 가져옵니다(이동). 다른 결과가 있으면 첫 번째 결과를 가져온 후 버려집니다. 결과를 즉시 사용할 수 없는 경우 이 함수는 결과를 차단하고 사용할 수 있게 될 때까지 기다립니다. QFuture 은 가능한 경우 이동 시맨틱을 사용하려고 시도하고, 이동이 불가능한 유형인 경우 복사 구조로 돌아갑니다. 결과를 가져온 후 isValid()는 false 으로 평가됩니다.

이 기능은 Qt 6.0에 도입되었습니다.

result(), results(), resultAt() 및 isValid()도 참조하세요 .

[since 6.0] template <typename Function> QFuture<QFuture<T>::ResultType<Function>> QFuture::then(Function &&function)

이것은 오버로드된 함수입니다.

이 퓨처에 연속을 첨부하여 원하는 경우 Sync 정책을 사용하여 여러 비동기 계산을 체인으로 연결할 수 있습니다. function 이 퓨처에 결과가 있는 경우( QFuture<void>가 아닌) 이 퓨처가 패키징한 유형의 인수를 받는 호출 가능 함수가 됩니다. 그렇지 않으면 인수를 받지 않습니다. 이 메서드는 function 에서 반환한 유형의 값을 패키징하는 새로운 QFuture 을 반환합니다. 반환된 퓨처는 연결된 연속이 호출되거나 이 퓨처가 실패하거나 취소될 때까지 초기화되지 않은 상태에 있게 됩니다.

다음과 같이 여러 작업을 연결할 수 있습니다:

QFuture<int> future = ...;
future.then([](int res1){ ... }).then([](int res2){ ... })...

또는:

QFuture<void> future = ...;
future.then([](){ ... }).then([](){ ... })...

또는: 연속은 이전 미래를 나타내는 QFuture 인수를 값 대신 사용할 수도 있습니다. 예를 들어 QFuture 에 여러 개의 결과가 있고 사용자가 연속체 내에서 그 결과에 액세스하려는 경우에 유용할 수 있습니다. 또는 사용자가 여러 연속의 체인을 중단하지 않기 위해 연속 내부에서 이전 미래의 예외를 처리해야 하는 경우입니다. 예를 들어

QFuture<int> future = ...;
    future.then([](QFuture<int> f) {
        try {
            ...
            auto result = f.result();
            ...
        } catch (QException &e) {
            // handle the exception
        }
    }).then(...);

이전 퓨처에서 예외가 발생했는데 연속체 내부에서 처리되지 않으면 호출자가 예외를 처리할 수 있도록 예외가 연속체 퓨처로 전파됩니다:

QFuture<int> future = ...;
auto continuation = future.then([](int res1){ ... }).then([](int res2){ ... })...
...
// future throws an exception
try {
    auto result = continuation.result();
} catch (QException &e) {
    // handle the exception
}

이 경우 전체 연속 체인이 중단됩니다.

이 함수는 Qt 6.0에 도입되었습니다.

onFailed() 및 onCanceled()도 참조하세요 .

[since 6.1] template <typename Function> QFuture<QFuture<T>::ResultType<Function>> QFuture::then(QObject *context, Function &&function)

과부하가 걸린 기능입니다.

이 퓨처에 연속을 첨부하여 원하는 경우 여러 비동기 계산을 연결할 수 있습니다. 이 퓨처로 표시되는 비동기 계산이 완료되면 context 객체의 스레드에서 function 가 호출됩니다. 이는 특정 스레드에서 연속을 호출해야 하는 경우에 유용할 수 있습니다. 예를 들어

// somewhere in the main thread
auto future = QtConcurrent::run([] {
    // This will run in a separate thread
    ...
}).then(this, [] {
   // Update UI elements
});

QtConcurrent::run 에 연결된 컨티뉴어는 UI 요소를 업데이트하므로 비 GUI 스레드에서는 호출할 수 없습니다. 따라서 this 은 .then() 에 컨텍스트로 제공되어 메인 스레드에서 호출될 수 있도록 합니다.

다른 컨텍스트나 실행 정책이 지정되지 않는 한 다음 연속문도 동일한 컨텍스트에서 호출됩니다:

auto future = QtConcurrent::run([] {
    ...
}).then(this, [] {
   // Update UI elements
}).then([] {
    // This will also run in the main thread
});

이는 기본적으로 .then() 이 이전 스레드와 동일한 스레드에서 호출되기 때문입니다.

그러나 이 미래가 이미 완료된 후에 연속이 첨부되면 then() 을 실행하는 스레드에서 즉시 호출됩니다:

QObject *context = ...;
auto future = cachedResultsReady ? QtFuture::makeReadyValueFuture(result)
                                 : QtConcurrent::run([] { /* compute result */});
auto continuation = future.then(context, [] (Result result) {
    // Runs in the context's thread
}).then([] {
    // May or may not run in the context's thread
});

위의 예에서 cachedResultsReady 가 true 이고 준비된 퓨처가 반환되는 경우 첫 번째 .then() 가 두 번째 가 첨부되기 전에 완료될 수 있습니다. 이 경우 현재 스레드에서 해결됩니다. 따라서 확실하지 않은 경우 컨텍스트를 명시적으로 전달하세요.

체인이 완료되기 전에 context 이 파괴되면 미래가 취소됩니다. 이는 context 이 더 이상 유효하지 않을 때 취소 핸들러가 호출될 수 있음을 의미합니다. 이를 방지하려면 context 을 QPointer 으로 캡처하세요:

QObject *context = ...;
auto future = ...;
auto continuation = future.then(context, [context](Result result) {
                               // ...
                           }).onCanceled([context = QPointer(context)] {
                               if (!context)
                                   return;  // context was destroyed already
                               // handle cancellation
                           });

컨텍스트 객체가 소멸되면 취소가 즉시 발생합니다. 체인의 이전 퓨처는 취소되지 않고 완료될 때까지 계속 실행됩니다.

이 함수는 Qt 6.1에 도입되었습니다.

onFailed() 및 onCanceled()도 참조하세요 .

[since 6.0] template <typename Function> QFuture<QFuture<T>::ResultType<Function>> QFuture::then(QThreadPool *pool, Function &&function)

이것은 과부하 함수입니다.

이 퓨처에 연속을 첨부하여 원하는 경우 여러 비동기 연산을 연결할 수 있습니다. 이 퓨처가 나타내는 비동기 연산이 완료되면 pool 에 function 가 예약됩니다.

이 함수는 Qt 6.0에 도입되었습니다.

onFailed() 및 onCanceled()도 참조하십시오 .

[since 6.0] template <typename Function> QFuture<QFuture<T>::ResultType<Function>> QFuture::then(QtFuture::Launch policy, Function &&function)

이것은 과부하 함수입니다.

이 퓨처에 연속을 첨부하여 여러 비동기 연산을 연결할 수 있습니다. 이 퓨처로 표현되는 비동기 계산이 완료되면 주어진 시작 policy 에 따라 function 이 호출됩니다. 연속의 결과를 나타내는 새로운 QFuture 이 반환됩니다.

policy 에 따라 이 퓨처와 동일한 스레드, 새 스레드에서 연속이 호출되거나 이 퓨처의 실행 정책 및 스레드 풀을 상속합니다. 시작 정책이 지정되지 않은 경우(콜러블만 사용하는 오버로드 참조) Sync 정책이 사용됩니다.

다음 예제에서는 두 연속성이 모두 새 스레드에서 호출되지만 동일한 스레드에서 호출됩니다.

QFuture<int> future = ...;
future.then(QtFuture::Launch::Async, [](int res){ ... }).then([](int res2){ ... });

다음 예에서는 두 연속이 모두 동일한 스레드 풀을 사용하여 새 스레드에서 호출됩니다.

QFuture<int> future = ...;
future.then(QtFuture::Launch::Async, [](int res){ ... })
      .then(QtFuture::Launch::Inherit, [](int res2){ ... });

function 에 대한 자세한 내용은 다른 오버로드에 대한 문서를 참조하십시오.

이 함수는 Qt 6.0에 도입되었습니다.

onFailed() 및 onCanceled()도 참조하십시오 .

[since 6.0] void QFuture::toggleSuspended()

비동기 계산의 일시 중단 상태를 전환합니다. 즉, 계산이 현재 일시 중단 중이거나 일시 중단된 경우 이 함수를 호출하면 계산이 재개되고, 계산이 실행 중인 경우 일시 중단됩니다. setSuspended (!(isSuspending() || isSuspended()))를 호출하는 편리한 방법입니다.

이 함수는 Qt 6.0에 도입되었습니다.

setSuspended(), suspend() 및 resume()도 참조하십시오 .

[since 6.4] template <typename U> QFuture<U> QFuture::unwrap()

이 QFuture<T> 에서 내부 퓨처를 언래핑합니다. 여기서 T 은 QFuture<U> 타입의 퓨처, 즉 이 퓨처의 타입은 QFuture<QFuture<U>> 입니다:

QFuture<QFuture<int>> outerFuture = ...;
QFuture<int> unwrappedFuture = outerFuture.unwrap();

unwrappedFuture 는 outerFuture 안에 중첩된 내부 퓨처가 충족되는 즉시 동일한 결과 또는 예외와 함께 내부 퓨처를 완료된 것으로 보고하는 동일한 스레드에서 충족됩니다. 내부 퓨처가 취소되면 unwrappedFuture 도 취소됩니다.

이 기능은 여러 계산을 연결하고 그 중 하나가 결과 유형으로 QFuture 을 반환할 때 특히 유용합니다. 예를 들어 URL에서 여러 이미지를 다운로드하고, 이미지의 크기를 조정한 다음 QtConcurrent::mappedReduced()를 사용하여 하나의 이미지로 축소한다고 가정해 봅시다. 다음과 같이 작성할 수 있습니다:

auto downloadImages = [] (const QUrl &url) {
    QList<QImage> images;
    ...
    return images;
};

auto processImages = [](const QList<QImage> &images) {
   return QtConcurrent::mappedReduced(images, scale, reduceImages);
}

auto show = [](const QImage &image) { ... };

auto future = QtConcurrent::run(downloadImages, url)
               .then(processImages)
               .unwrap()
               .then(show);

여기서 QtConcurrent::mappedReduced() 는 QFuture<QImage> 을 반환하므로 .then(processImages) 는 QFuture<QFuture<QImage>> 를 반환합니다. show() 는 QImage 를 인수로 받기 때문에 .then(processImages) 의 결과를 직접 전달할 수 없습니다. .unwrap() 을 호출해야 하며, 이 호출은 내부 퓨처가 준비되면 결과를 가져와 다음 연속으로 전달합니다.

다중 중첩의 경우 .unwrap() 은 가장 안쪽 레벨로 내려갑니다:

QFuture<QFuture<QFuture<int>>>> outerFuture;
QFuture<int> unwrappedFuture = outerFuture.unwrap();

이 함수는 Qt 6.4에 도입되었습니다.

void QFuture::waitForFinished()

비동기 계산이 완료될 때까지( cancel()의 계산 포함), 즉 isFinished()가 true 을 반환할 때까지 기다립니다.

QFuture<T> &QFuture::operator=(const QFuture<T> &other)

이 미래에 other 을 할당하고 이 미래에 대한 참조를 반환합니다.