Использование корутин C++ для асинхронных задач

struct promise_type {
  auto get_return_object() { /*...*/ }       // Создает объект результата корутины
  auto initial_suspend() { /*...*/ }         // Определяет, нужна ли начальная приостановка
  auto final_suspend() noexcept { /*...*/ }  // Определяет поведение при завершении
  void return_void() { /*...*/ }             // Обрабатывает co_return без значения
  void unhandled_exception() { /*...*/ }     // Обрабатывает исключения
};

// Сложный многопоточный подход
std::mutex mtx;
std::condition_variable cv;
std::vector<int> data;
bool ready = false;
 
void producer() {
    std::unique_lock<std::mutex> lock(mtx);
    data.push_back(42);
    ready = true;
    lock.unlock();
    cv.notify_one();
}
 
void consumer() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{return ready;});
    // Используем data...
}
 
// Элегантный подход с корутинами
async_task<int> producer() {
    co_return 42;
}
 
async_task<void> consumer() {
    int value = co_await producer();
    // Используем value...
}

// Пример кастомного awaitable для таймера
struct sleep_for {
    chrono::milliseconds duration;
    
    bool await_ready() const noexcept {
        return duration.count() <= 0;
    }
    
    void await_suspend(coroutine_handle<> h) {
        thread([this, h]() {
            this_thread::sleep_for(duration);
            h.resume();
        }).detach();
    }
    
    void await_resume() const noexcept {}
};
 
// Использование в корутине
task<void> delay_operation() {
    cout << "Начинаем операцию" << endl;
    co_await sleep_for{1000ms};  // Ждем 1 секунду
    cout << "Операция завершена" << endl;
}

task<int> risky_operation() {
    try {
        int result = co_await dangerous_call();
        co_return result;
    } catch(const std::exception& e) {
        // Локальная обработка ошибки
        co_return -1;
    }
}
 
// Вызывающий код
task<void> caller() {
    try {
        int val = co_await risky_operation();
        // Используем val...
    } catch(...) {
        // Этот блок поймает исключения из promise::unhandled_exception
    }
}

template <typename T>
struct cancelable_task {
    struct promise_type {
        std::optional<T> result;
        std::exception_ptr exception;
        bool canceled = false;
        
        cancelable_task get_return_object() { /*...*/ }
        void return_value(T value) { result = std::move(value); }
        void unhandled_exception() { exception = std::current_exception(); }
        
        // Метод для отмены операции извне
        void cancel() { canceled = true; }
        
        // Проверка отмены внутри корутины
        bool is_canceled() const { return canceled; }
    };
    
    // Интерфейс для вызывающего кода
    bool cancel() { /*...*/ }
};

// Для GCC/Clang
$ g++ -std=c++20 -fcoroutines my_program.cpp
// Для MSVC
$ cl /std:c++20 /await my_program.cpp

#include <coroutine>
#include <iostream>
 
struct simple_task {
    struct promise_type {
        simple_task get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
};
 
simple_task hello_coroutine() {
    std::cout << "Привет, ";
    co_await std::suspend_always{};
    std::cout << "мир корутин!" << std::endl;
}
 
int main() {
    auto task = hello_coroutine();
    // Корутина уже напечатала "Привет, " и приостановилась
    // Здесь можно что-то сделать...
    // А теперь продолжим корутину
    
    return 0;
}

#include <coroutine>
#include <iostream>
 
struct simple_task {
    struct promise_type;
    using handle_type = std::coroutine_handle<promise_type>;
    
    struct promise_type {
        simple_task get_return_object() { 
            return simple_task{handle_type::from_promise(*this)}; 
        }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
    
    handle_type coro;
    
    simple_task(handle_type h) : coro(h) {}
    ~simple_task() { if(coro) coro.destroy(); }
    
    void resume() { if(coro) coro.resume(); }
};
 
simple_task hello_coroutine() {
    std::cout << "Привет, ";
    co_await std::suspend_always{};
    std::cout << "мир корутин!" << std::endl;
}
 
int main() {
    auto task = hello_coroutine();
    // Ничего не напечатано, т.к. корутина сразу приостановилась (initial_suspend)
    std::cout << "Основная программа работает..." << std::endl;
    task.resume();  // Возобновляем корутину - печатает "Привет, "
    std::cout << "Снова в основной программе..." << std::endl;
    task.resume();  // Снова возобновляем - печатает "мир корутин!"
    return 0;
}

#include <coroutine>
#include <fstream>
#include <string>
#include <future>
 
struct async_read_file {
    bool await_ready() { return false; }
    
    void await_suspend(std::coroutine_handle<> handle) {
        std::thread([this, handle]() mutable {
            file.open(filename);
            if (file.is_open()) {
                std::string line;
                while (std::getline(file, line)) {
                    content += line + "\n";
                }
                file.close();
            }
            handle.resume();
        }).detach();
    }
    
    std::string await_resume() { return content; }
    
    std::string filename;
    std::ifstream file;
    std::string content;
    
    async_read_file(const std::string& fname) : filename(fname) {}
};
 
template <typename T>
struct async_task {
  struct promise_type {
      std::promise<T> promise;
      
      async_task get_return_object() {
          return async_task{promise.get_future()};
      }
      std::suspend_never initial_suspend() { return {}; }
      std::suspend_never final_suspend() noexcept { return {}; }
      void return_value(T value) {
          promise.set_value(std::move(value));
      }
      void unhandled_exception() {
          promise.set_exception(std::current_exception());
      }
  };
  
  std::future<T> future;
  async_task(std::future<T>&& f) : future(std::move(f)) {}
};
 
async_task<std::string> read_file_async(const std::string& filename) {
  std::string content = co_await async_read_file{filename};
  co_return content;
}

// Простой HTTP-клиент с использованием корутин
struct http_response {
  int status_code;
  std::string body;
};
 
struct async_http_request {
  std::string url;
  
  bool await_ready() { return false; }
  
  void await_suspend(std::coroutine_handle<> handle) {
      std::thread([this, handle]() mutable {
          // Здесь был бы реальный HTTP-запрос
          // Для примера используем заглушку
          response.status_code = 200;
          response.body = "{"success": true, "data": "пример ответа"}";
          
          // Имитация задержки сети
          std::this_thread::sleep_for(std::chrono::milliseconds(150));
          
          handle.resume();
      }).detach();
  }
  
  http_response await_resume() { return response; }
  
  http_response response;
};
 
async_task<http_response> fetch_data(const std::string& api_url) {
  http_response response = co_await async_http_request{api_url};
  co_return response;
}

async_task<void> handle_errors() {
  try {
      std::string content = co_await read_file_async("несуществующий_файл.txt");
      std::cout << "Содержимое: " << content << std::endl;
  } catch (const std::exception& e) {
      std::cerr << "Ошибка: " << e.what() << std::endl;
  }
}

class async_mutex {
  std::mutex mtx;
  std::queue<std::coroutine_handle<>> waiters;
  
  public:
  struct lock_operation {
      async_mutex& mutex;
      bool locked = false;
      
      bool await_ready() {
          std::unique_lock<std::mutex> lock(mutex.mtx);
          if (mutex.waiters.empty()) {
              locked = true;
              return true;
          }
          return false;
      }
      
      void await_suspend(std::coroutine_handle<> handle) {
          std::unique_lock<std::mutex> lock(mutex.mtx);
          mutex.waiters.push(handle);
      }
      
      void await_resume() {}
      
      ~lock_operation() {
          if (locked) {
              std::unique_lock<std::mutex> lock(mutex.mtx);
              if (!mutex.waiters.empty()) {
                  auto next = mutex.waiters.front();
                  mutex.waiters.pop();
                  next.resume();
              }
          }
      }
  };
  
  lock_operation lock() { return {*this}; }
};
 
async_task<void> protected_operation(async_mutex& mtx, int id) {
  {
      auto lock = co_await mtx.lock();
      std::cout << "Поток " << id << " получил блокировку" << std::endl;
      // Критическая секция
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
  }
  std::cout << "Поток " << id << " освободил блокировку" << std::endl;
}

template <typename T>
class async_generator {
public:
    struct promise_type {
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        async_generator get_return_object() { 
            return async_generator{handle::from_promise(*this)}; 
        }
        std::suspend_always yield_value(T value) {
            current_value = std::move(value);
            return {};
        }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
        T current_value;
    };
    
    using handle = std::coroutine_handle<promise_type>;
    
    async_generator(handle h) : coro(h) {}
    ~async_generator() { if(coro) coro.destroy(); }
    
    struct iterator {
        handle coro;
        
        bool operator!=(const iterator& other) const { return coro != other.coro; }
        void operator++() { coro.resume(); }
        const T& operator*() const { return coro.promise().current_value; }
    };
    
    iterator begin() {
        coro.resume();
        return coro.done() ? end() : iterator{coro};
    }
    
    iterator end() { return iterator{nullptr}; }
    
private:
    handle coro;
};
 
async_generator<int> fibonacci() {
    int a = 0, b = 1;
    while (true) {
        co_yield a;
        auto tmp = a;
        a = b;
        b = tmp + b;
    }
}

void print_first_10_fibonacci() {
    auto fib = fibonacci();
    int count = 0;
    for (auto value : fib) {
        std::cout << value << " ";
        if (++count >= 10) break;  // Избегаем бесконечного цикла
    }
}

template <typename AsyncOperation>
async_task<void> retry_operation(AsyncOperation op, int max_attempts = 3) {
    int attempts = 0;
    while (true) {
        try {
            co_await op();
            break;  // Успешно - выходим из цикла
        } catch (const std::exception& e) {
            if (++attempts >= max_attempts)
                throw;  // Все попытки исчерпаны
            
            // Экспоненциальная задержка перед повторной попыткой
            co_await sleep_for{std::chrono::milliseconds(100 * (1 << attempts))};
        }
    }
}

struct cancellation_token {
    bool is_cancellation_requested() const { return canceled; }
    void request_cancellation() { canceled = true; }
    
private:
    std::atomic<bool> canceled = false;
};
 
template <typename T>
struct cancelable_operation {
    T operation;
    std::shared_ptr<cancellation_token> token;
    
    bool await_ready() { return false; }
    
    template <typename Promise>
    void await_suspend(std::coroutine_handle<Promise> handle) {
        std::thread([this, handle]() mutable {
            // Периодически проверяем токен отмены
            while (!token->is_cancellation_requested()) {
                if (/* операция завершена */) {
                    handle.resume();
                    return;
                }
                std::this_thread::sleep_for(std::chrono::milliseconds(10));
            }
            
            // Операция отменена
            handle.promise().unhandled_exception() = 
                std::make_exception_ptr(std::runtime_error("Operation canceled"));
            handle.resume();
        }).detach();
    }
    
    auto await_resume() { /* возврат результата */ }
};

// Корутинный подход (420k запросов/сек)
async_task<json> process_request(Request req) {
  auto data = co_await database.query(req.user_id);
  auto profile = co_await api.get_profile(data.profile_id);
  co_return {data, profile};
}
 
// Колбэк-подход (396k запросов/сек)
void process_request(Request req, Callback cb) {
  database.query(req.user_id, [req, cb](auto data) {
    api.get_profile(data.profile_id, [data, cb](auto profile) {
      cb({data, profile});
    });
  });
}

template<typename T>
struct per_thread_allocator {
    using value_type = T;
    
    T* allocate(std::size_t n) {
        thread_local static std::vector<std::byte> pool;
        // Реализация аллокации из локального пула
        // ...
        return static_cast<T*>(ptr);
    }
    
    void deallocate(T* p, std::size_t n) {
        // Возврат памяти в пул
    }
};
 
// Использование в корутине
using thread_local_task = basic_task<per_thread_allocator<std::byte>>;

// Неоптимально - большой кадр корутины
async_task<void> process_large_data() {
  std::array<double, 1024> buffer; // Большая локальная переменная
  // ...
  co_await some_operation();
  // Использование buffer
}
 
// Оптимизированная версия
async_task<void> process_large_data_optimized() {
  auto buffer = std::make_shared<std::array<double, 1024>>(); // В куче, вне кадра
  // ...
  co_await some_operation();
  // Использование *buffer
}

// Может быть оптимизировано в обычную функцию
async_task<int> calculate() {
  co_return 42; // Нет co_await, компилятор может устранить корутину
}
 
// Или даже такой случай
async_task<int> calculate_simple() {
  if (condition) {
    co_await async_op(); // Приостановка зависит от условия
  }
  co_return 42;
}

async_task<void> temperature_monitor(sensor& temp_sensor) {
  while (true) {
    auto reading = co_await temp_sensor.next_reading();
    if (reading > threshold) {
      co_await alert_system.trigger_warning(reading);
    }
    co_await sleep_for(1min);
  }
}