C++非同期プログラミングとコンカレンシーの違いを徹底解説

#include <iostream>
#include <future>

// 非同期タスクとして実行する関数
int compute(int x) {
    return x * x;
}

int main() {
    // 非同期タスクを開始
    std::future<int> result = std::async(std::launch::async, compute, 10);

    // 他の作業を行う

    // 結果を取得
    int value = result.get();
    std::cout << "Result: " << value << std::endl;

    return 0;
}

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

// スレッドから呼び出される関数
void compute(std::promise<int>& prom, int x) {
    int result = x * x;
    prom.set_value(result);
}

int main() {
    // promiseとfutureの作成
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();

    // 非同期タスクの開始
    std::thread t(compute, std::ref(prom), 10);
    t.detach(); // スレッドをデタッチ

    // 結果を取得
    int value = fut.get();
    std::cout << "Result: " << value << std::endl;

    return 0;
}

#include <iostream>
#include <thread>

// スレッドから実行される関数
void printMessage(const std::string& message) {
    std::cout << message << std::endl;
}

int main() {
    // スレッドの作成と開始
    std::thread t(printMessage, "Hello from thread!");

    // メインスレッドで他の作業を行う

    // スレッドの完了を待つ
    t.join();

    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx; // ミューテックスの宣言

void printMessage(const std::string& message) {
    std::lock_guard<std::mutex> lock(mtx); // ミューテックスのロック
    std::cout << message << std::endl;
}

int main() {
    std::thread t1(printMessage, "Hello from thread 1!");
    std::thread t2(printMessage, "Hello from thread 2!");

    // スレッドの完了を待つ
    t1.join();
    t2.join();

    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void printMessage() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; }); // 条件が満たされるまで待機
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    std::thread t(printMessage);

    // メインスレッドで準備作業を行う
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_one(); // スレッドに通知

    // スレッドの完了を待つ
    t.join();

    return 0;
}

#include <iostream>
#include <future>
#include <vector>
#include <string>

// 模擬的なデータ取得関数
std::string fetchDataFromServer(const std::string& server) {
    // 実際のデータ取得処理（ここでは単なる待機）
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return "Data from " + server;
}

int main() {
    // サーバーリスト
    std::vector<std::string> servers = {"Server1", "Server2", "Server3"};

    // 非同期タスクのベクター
    std::vector<std::future<std::string>> futures;

    // 各サーバーからデータを非同期に取得
    for (const auto& server : servers) {
        futures.push_back(std::async(std::launch::async, fetchDataFromServer, server));
    }

    // 結果の取得と表示
    for (auto& future : futures) {
        std::cout << future.get() << std::endl;
    }

    return 0;
}

#include <iostream>
#include <thread>
#include <vector>
#include <numeric> // for std::accumulate

// 各スレッドで実行される関数
void computeSum(const std::vector<int>& numbers, int start, int end, int& result) {
    result = std::accumulate(numbers.begin() + start, numbers.begin() + end, 0);
}

int main() {
    // 計算対象のデータ
    std::vector<int> numbers(1000000, 1); // 100万個の1

    // 結果を格納する変数
    int result1 = 0, result2 = 0, result3 = 0, result4 = 0;

    // スレッドの作成と開始
    std::thread t1(computeSum, std::cref(numbers), 0, 250000, std::ref(result1));
    std::thread t2(computeSum, std::cref(numbers), 250000, 500000, std::ref(result2));
    std::thread t3(computeSum, std::cref(numbers), 500000, 750000, std::ref(result3));
    std::thread t4(computeSum, std::cref(numbers), 750000, 1000000, std::ref(result4));

    // スレッドの完了を待つ
    t1.join();
    t2.join();
    t3.join();
    t4.join();

    // 結果の集約
    int totalSum = result1 + result2 + result3 + result4;
    std::cout << "Total Sum: " << totalSum << std::endl;

    return 0;
}

#include <iostream>
#include <fstream>
#include <vector>
#include <future>

// ファイルからデータを読み込む関数
std::string readFile(const std::string& filename) {
    std::ifstream file(filename);
    std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
    return content;
}

int main() {
    // ファイル名のリスト
    std::vector<std::string> filenames = {"file1.txt", "file2.txt", "file3.txt"};

    // 非同期タスクのベクター
    std::vector<std::future<std::string>> futures;

    // 各ファイルを非同期に読み込む
    for (const auto& filename : filenames) {
        futures.push_back(std::async(std::launch::async, readFile, filename));
    }

    // 結果の取得と表示
    for (auto& future : futures) {
        std::cout << future.get() << std::endl;
    }

    return 0;
}

#include <iostream>
#include <vector>
#include <thread>
#include <algorithm>

// 配列の一部をソートする関数
void partialSort(std::vector<int>& arr, int start, int end) {
    std::sort(arr.begin() + start, arr.begin() + end);
}

// マージ関数
std::vector<int> merge(const std::vector<int>& left, const std::vector<int>& right) {
    std::vector<int> result;
    auto it1 = left.begin();
    auto it2 = right.begin();

    while (it1 != left.end() && it2 != right.end()) {
        if (*it1 < *it2) {
            result.push_back(*it1++);
        } else {
            result.push_back(*it2++);
        }
    }
    result.insert(result.end(), it1, left.end());
    result.insert(result.end(), it2, right.end());

    return result;
}

int main() {
    std::vector<int> arr = {9, 3, 1, 4, 6, 2, 8, 7, 5};

    // スレッド数
    int numThreads = 2;
    int partSize = arr.size() / numThreads;

    std::vector<std::thread> threads;

    // スレッドの作成と開始
    for (int i = 0; i < numThreads; ++i) {
        int start = i * partSize;
        int end = (i == numThreads - 1) ? arr.size() : start + partSize;
        threads.emplace_back(partialSort, std::ref(arr), start, end);
    }

    // スレッドの完了を待つ
    for (auto& thread : threads) {
        thread.join();
    }

    // 結果のマージ
    std::vector<int> sortedArr = merge(
        std::vector<int>(arr.begin(), arr.begin() + partSize),
        std::vector<int>(arr.begin() + partSize, arr.end())
    );

    // 結果の表示
    for (const auto& num : sortedArr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}