Многопоточные приложения на C++

#include <iostream>
#include <thread>
#include <mutex>
 
std::mutex mtx;
 
void threadFunction(int id) {
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << "Поток " << id << " выполняет работу" << std::endl;
}
 
int main() {
    std::thread t1(threadFunction, 1);
    std::thread t2(threadFunction, 2);
    
    t1.join();
    t2.join();
    
    return 0;
}

#include <vector>
#include <algorithm>
#include <execution>
 
std::vector<int> data(10000000);
 
// Заполнение вектора
std::iota(data.begin(), data.end(), 0);
 
// Параллельная сортировка
std::sort(std::execution::par, data.begin(), data.end());

#include <iostream>
#include <thread>
#include <chrono>
#include <stop_token>
 
void worker(std::stop_token stoken) {
    while (!stoken.stop_requested()) {
        std::cout << "Работаю..." << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    std::cout << "Получен запрос на остановку" << std::endl;
}
 
int main() {
    std::jthread t(worker);
    
    // Поток будет автоматически остановлен и присоединен при выходе из области видимости
    std::this_thread::sleep_for(std::chrono::seconds(5));
    // здесь t.request_stop() вызывается автоматически
}

#include <iostream>
#include <thread>
#include <barrier>
#include <vector>
 
int main() {
    const int thread_count = 4;
    std::barrier sync_point(thread_count);
    
    auto thread_func = [&](int id) {
        // Первая фаза работы
        std::cout << "Поток " << id << " выполнил фазу 1\n";
        
        // Ждём, пока все потоки не выполнят первую фазу
        sync_point.arrive_and_wait();
        
        // Вторая фаза - все потоки начинают одновременно
        std::cout << "Поток " << id << " выполнил фазу 2\n";
    };
    
    std::vector<std::jthread> threads;
    for (int i = 0; i < thread_count; ++i) {
        threads.emplace_back(thread_func, i);
    }
}

#ifdef _WIN32
    HANDLE thread = CreateThread(NULL, 0, ThreadFunction, data, 0, NULL);
    // Обработка специфичных для Windows ошибок
#else
    pthread_t thread;
    pthread_create(&thread, NULL, ThreadFunction, data);
    // Обработка POSIX-специфичных ошибок
#endif

void safeFunction() {
    std::lock_guard<std::mutex> lock(sharedResourceMutex);
    // Работа с общим ресурсом
    // При выходе из функции блокировка автоматически снимется
}

auto futureResult = std::async(std::launch::async, computeExpensiveValue);
// Продолжаем выполнение других задач
// ...
// Когда результат нужен:
int result = futureResult.get(); // Здесь произойдёт ожидание, если вычисление ещё не завершено

std::vector<int> data = getData();
// Просто указываем, что обработка должна быть паралельной
std::transform(std::execution::par_unseq, data.begin(), data.end(), 
                data.begin(), [](int x) { return process(x); });

#include <iostream>
#include <thread>
 
void doWork(int iterations) {
    for (int i = 0; i < iterations; ++i) {
        // Выполнение работы
        std::cout << "Итерация " << i << std::endl;
    }
}
 
int main() {
    // Создание потока, выполняющего функцию doWork с аргументом 5
    std::thread worker(doWork, 5);
    
    // Ожидание завершения потока
    worker.join();
    
    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
 
std::mutex resourceMutex;
std::vector<int> sharedResource;
 
void addToResource(int value) {
    // Блокировка мьютекса перед доступом к общему ресурсу
    resourceMutex.lock();
    
    // Критическая секция - только один поток может выполнять её одновременно
    sharedResource.push_back(value);
    std::cout << "Добавлено значение: " << value << std::endl;
    
    // Разблокировка мьютекса
    resourceMutex.unlock();
}

void safeAddToResource(int value) {
    // Автоматическая блокировка при создании объекта
    std::lock_guard<std::mutex> lock(resourceMutex);
    
    // Критическая секция
    sharedResource.push_back(value);
    std::cout << "Безопасно добавлено значение: " << value << std::endl;
    
    // Автоматическая разблокировка при уничтожении объекта lock
}

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
 
std::mutex queueMutex;
std::condition_variable dataCondition;
std::queue<int> dataQueue;
bool finished = false;
 
void producerFunction() {
    for (int i = 0; i < 10; ++i) {
        {
            std::lock_guard<std::mutex> lock(queueMutex);
            dataQueue.push(i);
            std::cout << "Произведено: " << i << std::endl;
        } // Мьютекс освобождается здесь
        
        // Уведомление одного ожидающего потока
        dataCondition.notify_one();
        
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    
    {
        std::lock_guard<std::mutex> lock(queueMutex);
        finished = true;
    }
    dataCondition.notify_all(); // Уведомляем всех ожидающих
}
 
void consumerFunction() {
    while (true) {
        std::unique_lock<std::mutex> lock(queueMutex);
        
        // Ожидание появления данных или завершения работы
        dataCondition.wait(lock, []{ 
            return !dataQueue.empty() || finished; 
        });
        
        if (dataQueue.empty() && finished) {
            // Работа завершена, данных больше не будет
            break;
        }
        
        int value = dataQueue.front();
        dataQueue.pop();
        
        std::cout << "Использовано: " << value << std::endl;
    }
}

#include <atomic>
#include <thread>
#include <iostream>
 
std::atomic<int> counter(0);  // Атомарный счётчик
 
void increment(int iterations) {
    for (int i = 0; i < iterations; ++i) {
        // Атомарное увеличение - безопасно в многопоточной среде
        counter++;
    }
}
 
int main() {
    std::thread t1(increment, 1000);
    std::thread t2(increment, 1000);
    
    t1.join();
    t2.join();
    
    std::cout << "Итоговое значение: " << counter << std::endl;
    // Всегда будет 2000, в отличие от обычной переменной!
    
    return 0;
}

// Инкремент с указанием модели памяти
counter.fetch_add(1, std::memory_order_relaxed);

std::mutex mutexA, mutexB;
 
void threadFunction1() {
    std::lock_guard<std::mutex> lockA(mutexA);
    std::this_thread::sleep_for(std::chrono::milliseconds(1)); // Имитация работы
    std::lock_guard<std::mutex> lockB(mutexB);
    // Действия с общими ресурсами
}
 
void threadFunction2() {
    std::lock_guard<std::mutex> lockB(mutexB);
    std::this_thread::sleep_for(std::chrono::milliseconds(1)); // Имитация работы
    std::lock_guard<std::mutex> lockA(mutexA);
    // Действия с общими ресурсами
}

void safeFunction() {
    std::mutex mutexA, mutexB;
    
    // Атомарная блокировка обоих мьютексов - исключает взаимную блокировку
    std::lock(mutexA, mutexB);
    
    // Захват уже заблокированных мьютексов
    std::lock_guard<std::mutex> lockA(mutexA, std::adopt_lock);
    std::lock_guard<std::mutex> lockB(mutexB, std::adopt_lock);
    
    // Работа с защищёнными ресурсами
}

void modernSafeFunction() {
    std::mutex mutexA, mutexB;
    
    // Одновременная блокировка всех мьютексов безопасным способом
    std::scoped_lock lock(mutexA, mutexB);
    
    // Работа с защищёнными ресурсами
} // Автоматическая разблокировка при выходе из области видимости

std::queue<Message> messageQueue;
std::mutex queueMutex;
std::condition_variable queueCondition;
 
void workerThread() {
    while (true) {
        Message msg;
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            queueCondition.wait(lock, [] { return !messageQueue.empty(); });
            msg = messageQueue.front();
            messageQueue.pop();
        }
        processMessage(msg);
    }
}

std::atomic<int> counter(0);
counter.fetch_add(1, std::memory_order_relaxed);

// Компиляция с поддержкой ThreadSanitizer
g++ -fsanitize=thread -g -O1 -fPIE my_program.cpp

std::mutex balanceMutex;
void withdraw(Account& account, int amount) {
    std::lock_guard<std::mutex> guard(balanceMutex);
    if (account.balance >= amount) {
        // Имитация сложной опирации
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
        account.balance -= amount;
    }
}

std::atomic<int> counter(0);
// Никаких гонок при параллельном инкременте
void increment() { counter++; }

std::atomic<int> value{0};
 
// Запись с максимальными гарантиями (по умолчанию)
value.store(10, std::memory_order_seq_cst);
 
// Запись с минимальными гарантиями - только атомарность
value.store(20, std::memory_order_relaxed);
 
// Запись с гарантией, что все предыдущие операции 
// станут видимыми другим потокам
value.store(30, std::memory_order_release);
 
// Чтение с гарантией увидеть все изменения,
// сделанные с memory_order_release
int x = value.load(std::memory_order_acquire);

#include <latch>
#include <thread>
#include <vector>
 
void processData(std::latch& startSignal, std::latch& doneSignal, int id) {
    // Ждём сигнала старта
    startSignal.wait();
    
    // Выполняем работу
    std::cout << "Поток " << id << " обрабатывает данные" << std::endl;
    
    // Сигнализируем о завершении
    doneSignal.count_down();
}
 
int main() {
    const int threadCount = 4;
    std::latch startSignal(1);          // Только один счёт - сигнал старта
    std::latch doneSignal(threadCount); // Ждём завершения всех потоков
    
    std::vector<std::thread> threads;
    for (int i = 0; i < threadCount; ++i) {
        threads.emplace_back(processData, std::ref(startSignal), 
                            std::ref(doneSignal), i);
    }
    
    // Даём сигнал всем потокам стартовать одновременно
    startSignal.count_down();
    
    // Ждём, пока все потоки завершат работу
    doneSignal.wait();
    
    for (auto& t : threads) {
        t.join();
    }
}

#include <barrier>
#include <thread>
#include <vector>
 
void iterativeProcess(std::barrier<>& sync, int id, int iterations) {
    for (int i = 0; i < iterations; ++i) {
        // Первая фаза обработки
        std::cout << "Поток " << id << ", итерация " << i << ", фаза 1" << std::endl;
        
        // Синхронизация после первой фазы
        sync.arrive_and_wait();
        
        // Вторая фаза (все потоки начинают одновременно)
        std::cout << "Поток " << id << ", итерация " << i << ", фаза 2" << std::endl;
        
        // Синхронизация перед следующей итерацией
        sync.arrive_and_wait();
    }
}

auto completion = []() noexcept { 
    std::cout << "Все потоки достигли барьера!" << std::endl; 
};
std::barrier sync(threadCount, completion);

std::vector<int> data(1000000);
// Заполнение данными...
 
for (auto& value : data) {
    value = value * value;
}

void squareChunk(std::vector<int>& data, size_t start, size_t end) {
    for (size_t i = start; i < end; ++i) {
        data[i] = data[i] * data[i];
    }
}
 
void parallelSquare(std::vector<int>& data) {
    const size_t numThreads = std::thread::hardware_concurrency();
    const size_t chunkSize = data.size() / numThreads;
    
    std::vector<std::thread> threads;
    
    for (size_t i = 0; i < numThreads; ++i) {
        size_t start = i * chunkSize;
        size_t end = (i == numThreads - 1) ? data.size() : (i + 1) * chunkSize;
        
        threads.emplace_back(squareChunk, std::ref(data), start, end);
    }
    
    for (auto& t : threads) {
        t.join();
    }
}

template<typename T>
class ThreadSafeQueue {
private:
    std::queue<T> queue;
    mutable std::mutex mutex;
    std::condition_variable cond;
public:
    void push(T value) {
        std::lock_guard<std::mutex> lock(mutex);
        queue.push(std::move(value));
        cond.notify_one();
    }
    
    T pop() {
        std::unique_lock<std::mutex> lock(mutex);
        cond.wait(lock, [this] { return !queue.empty(); });
        T value = std::move(queue.front());
        queue.pop();
        return value;
    }
    
    bool empty() const {
        std::lock_guard<std::mutex> lock(mutex);
        return queue.empty();
    }
};

ThreadSafeQueue<int> queue;
 
void producer() {
    for (int i = 0; i < 100; ++i) {
        queue.push(i);
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}
 
void consumer() {
    for (int i = 0; i < 100; ++i) {
        int value = queue.pop();
        process(value);
    }
}

class ThreadPool {
private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
 
public:
    ThreadPool(size_t threads) : stop(false) {
        for (size_t i = 0; i < threads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(queue_mutex);
                        condition.wait(lock, [this] { 
                            return stop || !tasks.empty(); 
                        });
                        
                        if (stop && tasks.empty()) return;
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
        }
    }
 
    template<class F>
    void enqueue(F&& f) {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            tasks.emplace(std::forward<F>(f));
        }
        condition.notify_one();
    }
 
    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread &worker : workers) {
            worker.join();
        }
    }
};

int main() {
    ThreadPool pool(4); // Создаём пул из 4 потоков
    
    // Запускаем задачи асинхронно
    for (int i = 0; i < 100; ++i) {
        pool.enqueue([i] {
            std::cout << "Обработка задачи " << i << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        });
    }
    
    // Пул автоматически завершит работу при выходе из области видимости
    return 0;
}

class ExceptionCollector {
private:
    std::vector<std::exception_ptr> exceptions;
    std::mutex mutex;
 
public:
    void add(std::exception_ptr ex) {
        std::lock_guard<std::mutex> lock(mutex);
        exceptions.push_back(ex);
    }
    
    void rethrow_if_any() {
        std::lock_guard<std::mutex> lock(mutex);
        if (!exceptions.empty()) {
            std::rethrow_exception(exceptions.front());
        }
    }
};

void process_with_exceptions(std::vector<int>& data, ExceptionCollector& collector) {
    std::vector<std::thread> threads;
    
    for (size_t i = 0; i < data.size(); ++i) {
        threads.emplace_back([&data, i, &collector] {
            try {
                // Потенциально опасный код
                if (data[i] < 0) {
                    throw std::runtime_error("Отрицательное значение");
                }
                data[i] = process(data[i]);
            } catch (...) {
                collector.add(std::current_exception());
            }
        });
    }
    
    for (auto& t : threads) {
        t.join();
    }
    
    // Проверяем и перевыбрасываем первое исключение, если оно возникло
    collector.rethrow_if_any();
}

std::promise<int> resultPromise;
std::future<int> resultFuture = resultPromise.get_future();
 
// Запуск вычисления в отдельном потоке
std::thread worker([&resultPromise] {
    try {
        int result = performComputation(); // Долгое вычисление
        resultPromise.set_value(result);   // Установка результата
    } catch (...) {
        resultPromise.set_exception(std::current_exception()); // Сохранение исключения
    }
});
 
// Тем временем, в основном потоке можно делать что-то другое
doOtherWork();
 
// Получение результата - будет ждать, если он ещё не готов
try {
    int result = resultFuture.get(); // Блокирующий вызов
    useResult(result);
} catch (const std::exception& e) {
    std::cerr << "Вычисление завершилось ошибкой: " << e.what() << std::endl;
}
 
worker.join();

auto status = resultFuture.wait_for(std::chrono::seconds(5));
if (status == std::future_status::ready) {
    // Результат готов
    int result = resultFuture.get();
    useResult(result);
} else if (status == std::future_status::timeout) {
    // Результат не получен в течение 5 секунд
    handleTimeout();
}

std::promise<int> resultPromise;
std::shared_future<int> sharedFuture = resultPromise.get_future().share();
 
// Несколько потоков могут ждать один результат
std::thread consumer1([sharedFuture] { useResult(sharedFuture.get()); });
std::thread consumer2([sharedFuture] { useResult(sharedFuture.get()); });

#include <future>
#include <iostream>
#include <chrono>
 
int computeFactorial(int n) {
    if (n < 0) throw std::invalid_argument("Отрицательный аргумент");
    int result = 1;
    for (int i = 2; i <= n; ++i) {
        result *= i;
    }
    return result;
}
 
int main() {
    // Запуск вычисления асинхронно
    std::future<int> resultFuture = std::async(std::launch::async, computeFactorial, 10);
    
    // Выполнение другой работы, пока вычисляется факториал
    std::cout << "Выполняется другая работа..." << std::endl;
    
    // Получение результата (блокирующий вызов)
    try {
        int result = resultFuture.get();
        std::cout << "Факториал: " << result << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Ошибка: " << e.what() << std::endl;
    }
}

// Принудительное асинхронное выполнение
auto f1 = std::async(std::launch::async, []{ return heavyComputation(); });
 
// Отложенное выполнение - запустится только при обращении к результату
auto f2 = std::async(std::launch::deferred, []{ return anotherComputation(); });

#include <thread>
#include <future>
#include <functional>
 
int main() {
    // Создаём упакованную задачу
    std::packaged_task<int(int, int)> addTask([](int a, int b) {
        return a + b;
    });
    
    // Получаем future до запуска задачи
    std::future<int> resultFuture = addTask.get_future();
    
    // Запускаем задачу в отдельном потоке
    std::thread taskThread(std::move(addTask), 2, 3);
    
    // Получаем результат
    int sum = resultFuture.get();
    std::cout << "Сумма: " << sum << std::endl;
    
    // Дожидаемся завершения потока
    taskThread.join();
}

std::packaged_task<int()> task([]{ return complexCalculation(); });
std::future<int> result = task.get_future();
 
// Передаём задачу в пул потоков
threadPool.enqueue([&task]{ task(); });
 
// Позже получаем результат
int value = result.get();

std::tuple<int, double, bool> processDataAsync(const std::vector<int>& data) {
    int result = 0;
    double processingTime = 0.0;
    bool success = true;
    
    // Имитация обработки
    auto start = std::chrono::high_resolution_clock::now();
    for (auto value : data) {
        result += value;
    }
    processingTime = std::chrono::duration_cast<std::chrono::milliseconds>(
        std::chrono::high_resolution_clock::now() - start
    ).count() / 1000.0;
    
    return {result, processingTime, success};
}
 
// Использование с async и structured bindings
auto futureResult = std::async(std::launch::async, processDataAsync, data);
 
// Когда результат будет нужен
auto [sum, time, ok] = futureResult.get();

struct AsyncResult {
    int value;
    std::string error;
    double elapsed;
};
 
AsyncResult complexComputation() {
    // Вычисления...
    return {42, "", 1.23};
}
 
std::future<AsyncResult> futureResult = std::async(complexComputation);
 
// Элегантная распаковка результата
auto [value, error, time] = futureResult.get();

std::optional<std::tuple<int, std::string>> getDataIfAvailable() {
    if (dataReady()) {
        return std::make_tuple(42, "success");
    }
    return std::nullopt;
}
 
if (auto resultOpt = getDataIfAvailable(); resultOpt) {
    auto& [value, message] = *resultOpt;
    // Используем result и message
}

class ActiveObject {
private:
    std::thread worker;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
 
public:
    ActiveObject() : stop(false) {
        worker = std::thread([this] {
            while (true) {
                std::function<void()> task;
                {
                    std::unique_lock<std::mutex> lock(queue_mutex);
                    condition.wait(lock, [this] { return stop || !tasks.empty(); });
                    if (stop && tasks.empty()) return;
                    task = std::move(tasks.front());
                    tasks.pop();
                }
                task();
            }
        });
    }
 
    template <class F>
    void enqueue(F&& task) {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            tasks.push(std::forward<F>(task));
        }
        condition.notify_one();
    }
 
    ~ActiveObject() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        if (worker.joinable()) worker.join();
    }
};

template <typename T>
class RCUProtected {
private:
    std::atomic<T*> data;
    std::mutex write_mutex;
 
public:
    RCUProtected(T* initial_value) : data(initial_value) {}
 
    // Для читателей - не требует блокировок
    T* read() {
        return data.load(std::memory_order_acquire);
    }
 
    // Для писателей - создаёт копию, модифицирует, заменяет
    template <typename ModifyFunc>
    void update(ModifyFunc modifier) {
        std::lock_guard<std::mutex> lock(write_mutex);
        
        // Создаём копию текущих данных
        T* old_data = data.load(std::memory_order_acquire);
        T* new_data = new T(*old_data);
        
        // Модифицируем копию
        modifier(*new_data);
        
        // Атомарно заменяем указатель
        data.store(new_data, std::memory_order_release);
        
        // В реальном RCU здесь была бы дополнительная логика
        // для безопасного удаления старых данных
        delete old_data;
    }
 
    ~RCUProtected() {
        delete data.load();
    }
};

template<typename T, size_t Size>
class SPSCQueue {
private:
    std::array<T, Size> buffer;
    std::atomic<size_t> head{0};
    std::atomic<size_t> tail{0};
 
public:
    bool push(const T& item) {
        size_t current_tail = tail.load(std::memory_order_relaxed);
        size_t next_tail = (current_tail + 1) % Size;
        
        if (next_tail == head.load(std::memory_order_acquire))
            return false;  // Очередь переполнена
        
        buffer[current_tail] = item;
        tail.store(next_tail, std::memory_order_release);
        return true;
    }
 
    bool pop(T& item) {
        size_t current_head = head.load(std::memory_order_relaxed);
        
        if (current_head == tail.load(std::memory_order_acquire))
            return false;  // Очередь пуста
        
        item = buffer[current_head];
        head.store((current_head + 1) % Size, std::memory_order_release);
        return true;
    }
};

class TaskSystem {
private:
    struct Task {
        std::function<void()> func;
        std::vector<Task*> dependencies;
    };
 
    std::vector<Task> tasks;
    // Остальная реализация...
};

class WorkStealingQueue {
private:
    std::deque<std::function<void()>> tasks;
    std::mutex mutex;
 
public:
    void push(std::function<void()> task) {
        std::lock_guard<std::mutex> lock(mutex);
        tasks.push_front(std::move(task));
    }
 
    bool pop(std::function<void()>& task) {
        std::lock_guard<std::mutex> lock(mutex);
        if (tasks.empty()) return false;
        
        task = std::move(tasks.front());
        tasks.pop_front();
        return true;
    }
 
    bool steal(std::function<void()>& task) {
        std::lock_guard<std::mutex> lock(mutex);
        if (tasks.empty()) return false;
        
        // Воруем с конца очереди для минимизации конфликтов
        task = std::move(tasks.back());
        tasks.pop_back();
        return true;
    }
};

class Actor {
private:
    std::queue<Message> mailbox;
    std::mutex mailbox_mutex;
    std::condition_variable message_condition;
    std::thread worker;
    bool stop = false;
 
    void processMessages() {
        while (true) {
            Message msg;
            {
                std::unique_lock<std::mutex> lock(mailbox_mutex);
                message_condition.wait(lock, [this] { 
                    return !mailbox.empty() || stop; 
                });
                
                if (stop && mailbox.empty()) return;
                
                msg = std::move(mailbox.front());
                mailbox.pop();
            }
            onMessage(msg);
        }
    }
 
protected:
    virtual void onMessage(const Message& msg) = 0;
 
public:
    Actor() {
        worker = std::thread(&Actor::processMessages, this);
    }
 
    void send(Message msg) {
        {
            std::lock_guard<std::mutex> lock(mailbox_mutex);
            mailbox.push(std::move(msg));
        }
        message_condition.notify_one();
    }
 
    virtual ~Actor() {
        {
            std::lock_guard<std::mutex> lock(mailbox_mutex);
            stop = true;
        }
        message_condition.notify_all();
        worker.join();
    }
};

std::atomic<bool> flag{false};
std::atomic<int> data{0};
 
// Поток 1
void producer() {
    data.store(42, std::memory_order_relaxed); // Сначала записываем данные
    flag.store(true, std::memory_order_release); // Затем сигнализируем о готовности
}
 
// Поток 2
void consumer() {
    while (!flag.load(std::memory_order_acquire)); // Ждём сигнала
    int value = data.load(std::memory_order_relaxed); // Теперь безопасно читаем
}

#include <algorithm>
#include <execution>
#include <vector>
 
std::vector<int> hugeVector(10'000'000);
// Заполняем вектор...
 
// Последовательная сортировка
std::sort(hugeVector.begin(), hugeVector.end());
 
// Параллельная сортировка - просто добавляем политику выполнения
std::sort(std::execution::par, hugeVector.begin(), hugeVector.end());

// Выполнение с возможной векторизацией и распараллеливанием
std::transform(std::execution::par_unseq, 
              data.begin(), data.end(), 
              data.begin(),
              [](float x) { return std::sqrt(x); });

#include <ranges>
#include <algorithm>
#include <execution>
 
auto result = data | std::views::filter([](int n) { return n > 0; })
                  | std::views::transform([](int n) { return n * n; });
 
// Выполнение алгоритма над диапазоном в параллельном режиме
std::ranges::sort(result, std::execution::par);

#include <coroutine>
#include <iostream>
 
struct Task {
    struct promise_type {
        Task get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
};
 
Task simpleCoroutine() {
    std::cout << "Начало корутины" << std::endl;
    co_await std::suspend_always{};
    std::cout << "Продолжение после возобновления" << std::endl;
}

Task processRequest(Connection conn) {
    // Чтение запроса - может приостановить выполнение, не блокируя поток
    Request req = co_await conn.readRequest();
    
    // Обработка данных
    Response resp = processData(req);
    
    // Отправка ответа - снова может приостановить без блокировки
    co_await conn.sendResponse(resp);
}

class Actor {
private:
    ThreadSafeQueue<Message> mailbox;
    std::thread worker;
    
public:
    Actor() {
        worker = std::thread([this] {
            while (true) {
                Message msg = mailbox.pop(); // Блокирующее получение
                if (msg.type == Message::TERMINATE) break;
                process(msg);
            }
        });
    }
    
    void send(Message msg) {
        mailbox.push(std::move(msg));
    }
    
    virtual void process(const Message& msg) = 0;
    
    ~Actor() {
        send({Message::TERMINATE});
        worker.join();
    }
};

class PipelineStage {
private:
    ThreadSafeQueue<DataItem>& input;
    ThreadSafeQueue<DataItem>& output;
    std::thread worker;
    
public:
    PipelineStage(ThreadSafeQueue<DataItem>& in, ThreadSafeQueue<DataItem>& out) 
        : input(in), output(out) {
        worker = std::thread([this] {
            while (true) {
                DataItem item = input.pop();
                if (item.isTerminal()) break;
                
                DataItem processed = process(item);
                output.push(std::move(processed));
            }
            // Пропускаем терминальный элемент для корректного завершения
            output.push(DataItem::createTerminal());
        });
    }
    
    virtual DataItem process(const DataItem& item) = 0;
};

template <typename T, typename R>
std::vector<R> parallelMap(const std::vector<T>& data, 
                          std::function<R(T)> mapper) {
    const size_t threadCount = std::thread::hardware_concurrency();
    const size_t itemsPerThread = data.size() / threadCount;
    
    std::vector<std::future<std::vector<R>>> futures;
    
    // Fork: разделение на подзадачи
    for (size_t t = 0; t < threadCount; ++t) {
        size_t start = t * itemsPerThread;
        size_t end = (t == threadCount - 1) ? data.size() : (t + 1) * itemsPerThread;
        
        futures.push_back(std::async(std::launch::async, [&data, mapper, start, end] {
            std::vector<R> results;
            for (size_t i = start; i < end; ++i) {
                results.push_back(mapper(data[i]));
            }
            return results;
        }));
    }
    
    // Join: сбор результатов
    std::vector<R> result;
    for (auto& future : futures) {
        auto partialResults = future.get();
        result.insert(result.end(), partialResults.begin(), partialResults.end());
    }
    
    return result;
}

#include <immintrin.h> // Для AVX/SSE интринсиков
 
void vectorAdd(float* a, float* b, float* result, size_t size) {
    // Выравнивание важно для производительности SIMD
    for (size_t i = 0; i < size; i += 8) {
        // Загружаем 8 float чисел одной инструкцией
        __m256 va = _mm256_load_ps(a + i);
        __m256 vb = _mm256_load_ps(b + i);
        
        // Складываем 8 пар чисел параллельно
        __m256 vresult = _mm256_add_ps(va, vb);
        
        // Сохраняем результат
        _mm256_store_ps(result + i, vresult);
    }
}

void autoVectorizedAdd(float* a, float* b, float* result, size_t size) {
    // Компилятор может автоматически преобразовать этот цикл в SIMD-инструкции
    // при соответствующем уровне оптимизации (-O3 в GCC/Clang)
    for (size_t i = 0; i < size; ++i) {
        result[i] = a[i] + b[i];
    }
}

#include <experimental/simd>
namespace stdx = std::experimental;
 
void modernVectorAdd(float* a, float* b, float* c, size_t n) {
    using simd_t = stdx::native_simd<float>;
    
    for (size_t i = 0; i < n; i += simd_t::size()) {
        simd_t va(a + i);
        simd_t vb(b + i);
        (va + vb).copy_to(c + i);
    }
}

#include <boost/fiber/all.hpp>
#include <thread>
#include <vector>
 
void fiber_function(int fiber_id) {
    for (int i = 0; i < 3; ++i) {
        std::cout << "Фибер " << fiber_id << " выполняется в потоке " 
                  << std::this_thread::get_id() << std::endl;
        boost::this_fiber::yield(); // Кооперативное переключение
    }
}
 
void thread_function(int thread_id) {
    // Запускаем несколько фиберов в этом потоке
    std::vector<boost::fibers::fiber> fibers;
    for (int i = 0; i < 5; ++i) {
        fibers.emplace_back(fiber_function, i + thread_id * 10);
    }
    
    // Запускаем планировщик фиберов
    for (auto& f : fibers) {
        f.join();
    }
}