C++非同期プログラミングとメモリリーク防止の完全ガイド

#include <iostream>
#include <thread>

void do_work() {
    std::cout << "Work in another thread\n";
}

int main() {
    std::thread worker(do_work);
    worker.join(); // スレッドの終了を待つ
    return 0;
}

#include <iostream>
#include <future>

int compute() {
    return 42;
}

int main() {
    std::future<int> result = std::async(std::launch::async, compute);
    std::cout << "Result: " << result.get() << "\n"; // 結果を取得
    return 0;
}

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

void producer(std::promise<int> prom) {
    prom.set_value(42);
}

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();
    std::thread t(producer, std::move(prom));
    std::cout << "Value: " << fut.get() << "\n"; // 値を取得
    t.join();
    return 0;
}

#include <iostream>
#include <thread>
#include <fstream>
#include <string>

void readFile(const std::string& filename) {
    std::ifstream file(filename);
    if (!file.is_open()) {
        std::cerr << "Failed to open file\n";
        return;
    }
    std::string line;
    while (std::getline(file, line)) {
        std::cout << line << '\n';
    }
}

int main() {
    std::thread reader(readFile, "example.txt");
    reader.join(); // スレッドの終了を待つ
    return 0;
}

#include <iostream>
#include <future>

int calculateFactorial(int n) {
    return (n == 0) ? 1 : n * calculateFactorial(n - 1);
}

int main() {
    std::future<int> result = std::async(std::launch::async, calculateFactorial, 5);
    std::cout << "Factorial of 5 is: " << result.get() << "\n"; // 結果を取得
    return 0;
}

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

void produceData(std::promise<int> prom) {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // データ生成のシミュレーション
    prom.set_value(10);
}

void consumeData(std::future<int> fut) {
    std::cout << "Data: " << fut.get() << "\n"; // データを取得
}

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();
    std::thread producer(produceData, std::move(prom));
    std::thread consumer(consumeData, std::move(fut));

    producer.join();
    consumer.join();
    return 0;
}

void memoryLeakExample() {
    int* leak = new int[10]; // メモリを確保
    // 確保したメモリを使用するコード
    // ...
    // メモリを解放しないため、リークが発生
}

#include <thread>
#include <vector>

void worker(std::vector<int>* data) {
    // データを使用
}

int main() {
    std::vector<int>* sharedData = new std::vector<int>(100);
    std::thread t1(worker, sharedData);
    std::thread t2(worker, sharedData);
    t1.join();
    t2.join();
    // メモリ解放が忘れられる可能性がある
    delete sharedData;
    return 0;
}

#include <future>

void doWork() {
    // 長時間の作業
}

int main() {
    std::future<void> fut = std::async(std::launch::async, doWork);
    // タスクが完了する前にプログラムが終了する可能性がある
    return 0;
}

#include <functional>
#include <vector>

std::vector<std::function<void()>> callbacks;

void registerCallback(std::function<void()> callback) {
    callbacks.push_back(callback);
}

int main() {
    registerCallback([]() { /* 処理 */ });
    // callbacksが解放されない場合、リークが発生
    return 0;
}

#include <future>
#include <stdexcept>

void riskyWork() {
    throw std::runtime_error("エラー発生");
}

int main() {
    try {
        std::future<void> fut = std::async(std::launch::async, riskyWork);
        fut.get();
    } catch (const std::exception& e) {
        // 例外処理
    }
    // メモリが適切に解放されない場合、リークが発生
    return 0;
}

sudo apt-get install valgrind

valgrind --leak-check=full ./your_program

g++ -fsanitize=address -g -o your_program your_program.cpp

drmemory -- your_program

#include <memory>
#include <iostream>

void asyncTask(std::shared_ptr<int> data) {
    // 非同期タスク内でデータを使用
    std::cout << "Data: " << *data << std::endl;
}

int main() {
    std::shared_ptr<int> data = std::make_shared<int>(42);
    std::thread t(asyncTask, data);
    t.join();
    // 自動的にメモリが解放される
    return 0;
}

#include <iostream>
#include <fstream>
#include <thread>

class FileGuard {
public:
    FileGuard(const std::string& filename) : file(filename) {
        if (!file.is_open()) throw std::runtime_error("ファイルを開けません");
    }
    ~FileGuard() {
        if (file.is_open()) file.close();
    }
    std::ifstream& get() { return file; }

private:
    std::ifstream file;
};

void readFile(const std::string& filename) {
    FileGuard fileGuard(filename);
    std::ifstream& file = fileGuard.get();
    std::string line;
    while (std::getline(file, line)) {
        std::cout << line << '\n';
    }
}

int main() {
    std::thread t(readFile, "example.txt");
    t.join();
    return 0;
}

#include <iostream>
#include <memory>
#include <stdexcept>

void riskyOperation() {
    std::unique_ptr<int> data = std::make_unique<int>(42);
    // 何らかの例外が発生する可能性のある操作
    throw std::runtime_error("エラー発生");
}

int main() {
    try {
        riskyOperation();
    } catch (const std::exception& e) {
        std::cerr << "例外: " << e.what() << std::endl;
    }
    // メモリは自動的に解放される
    return 0;
}

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

std::mutex mtx;

void safeIncrement(int& counter) {
    std::lock_guard<std::mutex> lock(mtx);
    ++counter;
}

int main() {
    int counter = 0;
    std::thread t1(safeIncrement, std::ref(counter));
    std::thread t2(safeIncrement, std::ref(counter));
    t1.join();
    t2.join();
    std::cout << "Counter: " << counter << std::endl;
    return 0;
}

#include <iostream>
#include <memory>
#include <thread>

void processData(std::shared_ptr<int> data) {
    std::cout << "Data: " << *data << std::endl;
}

int main() {
    std::shared_ptr<int> data = std::make_shared<int>(42);
    std::thread t(processData, data);
    t.join(); // スレッドの終了を待つ
    // メモリは自動的に解放される
    return 0;
}

#include <iostream>
#include <fstream>
#include <thread>

class FileGuard {
public:
    FileGuard(const std::string& filename) : file(filename) {
        if (!file.is_open()) throw std::runtime_error("ファイルを開けません");
    }
    ~FileGuard() {
        if (file.is_open()) file.close();
    }
    std::ifstream& get() { return file; }

private:
    std::ifstream file;
};

void readFile(const std::string& filename) {
    FileGuard fileGuard(filename);
    std::ifstream& file = fileGuard.get();
    std::string line;
    while (std::getline(file, line)) {
        std::cout << line << '\n';
    }
}

int main() {
    std::thread t(readFile, "example.txt");
    t.join();
    return 0;
}

#include <iostream>
#include <memory>
#include <stdexcept>

void riskyOperation() {
    std::unique_ptr<int> data = std::make_unique<int>(42);
    // 何らかの例外が発生する可能性のある操作
    throw std::runtime_error("エラー発生");
}

int main() {
    try {
        riskyOperation();
    } catch (const std::exception& e) {
        std::cerr << "例外: " << e.what() << std::endl;
    }
    // メモリは自動的に解放される
    return 0;
}

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

std::mutex mtx;

void safeIncrement(int& counter) {
    std::lock_guard<std::mutex> lock(mtx);
    ++counter;
}

int main() {
    int counter = 0;
    std::thread t1(safeIncrement, std::ref(counter));
    std::thread t2(safeIncrement, std::ref(counter));
    t1.join();
    t2.join();
    std::cout << "Counter: " << counter << std::endl;
    return 0;
}

#include <iostream>

class Resource {
public:
    Resource() { std::cout << "Resource acquired\n"; }
    ~Resource() { std::cout << "Resource released\n"; }
};

void useResource() {
    Resource res;
    // リソースを使用する処理
}

int main() {
    useResource();
    // リソースはスコープ終了時に自動的に解放される
    return 0;
}

#include <iostream>
#include <vector>
#include <thread>
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>

class ThreadPool {
public:
    ThreadPool(size_t numThreads) {
        for (size_t i = 0; i < numThreads; ++i) {
            workers.emplace_back([this] {
                for (;;) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->queueMutex);
                        this->condition.wait(lock, [this] { return this->stop || !this->tasks.empty(); });
                        if (this->stop && this->tasks.empty()) return;
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    void enqueueTask(std::function<void()> task) {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            if (stop) throw std::runtime_error("enqueue on stopped ThreadPool");
            tasks.emplace(std::move(task));
        }
        condition.notify_one();
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& worker : workers) worker.join();
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queueMutex;
    std::condition_variable condition;
    bool stop = false;
};

int main() {
    ThreadPool pool(4);
    for (int i = 0; i < 8; ++i) {
        pool.enqueueTask([i] {
            std::cout << "Task " << i << " is being processed by thread " << std::this_thread::get_id() << std::endl;
        });
    }
    // スレッドプールはスコープ終了時に自動的に終了する
    return 0;
}

#include <iostream>
#include <future>
#include <chrono>

void asyncReadFile(const std::string& filename) {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // シミュレーションとして待機
    std::cout << "Finished reading file: " << filename << std::endl;
}

int main() {
    auto future = std::async(std::launch::async, asyncReadFile, "example.txt");
    std::cout << "Performing other tasks while reading file..." << std::endl;
    future.get(); // ファイル読み込みの完了を待つ
    return 0;
}

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

void processChunk(int start, int end) {
    for (int i = start; i < end; ++i) {
        // 大量の計算をシミュレーション
    }
    std::cout << "Processed chunk: " << start << " to " << end << std::endl;
}

int main() {
    int dataSize = 100;
    int chunkSize = 10;
    std::vector<std::thread> threads;

    for (int i = 0; i < dataSize; i += chunkSize) {
        threads.emplace_back(processChunk, i, std::min(i + chunkSize, dataSize));
    }

    for (auto& t : threads) {
        t.join();
    }
    return 0;
}

#include <iostream>
#include <unordered_map>
#include <shared_mutex>

class Cache {
public:
    int get(int key) {
        std::shared_lock lock(mutex);
        if (cache.find(key) != cache.end()) {
            return cache[key];
        }
        return -1;
    }

    void put(int key, int value) {
        std::unique_lock lock(mutex);
        cache[key] = value;
    }

private:
    std::unordered_map<int, int> cache;
    mutable std::shared_mutex mutex;
};

int main() {
    Cache cache;
    cache.put(1, 100);
    std::cout << "Cached value: " << cache.get(1) << std::endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <thread>
#include <future>
#include <curl/curl.h>

size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp) {
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

std::string fetchUrl(const std::string& url) {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
        res = curl_easy_perform(curl);
        curl_easy_cleanup(curl);
    }
    return readBuffer;
}

int main() {
    std::vector<std::string> urls = {
        "http://example.com",
        "http://example.org",
        "http://example.net"
    };

    std::vector<std::future<std::string>> futures;
    for (const auto& url : urls) {
        futures.push_back(std::async(std::launch::async, fetchUrl, url));
    }

    for (auto& fut : futures) {
        std::string content = fut.get();
        std::cout << "Fetched content size: " << content.size() << " bytes\n";
    }
    return 0;
}

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

void processFile(const std::string& filename) {
    std::ifstream file(filename);
    if (!file.is_open()) {
        std::cerr << "Failed to open file: " << filename << std::endl;
        return;
    }
    std::string line;
    while (std::getline(file, line)) {
        // ファイルの各行を処理
    }
    file.close();
    std::cout << "Processed file: " << filename << std::endl;
}

int main() {
    std::vector<std::string> filenames = {
        "file1.txt",
        "file2.txt",
        "file3.txt"
    };

    std::vector<std::future<void>> futures;
    for (const auto& filename : filenames) {
        futures.push_back(std::async(std::launch::async, processFile, filename));
    }

    for (auto& fut : futures) {
        fut.get(); // ファイル処理の完了を待つ
    }
    return 0;
}