git clone https://github.com/sogou/workflow.git
如果克隆失敗，可以下載zip壓縮包然后解壓代碼文件或者是下載release文件

sudo apt install -y cmake libssl-dev

mkdir build
cd build
cmake ..（如果報(bào)錯(cuò) sudo apt install libssl1.1 or libssl-dev）

make

sudo make install
sudo ldconfig

g++ tutorial-00-helloworld.cc -lworkflow

class WFTaskFactory
{
public:
	static WFHttpTask *create_http_task(const std::string& url,//要連接的服務(wù)端的url
										int redirect_max,//最大重定向次數(shù)
										int retry_max,//連接失敗的時(shí)候的重試次數(shù)
										http_callback_t callback);//回調(diào)函數(shù)
};

using WFHttpTask = WFNetworkTask<protocol::HttpRequest,
								 protocol::HttpResponse>;
REQ *get_req();//獲取指向請(qǐng)求的指針
void set_callback(std::function<void (WFNetworkTask<REQ, RESP> *)> cb);//設(shè)置回調(diào)函數(shù)

class HttpMessage : public ProtocolMessage
{
public:
	const char *get_http_version() const;
	
	bool set_http_version(const char *version);
	
	bool add_header_pair(const char *name, const char *value);
	
	bool set_header_pair(const char *name, const char *value);
	
	bool get_parsed_body(const void **body, size_t *size) const;
	
	/* Output body is for sending. Want to transfer a message received, maybe:
	* msg->get_parsed_body(&body, &size);
	* msg->append_output_body_nocopy(body, size); */
	bool append_output_body(const void *buf, size_t size);
	
	bool append_output_body_nocopy(const void *buf, size_t size);
	
	void clear_output_body();
	
	size_t get_output_body_size() const;
	//上述接口都有std::string版本
	//...
};
class HttpRequest : public HttpMessage
{
public:
	const char *get_method() const;
	
	const char *get_request_uri() const;
	
	bool set_method(const char *method);
	
	bool set_request_uri(const char *uri);
  	//上述接口都有std::string版本
	//...
};

class HttpResponse : public HttpMessage
{
public:
	const char *get_status_code() const;
	
	const char *get_reason_phrase() const;
	
	bool set_status_code(const char *code);
	
	bool set_reason_phrase(const char *phrase);
	
	/* Tell the parser, it is a HEAD response. */
	void parse_zero_body();
	//上述接口都有std::string版本
	//...
};

/* start(), dismiss() are for client tasks only. */
void start()
{
	assert(!series_of(this));
	Workflow::start_series_work(this, nullptr);
}

template<class REQ, class RESP>
class WFNetworkTask : public CommRequest
{
public:
	// ...
	int get_state() const { return this->state; }
	int get_error() const { return this->error; }
	// ...
}

#include "unixHeader.h"
#include <workflow/HttpMessage.h>
#include <workflow/HttpUtil.h>
#include <workflow/WFTaskFactory.h>
#include <workflow/WFFacilities.h>
static WFFacilities::WaitGroup wait_group(1);
void sig_handler(int signo){
	wait_group.done();
}
void callback(WFHttpTask *httpTask){
	int state = httpTask->get_state();
	int error = httpTask->get_error();
	switch (state){
		case WFT_STATE_SYS_ERROR:
			fprintf(stderr, "system error: %s\n", strerror(error));
			break;
		case WFT_STATE_DNS_ERROR:
			fprintf(stderr, "DNS error: %s\n", gai_strerror(error));
			break;
		case WFT_STATE_SUCCESS:
			break;
	}
	if (state != WFT_STATE_SUCCESS){
		fprintf(stderr, "Failed. Press Ctrl-C to exit.\n");
		return;
	}
	fprintf(stderr, "success\n");
	wait_group.done();
}

int main(int argc, char *argv[]){
	std::string url = "http://";
	url.append(argv[1]);
	signal(SIGINT, sig_handler);
	auto httpTask = WFTaskFactory::create_http_task(url, 0, 0, callback);
	protocol::HttpRequest *req = httpTask->get_req();
	req->add_header_pair("Accept", "*/*");
	req->add_header_pair("User-Agent", "TestAgent");
	req->add_header_pair("Connection", "close");
	httpTask->start();
	wait_group.wait();
	return 0;
}

template<class REQ, class RESP>
class WFNetworkTask : public CommRequest
{
	// ...
public:
	REQ *get_req() { return &this->req; }
	RESP *get_resp() { return &this->resp; }
 	// ...
}
//其中http任務(wù)的實(shí)例化版本
//REQ -> protocol::HttpRequest
//RESP -> protocol::HttpResponse

void callback(WFHttpTask *task){
	protocol::HttpRequest *req = task->get_req();
	protocol::HttpResponse *resp = task->get_resp();
	// ...
	fprintf(stderr, "%s %s %s\r\n", req->get_method(),
	req->get_http_version(),
	req->get_request_uri());
	// ...
	fprintf(stderr, "%s %s %s\r\n", resp->get_http_version(),
	resp->get_status_code(),
	resp->get_reason_phrase());
	// ...
}

class HttpHeaderCursor{
//...
public:
	bool next(std::string& name, std::string& value);
	bool find(const std::string& name, std::string& value);
	void rewind();
	//...
};

void callback(WFHttpTask *task){
	protocol::HttpRequest *req = task->get_req();
	protocol::HttpResponse *resp = task->get_resp();
	//...
	std::string name;
	std::string value;
	// ....
	// 遍歷請(qǐng)求報(bào)文的首部字段
	protocol::HttpHeaderCursor req_cursor(req);
	while (req_cursor.next(name, value)){
		fprintf(stderr, "%s: %s\r\n", name.c_str(), value.c_str());
 	}
	fprintf(stderr, "\r\n");
 	// 遍歷響應(yīng)報(bào)文的首部字段
	protocol::HttpHeaderCursor resp_cursor(resp);
	while (resp_cursor.next(name, value)){
		fprintf(stderr, "%s: %s\r\n", name.c_str(), value.c_str());
 	}
	fprintf(stderr, "\r\n");
 	//...
}

//...
	// 首先需要定義一個(gè)指針變量，該指針的基類型是const void
	const void *body;
	size_t body_len;
	// 將指針變量的地址傳入get_parsed_body方法中，指針變量將要指向報(bào)文體
	resp->get_parsed_body(&body, &body_len);
	fwrite(body, 1, body_len, stdout);
	fflush(stdout);
	//...

#include "workflow/WFFacilities.h"

using namespace wf;

int main()
{
    // 創(chuàng)建一個(gè)CPU任務(wù)工廠
    WFFacilities::WaitGroup waitGroup(1);
    WFCPUTask *task = WFTaskFactory::create_cpu_task([](WFCPUTask *task) {
        // 這里進(jìn)行具體的CPU計(jì)算操作，比如快速排序
        int data[] = {5, 3, 8, 1, 2};
        // 簡單的快速排序?qū)崿F(xiàn)示例
        int n = sizeof(data) / sizeof(data[0]);
        for (int i = 0; i < n - 1; ++i) {
            for (int j = 0; j < n - i - 1; ++j) {
                if (data[j] > data[j + 1]) {
                    int temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;
                }
            }
        }
        // 可以將結(jié)果存儲(chǔ)在task的自定義數(shù)據(jù)區(qū)等操作
    }, [&waitGroup](WFCPUTask *task) {
        waitGroup.done();
    });
    task->start();
    waitGroup.wait();
    return 0;
}

#include "workflow/WFFacilities.h"
#include <cuda_runtime.h>

using namespace wf;

// CUDA核函數(shù)，用于矩陣乘法
__global__ void matrixMultiplication(float *a, float *b, float *c, int size)
{
    int row = blockIdx.y * blockDim.y + threadIdx.y;
    int col = blockIdx.x * blockDim.x + threadIdx.x;
    if (row < size && col < size) {
        float sum = 0;
        for (int i = 0; i < size; ++i) {
            sum += a[row * size + i] * b[i * size + col];
        }
        c[row * size + col] = sum;
    }
}

int main()
{
    WFFacilities::WaitGroup waitGroup(1);
    WFCPUTask *prepareTask = WFTaskFactory::create_cpu_task([](WFCPUTask *task) {
        // 初始化矩陣數(shù)據(jù)等準(zhǔn)備工作
        int size = 1024;
        float *hostA = new float[size * size];
        float *hostB = new float[size * size];
        float *hostC = new float[size * size];
        for (int i = 0; i < size * size; ++i) {
            hostA[i] = 1.0f;
            hostB[i] = 2.0f;
        }
        float *deviceA, *deviceB, *deviceC;
        cudaMalloc((void**)&deviceA, size * size * sizeof(float));
        cudaMalloc((void**)&deviceB, size * size * sizeof(float));
        cudaMalloc((void**)&deviceC, size * size * sizeof(float));
        cudaMemcpy(deviceA, hostA, size * size * sizeof(float), cudaMemcpyHostToDevice);
        cudaMemcpy(deviceB, hostB, size * size * sizeof(float), cudaMemcpyHostToDevice);
        // 將設(shè)備指針和相關(guān)參數(shù)傳遞給GPU任務(wù)
        task->user_data = new GPUData{deviceA, deviceB, deviceC, size};
    }, [&waitGroup](WFCPUTask *task) {
        // 啟動(dòng)GPU任務(wù)
        GPUData *data = (GPUData*)task->user_data;
        WFGPUTask *gpuTask = WFTaskFactory::create_gpu_task(matrixMultiplication, data->deviceA, data->deviceB, data->deviceC, data->size, [&waitGroup](WFGPUTask *task) {
            // GPU任務(wù)完成后，將結(jié)果從設(shè)備拷貝回主機(jī)
            GPUData *data = (GPUData*)task->user_data;
            float *hostC = new float[data->size * data->size];
            cudaMemcpy(hostC, data->deviceC, data->size * data->size * sizeof(float), cudaMemcpyDeviceToHost);
            // 釋放設(shè)備內(nèi)存
            cudaFree(data->deviceA);
            cudaFree(data->deviceB);
            cudaFree(data->deviceC);
            delete data;
            waitGroup.done();
        });
        gpuTask->start();
    });
    prepareTask->start();
    waitGroup.wait();
    return 0;
}

#include "workflow/WFHttpServer.h"
#include "workflow/WFHttpUtil.h"

using namespace protocol;

void onHttpResponse(WFHttpTask *task)
{
    HttpResponse *resp = task->get_resp();
    if (resp->get_status_code() == 200) {
        const void *body;
        size_t len;
        resp->get_parsed_body(&body, &len);
        std::string content((const char*)body, len);
        // 在這里可以對(duì)獲取到的網(wǎng)頁內(nèi)容進(jìn)行處理
        std::cout << "網(wǎng)頁內(nèi)容: " << content << std::endl;
    } else {
        std::cout << "請(qǐng)求失敗，狀態(tài)碼: " << resp->get_status_code() << std::endl;
    }
}

int main()
{
    WFHttpTask *task = WFTaskFactory::create_http_task("http://www.example.com", 1, 0, onHttpResponse);
    task->start();
    // 可以使用WaitGroup等方式等待任務(wù)完成
    return 0;
}

#include "workflow/WFFacilities.h"
#include <iostream>
#include <fstream>

using namespace wf;

void readFileCallback(WFCPUTask *task)
{
    std::ifstream file("example.txt", std::ios::binary);
    if (file.is_open()) {
        std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
        // 在這里可以對(duì)讀取到的文件內(nèi)容進(jìn)行處理
        std::cout << "文件內(nèi)容: " << content << std::endl;
        file.close();
    } else {
        std::cout << "無法打開文件" << std::endl;
    }
}

int main()
{
    WFFacilities::WaitGroup waitGroup(1);
    WFCPUTask *task = WFTaskFactory::create_cpu_task(readFileCallback, [&waitGroup](WFCPUTask *task) {
        waitGroup.done();
    });
    task->start();
    waitGroup.wait();
    return 0;
}

#include "workflow/WFFacilities.h"
#include <iostream>

using namespace wf;

void timerCallback(WFCPUTask *task)
{
    static int count = 0;
    std::cout << "定時(shí)器觸發(fā)，第 " << ++count << " 次" << std::endl;
    // 可以在這里進(jìn)行具體的操作
}

int main()
{
    WFFacilities::WaitGroup waitGroup(1);
    WFCPUTask *task = WFTaskFactory::create_cpu_task(timerCallback, [&waitGroup](WFCPUTask *task) {
        // 重新設(shè)置定時(shí)器，實(shí)現(xiàn)每隔1秒觸發(fā)
        WFCTask *timerTask = WFTaskFactory::create_timer_task(1000, true, [&waitGroup](WFCTask *task) {
            WFCPUTask *newTask = WFTaskFactory::create_cpu_task(timerCallback, [&waitGroup](WFCPUTask *task) {
                // 再次設(shè)置定時(shí)器，循環(huán)執(zhí)行
                WFCTask *newTimerTask = WFTaskFactory::create_timer_task(1000, true, [&waitGroup](WFCTask *task) {
                    // 可以根據(jù)需要停止定時(shí)器等操作
                    waitGroup.done();
                });
                newTimerTask->start();
            });
            newTask->start();
        });
        timerTask->start();
    });
    task->start();
    waitGroup.wait();
    return 0;
}

#include "workflow/WFFacilities.h"
#include <iostream>

using namespace wf;

void eventCallback(WFCPUTask *task)
{
    static WFCounter counter(0);
    counter.increment();
    std::cout << "事件發(fā)生次數(shù): " << counter.get() << std::endl;
}

int main()
{
    WFFacilities::WaitGroup waitGroup(1);
    WFCPUTask *task = WFTaskFactory::create_cpu_task(eventCallback, [&waitGroup](WFCPUTask *task) {
        // 模擬多次事件發(fā)生
        for (int i = 0; i < 5; ++i) {
            WFCPUTask *newTask = WFTaskFactory::create_cpu_task(eventCallback, [&waitGroup](WFCPUTask *task) {
                waitGroup.done();
            });
            newTask->start();
        }
    });
    task->start();
    waitGroup.wait();
    return 0;
}

#include "workflow/WFFacilities.h"
#include <iostream>
#include <mysql/mysql.h>

using namespace wf;

// 假設(shè)這是檢查用戶名是否存在的函數(shù)
bool checkUsernameExists(const std::string& username)
{
    // 這里省略具體的數(shù)據(jù)庫連接和查詢代碼
    // 簡單返回一個(gè)示例結(jié)果
    return false;
}

// 假設(shè)這是插入用戶信息到數(shù)據(jù)庫的函數(shù)
bool insertUserInfo(const std::string& username, const std::string& password)
{
    // 這里省略具體的數(shù)據(jù)庫連接和插入代碼
    // 簡單返回一個(gè)示例結(jié)果
    return true;
}

void firstSubtask(WFSubTask *subTask)
{
    std::string username = "testUser";
    if (checkUsernameExists(username)) {
        std::cout << "用戶名已存在" << std::endl;
        // 可以在這里設(shè)置錯(cuò)誤狀態(tài)等
    } else {
        // 將用戶名傳遞給下一個(gè)子任務(wù)
        subTask->user_data = new std::string(username);
        // 啟動(dòng)下一個(gè)子任務(wù)
        WFSubTask *nextSubTask = WFTaskFactory::create_subtask([](WFSubTask *subTask) {
            std::string *username = (std::string*)subTask->user_data;
            std::string password = "testPassword";
            if (insertUserInfo(*username, password)) {
                std::cout << "用戶注冊成功" << std::endl;
            } else {
                std::cout << "用戶注冊失敗" << std::endl;
            }
            delete username;
        }, nullptr);
        nextSubTask->start();
    }
}

int main()
{
    WFFacilities::WaitGroup waitGroup(1);
    WFSubTask *subTask = WFTaskFactory::create_subtask(firstSubtask, [&waitGroup](WFSubTask *subTask) {
        waitGroup.done();
    });
    subTask->start();
    waitGroup.wait();
    return 0;
}

#include "workflow/WFFacilities.h"
#include "workflow/WFHttpServer.h"
#include "workflow/WFHttpUtil.h"
#include <iostream>
#include <vector>

using namespace protocol;
using namespace wf;

void analyzeContent(const std::string& content)
{
    // 這里進(jìn)行內(nèi)容分析的具體邏輯，比如統(tǒng)計(jì)字?jǐn)?shù)等
    std::cout << "內(nèi)容字?jǐn)?shù): " << content.size() << std::endl;
}

void httpCallback(WFHttpTask *task)
{
    HttpResponse *resp = task->get_resp();
    if (resp->get_status_code() == 200) {
        const void *body;
        size_t len;
        resp->get_parsed_body(&body, &len);
        std::string content((const char*)body, len);
        analyzeContent(content);
    } else {
        std::cout << "請(qǐng)求失敗，狀態(tài)碼: " << resp->get_status_code() << std::endl;
    }
}

int main()
{
    WFFacilities::WaitGroup waitGroup(3);
    std::vector<WFHttpTask*> tasks;
    std::vector<std::string> urls = {"http://www.example1.com", "http://www.example2.com", "http://www.example3.com"};
    for (const auto& url : urls) {
        WFHttpTask *task = WFTaskFactory::create_http_task(url, 1, 0, [&waitGroup](WFHttpTask *task) {
            waitGroup.done();
        });
        tasks.push_back(task);
        task->start();
    }
    waitGroup.wait();
    for (auto task : tasks) {
        delete task;
    }
    return 0;
}

#include <iostream>
#include <fstream>
#include <functional>

void readFileAsync(const std::string& filename, std::function<void(const std::string&)> callback)
{
    std::ifstream file(filename);
    if (file.is_open())
    {
        std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
        file.close();
        callback(content);
    }
    else
    {
        callback("");
    }
}

void processFileContent(const std::string& content)
{
    // 這里進(jìn)行文件內(nèi)容的處理邏輯
    std::cout << "處理后的內(nèi)容: " << content << std::endl;
}

int main()
{
    readFileAsync("example.txt", [](const std::string& content) {
        processFileContent(content);
    });
    return 0;
}

#include "workflow/WFFacilities.h"
#include <iostream>
#include <fstream>

using namespace wf;

void readFileAndProcess()
{
    WFFacilities::WaitGroup waitGroup(1);
    WFCPUTask *task = WFTaskFactory::create_cpu_task([](WFCPUTask *task) {
        std::ifstream file("example.txt");
        if (file.is_open())
        {
            std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
            file.close();
            // 這里可以直接進(jìn)行文件內(nèi)容的處理
            std::cout << "處理后的內(nèi)容: " << content << std::endl;
        }
        else
        {
            std::cout << "無法打開文件" << std::endl;
        }
    }, [&waitGroup](WFCPUTask *task) {
        waitGroup.done();
    });
    task->start();
    waitGroup.wait();
}

int main()
{
    readFileAndProcess();
    return 0;
}