import asyncio
import time

# Синхронная функция, которая имитирует блокирующую операцию
def blocking_function(seconds: int, name: str) -> str:
    print(f"Запуск {name}, ожидание {seconds} секунд...")
    time.sleep(seconds)
    return f"{name} завершена после {seconds} секунд"

async def main():
    # Запускаем блокирующую функцию в отдельном потоке
    result = await asyncio.to_thread(blocking_function, 2, "Первая задача")
    print(f"Результат: {result}")

    # Можно запускать несколько задач
    task1 = asyncio.to_thread(blocking_function, 1, "Вторая задача")
    task2 = asyncio.to_thread(blocking_function, 3, "Третья задача")

    results = await asyncio.gather(task1, task2)
    for result in results:
        print(f"Результат: {result}")

# Запускаем асинхронную программу
asyncio.run(main())

import asyncio
import time

def blocking_function(seconds: int):
    time.sleep(seconds)
    return f"Завершено после {seconds} секунд"

async def main():
    loop = asyncio.get_running_loop()

    # Старый подход с run_in_executor
    result = await loop.run_in_executor(None, blocking_function, 2)
    print(result)

    # Новый подход с to_thread
    result = await asyncio.to_thread(blocking_function, 2)
    print(result)

asyncio.run(main())

import asyncio
import time

async def async_function(seconds: int):
    await asyncio.sleep(seconds)
    return f"Асинхронная задача завершена после {seconds} секунд"

def sync_function(seconds: int):
    time.sleep(seconds)
    return f"Синхронная задача завершена после {seconds} секунд"

async def main():
    # Правильно: асинхронная функция запускается как задача
    task1 = asyncio.create_task(async_function(1))

    # Правильно: синхронная блокирующая функция запускается в потоке
    task2 = asyncio.to_thread(sync_function, 2)

    # НЕПРАВИЛЬНО: синхронная функция блокирует event loop
    # result = sync_function(3)

    results = await asyncio.gather(task1, task2)
    print(results)

asyncio.run(main())

import asyncio

def function_that_fails():
    raise ValueError("Что-то пошло не так!")

async def main():
    try:
        result = await asyncio.to_thread(function_that_fails)
    except ValueError as e:
        print(f"Поймано исключение: {e}")

asyncio.run(main())

import asyncio
from concurrent.futures import ThreadPoolExecutor
import time

def blocking_function(seconds: int):
    time.sleep(seconds)
    return f"Завершено после {seconds} секунд"

async def main():
    # Создаем собственный исполнитель с ограничением в 3 потока
    with ThreadPoolExecutor(max_workers=3) as executor:
        # Создаем задачи
        tasks = [
            asyncio.to_thread(blocking_function, i, executor=executor)
            for i in range(1, 6)
        ]

        # Выполняем задачи с ограничением потоков
        results = await asyncio.gather(*tasks)
        for result in results:
            print(result)

asyncio.run(main())

import asyncio
import time
from concurrent.futures import ThreadPoolExecutor

def blocking_function(id: int, seconds: int):
    print(f"Задача {id} началась")
    time.sleep(seconds)
    print(f"Задача {id} завершилась")
    return id

async def limited_concurrent_tasks(max_concurrent: int):
    # Создаем исполнитель с ограничением потоков
    with ThreadPoolExecutor(max_workers=max_concurrent) as executor:
        # Создаем 10 задач, но выполняться будут не более max_concurrent одновременно
        tasks = [
            asyncio.to_thread(blocking_function, i, 2, executor=executor)
            for i in range(10)
        ]

        results = await asyncio.gather(*tasks)
        print(f"Все задачи завершены: {results}")

asyncio.run(limited_concurrent_tasks(3))

import asyncio
import sync_database_lib  # Предполагаемая синхронная библиотека

def sync_db_query(query: str):
    # Имитация долгого запроса к базе данных
    result = sync_database_lib.execute_query(query)
    return result

async def perform_database_operations():
    queries = [
        "SELECT * FROM users",
        "SELECT * FROM orders",
        "SELECT COUNT(*) FROM products"
    ]

    # Запускаем все запросы параллельно в отдельных потоках
    tasks = [asyncio.to_thread(sync_db_query, query) for query in queries]
    results = await asyncio.gather(*tasks)

    # Обрабатываем результаты
    for query, result in zip(queries, results):
        print(f"Результат запроса '{query}': {len(result)} строк")

asyncio.run(perform_database_operations())

import asyncio
import json

def read_large_file(filename: str):
    with open(filename, 'r') as file:
        content = file.read()
    return content

def process_content(content: str):
    # Имитация обработки содержимого
    processed = json.loads(content)
    return processed

def write_result(filename: str, data):
    with open(filename, 'w') as file:
        json.dump(data, file, indent=2)

async def file_processing_pipeline(input_file: str, output_file: str):
    # Чтение файла в отдельном потоке
    content = await asyncio.to_thread(read_large_file, input_file)

    # Обработка содержимого (может быть CPU-intensive)
    processed_data = await asyncio.to_thread(process_content, content)

    # Добавляем дополнительную информацию
    processed_data['processed'] = True

    # Записываем результат в отдельном потоке
    await asyncio.to_thread(write_result, output_file, processed_data)

    print("Обработка файла завершена")

asyncio.run(file_processing_pipeline("input.json", "output.json"))

import asyncio
import requests

def sync_http_request(url: str):
    response = requests.get(url)
    return response.status_code, response.text[:100]  # Возвращаем первые 100 символов

async def fetch_multiple_urls(urls: list):
    tasks = [asyncio.to_thread(sync_http_request, url) for url in urls]
    results = await asyncio.gather(*tasks)

    for url, (status, content) in zip(urls, results):
        print(f"URL: {url}, Status: {status}, Content: {content}")

urls = [
    "https://httpbin.org/get",
    "https://api.github.com",
    "https://jsonplaceholder.typicode.com/posts/1"
]

asyncio.run(fetch_multiple_urls(urls))

import asyncio
import time
import threading
from concurrent.futures import ThreadPoolExecutor

def blocking_operation(seconds: int):
    time.sleep(seconds)
    return seconds

# 1. Последовательное выполнение
def sequential_execution():
    start = time.time()
    results = [blocking_operation(1) for _ in range(5)]
    end = time.time()
    return end - start

# 2. Потоки без asyncio
def threading_execution():
    start = time.time()
    threads = []
    results = [None] * 5

    def worker(i):
        results[i] = blocking_operation(1)

    for i in range(5):
        thread = threading.Thread(target=worker, args=(i,))
        thread.start()
        threads.append(thread)

    for thread in threads:
        thread.join()

    end = time.time()
    return end - start

# 3. Использование to_thread
async def asyncio_execution():
    start = time.time()
    tasks = [asyncio.to_thread(blocking_operation, 1) for _ in range(5)]
    results = await asyncio.gather(*tasks)
    end = time.time()
    return end - start

# Сравниваем все подходы
print(f"Последовательное выполнение: {sequential_execution():.2f} сек")
print(f"Потоки без asyncio: {threading_execution():.2f} сек")

asyncio_time = asyncio.run(asyncio_execution())
print(f"Asyncio to_thread: {asyncio_time:.2f} сек")