ufm::util::Future< R > 結構 樣版 參考文件

非同步操作結果介面，提供異步任務的監控和結果獲取功能。 更多...

#include <Future.h>

類別ufm::util::Future< R >的繼承圖:

公開方法(Public Methods)
virtual bool	get (R &result, int timeout) override
	獲取非同步操作的結果
virtual bool	setWait (void) override
	設定為等待狀態
virtual bool	waitDone (int timeout) override
	等待非同步操作完成
virtual void	clear (void) override
	清除當前狀態和結果
virtual FutureStatus	getStatus (void) override
	獲取當前 Future 的狀態
bool	waitDone (void)
	等待非同步操作完成，無超時限制
bool	get (R &result)
	獲取非同步操作結果，無超時限制
bool	isDone (void)
	檢查操作是否已完成（無論成功或失敗）
bool	isCompleted (void)
	檢查操作是否已成功完成
bool	isFailed (void)
	檢查操作是否已失敗
bool	isIdle (void)
	檢查操作是否處於閒置狀態
bool	isBusy (void)
	檢查操作是否處於忙碌（等待）狀態
公開方法(Public Methods) 繼承自 ufm::io::CompletionHandler< int >
virtual void	completed (int &result, void *attachment) override
	當非同步操作成功完成時呼叫
virtual void	failed (void *attachment) override
	當非同步操作失敗時呼叫

詳細描述

template<typename R = int>
struct ufm::util::Future< R >

非同步操作結果介面，提供異步任務的監控和結果獲取功能。

樣版參數

R	非同步操作結果的類型，預設為 int

Future 介面提供了完整的異步操作管理功能，包括狀態監控、 結果等待、結果獲取等核心操作。它支援超時控制， 並提供多種便利方法來檢查操作的不同狀態。

狀態轉換：

• IDLE: 初始閒置狀態
• WAIT: 正在執行異步操作
• DONE_COMPLETED: 操作成功完成
• DONE_FAILED: 操作執行失敗

主要功能：

• 異步任務結果的等待和獲取
• 支援超時控制的操作
• 提供詳細的狀態查詢功能
• 支援操作重置和重新使用

使用場景：

• 異步 I/O 操作的結果處理
• 長時間運行任務的監控
• 執行緒間的數據交換
• 非阻塞式操作的同步控制

使用範例：

// 實作一個簡單的異步計算 Future
class AsyncCalculator : public ufm::util::Future<int> {
private:
    int result;
    ufm::util::FutureStatus status;
    std::thread* workerThread;
    bool resultReady;
    
public:
    AsyncCalculator() : result(0), status(ufm::util::FutureStatus::IDLE), 
                       workerThread(nullptr), resultReady(false) {}
    
    ~AsyncCalculator() {
        if (workerThread && workerThread->joinable()) {
            workerThread->join();
            delete workerThread;
        }
    }
    
    // 啟動異步計算
    bool startCalculation(int a, int b) {
        if (status != ufm::util::FutureStatus::IDLE) {
            return false;  // 已經在執行中
        }
        
        status = ufm::util::FutureStatus::WAIT;
        resultReady = false;
        
        workerThread = new std::thread([this, a, b]() {
            // 模擬複雜計算
            std::this_thread::sleep_for(std::chrono::seconds(2));
            
            // 隨機決定成功或失敗
            if (rand() % 10 < 8) {  // 80% 成功率
                result = a * b + (a + b);  // 某種複雜計算
                status = ufm::util::FutureStatus::DONE_COMPLETED;
                resultReady = true;
                completed(result);  // 通知完成
            } else {
                status = ufm::util::FutureStatus::DONE_FAILED;
                failed();  // 通知失敗
            }
        });
        
        return true;
    }
    
    // 實作 Future 介面
    bool get(int& outResult, int timeout) override {
        if (!waitDone(timeout)) {
            return false;
        }
        
        if (status == ufm::util::FutureStatus::DONE_COMPLETED) {
            outResult = result;
            return true;
        }
        
        return false;
    }
    
    bool setWait(void) override {
        if (status == ufm::util::FutureStatus::IDLE) {
            status = ufm::util::FutureStatus::WAIT;
            return true;
        }
        return false;
    }
    
    bool waitDone(int timeout) override {
        if (isDone()) {
            return true;
        }
        
        if (!workerThread) {
            return false;
        }
        
        if (timeout == 0) {
            // 無限等待
            workerThread->join();
            return isDone();
        } else {
            // 超時等待
            auto start = std::chrono::steady_clock::now();
            while (!isDone()) {
                std::this_thread::sleep_for(std::chrono::milliseconds(10));
                auto elapsed = std::chrono::steady_clock::now() - start;
                if (std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count() >= timeout) {
                    return false;  // 超時
                }
            }
            return true;
        }
    }
    
    void clear(void) override {
        if (workerThread && workerThread->joinable()) {
            workerThread->join();
            delete workerThread;
            workerThread = nullptr;
        }
        
        status = ufm::util::FutureStatus::IDLE;
        result = 0;
        resultReady = false;
    }
    
    ufm::util::FutureStatus getStatus(void) override {
        return status;
    }
    
    // 實作 CompletionHandler 介面
    void completed(int result) override {
        std::cout << "計算完成，結果: " << result << std::endl;
    }
    
    void failed(void) override {
        std::cout << "計算失敗" << std::endl;
    }
};
 
// 使用異步計算器
AsyncCalculator calculator;
 
// 啟動異步計算
std::cout << "開始異步計算..." << std::endl;
if (calculator.startCalculation(15, 25)) {
    // 檢查初始狀態
    std::cout << "是否忙碌: " << calculator.isBusy() << std::endl;  // true
    std::cout << "是否完成: " << calculator.isDone() << std::endl;  // false
    
    // 等待完成（5 秒超時）
    if (calculator.waitDone(5000)) {
        std::cout << "操作完成" << std::endl;
        
        // 檢查最終狀態
        if (calculator.isCompleted()) {
            int result;
            if (calculator.get(result)) {
                std::cout << "計算結果: " << result << std::endl;
            }
        } else if (calculator.isFailed()) {
            std::cout << "計算失敗" << std::endl;
        }
    } else {
        std::cout << "等待超時" << std::endl;
    }
}
 
// 異步文件讀取範例
class AsyncFileReader : public ufm::util::Future<std::string> {
private:
    std::string content;
    ufm::util::FutureStatus status;
    std::string filename;
    
public:
    AsyncFileReader() : status(ufm::util::FutureStatus::IDLE) {}
    
    bool readFile(const std::string& file) {
        if (!isIdle()) {
            return false;
        }
        
        filename = file;
        setWait();
        
        std::thread([this]() {
            // 模擬文件讀取
            std::this_thread::sleep_for(std::chrono::milliseconds(500));
            
            // 模擬讀取成功/失敗
            if (filename != "nonexistent.txt") {
                content = "File content from " + filename;
                status = ufm::util::FutureStatus::DONE_COMPLETED;
                completed(content);
            } else {
                status = ufm::util::FutureStatus::DONE_FAILED;
                failed();
            }
        }).detach();
        
        return true;
    }
    
    // ... 其他 Future 方法實作 ...
};
 
// 使用異步文件讀取器
AsyncFileReader fileReader;
 
if (fileReader.readFile("config.txt")) {
    // 無超時等待
    if (fileReader.waitDone()) {
        if (fileReader.isCompleted()) {
            std::string content;
            if (fileReader.get(content)) {
                std::cout << "讀取內容: " << content << std::endl;
            }
        }
    }
}
 
// 批次 Future 管理範例
class FutureManager {
private:
    std::vector<std::unique_ptr<ufm::util::Future<int>>> futures;
    
public:
    void addFuture(std::unique_ptr<ufm::util::Future<int>> future) {
        futures.push_back(std::move(future));
    }
    
    void waitAll(int timeout) {
        std::cout << "等待所有操作完成..." << std::endl;
        
        for (auto& future : futures) {
            if (future->waitDone(timeout)) {
                if (future->isCompleted()) {
                    int result;
                    if (future->get(result)) {
                        std::cout << "結果: " << result << std::endl;
                    }
                } else if (future->isFailed()) {
                    std::cout << "操作失敗" << std::endl;
                }
            } else {
                std::cout << "操作超時" << std::endl;
            }
        }
    }
    
    void clearAll() {
        for (auto& future : futures) {
            future->clear();
        }
        futures.clear();
    }
};

參閱

ufm::io::CompletionHandler

ufm::util::FutureStatus

自

1.0.0

函式成員說明文件

clear()

template<typename R = int>

virtual void ufm::util::Future< R >::clear ( void )

pure virtual

清除當前狀態和結果

實作於 ufm::util::PFuture.

get() [1/2]

template<typename R = int>

bool ufm::util::Future< R >::get ( R & result )

inline

獲取非同步操作結果，無超時限制

參數

result

[out] 用於存儲結果的引用

傳回值

true 成功獲取結果

false 獲取失敗

get() [2/2]

template<typename R = int>

virtual bool ufm::util::Future< R >::get ( R & result, int timeout )

pure virtual

獲取非同步操作的結果

參數

result	用於儲存結果的參考
timeout	等待超時時間（毫秒），0 表示無限等待

傳回值

true 成功獲取結果，false 獲取失敗或超時

實作於 ufm::util::PFuture.

getStatus()

template<typename R = int>

virtual FutureStatus ufm::util::Future< R >::getStatus ( void )

pure virtual

獲取當前 Future 的狀態

傳回值

FutureStatus 目前狀態的列舉值

實作於 ufm::util::PFuture.

isBusy()

template<typename R = int>

bool ufm::util::Future< R >::isBusy ( void )

inline

檢查操作是否處於忙碌（等待）狀態

傳回值

true 操作處於忙碌狀態

false 操作處於其他狀態

isCompleted()

template<typename R = int>

bool ufm::util::Future< R >::isCompleted ( void )

inline

檢查操作是否已成功完成

傳回值

true 操作成功完成

false 操作未完成或失敗

isDone()

template<typename R = int>

bool ufm::util::Future< R >::isDone ( void )

inline

檢查操作是否已完成（無論成功或失敗）

傳回值

true 操作已完成（成功或失敗）

false 操作尚未完成

isFailed()

template<typename R = int>

bool ufm::util::Future< R >::isFailed ( void )

inline

檢查操作是否已失敗

傳回值

true 操作已失敗

false 操作未完成或已成功

isIdle()

template<typename R = int>

bool ufm::util::Future< R >::isIdle ( void )

inline

檢查操作是否處於閒置狀態

傳回值

true 操作處於閒置狀態

false 操作處於其他狀態

setWait()

template<typename R = int>

virtual bool ufm::util::Future< R >::setWait ( void )

pure virtual

設定為等待狀態

傳回值

true 成功設定為等待狀態，false 設定失敗

實作於 ufm::util::PFuture.

waitDone() [1/2]

template<typename R = int>

virtual bool ufm::util::Future< R >::waitDone ( int timeout )

pure virtual

等待非同步操作完成

參數

timeout

等待超時時間（毫秒），0 表示無限等待

傳回值

true 操作已完成，false 等待超時或操作未完成

實作於 ufm::util::PFuture.

waitDone() [2/2]

template<typename R = int>

bool ufm::util::Future< R >::waitDone ( void )

inline

等待非同步操作完成，無超時限制

傳回值

true 操作已完成

false 操作未完成或等待失敗

---

此結構(structure) 文件是由下列檔案中產生:

• Future.h