Async를 언어별로 비교하기

import kotlinx.coroutines.*

fun main() = runBlocking {
    // launch — 결과 없이 백그라운드 실행
    val job = launch {
        delay(100)
        println("launch 완료")
    }

    // async — 결과를 Deferred로 반환
    val deferred1 = async { fetchUser(1) }
    val deferred2 = async { fetchUser(2) }

    // await() — 결과 대기
    val user1 = deferred1.await()
    val user2 = deferred2.await()
    println("$user1, $user2")

    // awaitAll — 여러 Deferred 동시 대기
    val results = awaitAll(
        async { fetchUser(3) },
        async { fetchUser(4) },
    )
    println(results)

    job.join()  // launch 완료 대기
    println("모두 완료")
}

suspend fun fetchUser(id: Int): String {
    delay(50)  // 네트워크 시뮬레이션 (스레드 차단 없음)
    return "User#$id"
}

import asyncio
import time

# 기본 코루틴
async def fetch_data(url: str, delay: float) -> str:
    print(f"시작: {url}")
    await asyncio.sleep(delay)   # 비차단 대기
    print(f"완료: {url}")
    return f"data:{url}"

# asyncio.gather — 병렬 실행
async def main_parallel():
    start = time.perf_counter()

    results = await asyncio.gather(
        fetch_data("url1", 1.0),
        fetch_data("url2", 1.5),
        fetch_data("url3", 0.5),
    )

    elapsed = time.perf_counter() - start
    print(f"총 소요: {elapsed:.2f}초")   # ~1.5초 (병렬)
    print(results)

# asyncio.create_task — 태스크 생성
async def main_tasks():
    task1 = asyncio.create_task(fetch_data("a", 1.0))
    task2 = asyncio.create_task(fetch_data("b", 0.5))

    # 여기서 다른 작업 가능
    print("태스크 생성 후 바로 실행 가능")

    r1 = await task1
    r2 = await task2
    return r1, r2

# 타임아웃
async def with_timeout():
    try:
        result = await asyncio.wait_for(
            fetch_data("slow", 5.0),
            timeout=2.0
        )
    except asyncio.TimeoutError:
        print("타임아웃!")

asyncio.run(main_parallel())

<span class="cm">// fuzzing 테스트 (Go 1.18+) 예제
// data/prompts.js의 생성 프롬프트로 상세 코드 생성 가능</span>
fun main() { println("fuzzing 테스트 (Go 1.18+)") }

import java.util.concurrent.*;
import java.util.List;

public class AsyncDemo {

    static CompletableFuture<String> fetchUser(int id) {
        return CompletableFuture.supplyAsync(() -> {
            sleep(100);
            return "User#" + id;
        });
    }

    static CompletableFuture<String> fetchOrders(String userId) {
        return CompletableFuture.supplyAsync(() -> {
            sleep(100);
            return "Orders of " + userId;
        });
    }

    public static void main(String[] args) throws Exception {
        // thenApply — 변환 (Function)
        CompletableFuture<String> upper = fetchUser(1)
            .thenApply(String::toUpperCase);

        // thenAccept — 소비 (Consumer)
        fetchUser(1).thenAccept(u ->
            System.out.println("받음: " + u));

        // thenCompose — 플랫맵 (다른 CF 반환)
        CompletableFuture<String> orders = fetchUser(1)
            .thenCompose(AsyncDemo::fetchOrders);

        // thenCombine — 두 CF 결과 합치기
        CompletableFuture<String> combined =
            fetchUser(1).thenCombine(fetchUser(2),
                (u1, u2) -> u1 + " & " + u2);

        // allOf — 모두 완료 대기
        CompletableFuture<Void> all = CompletableFuture.allOf(
            fetchUser(1), fetchUser(2), fetchUser(3));
        all.join();

        // anyOf — 가장 빠른 것
        CompletableFuture<Object> any = CompletableFuture.anyOf(
            fetchUser(1), fetchUser(2));

        // 예외 처리
        CompletableFuture<String> safe = fetchUser(-1)
            .exceptionally(ex -> "기본 사용자")
            .handle((result, ex) -> {
                if (ex != null) return "에러: " + ex.getMessage();
                return result;
            });

        System.out.println(orders.get());
        System.out.println(combined.get());
        System.out.println(safe.get());
    }

    static void sleep(long ms) {
        try { Thread.sleep(ms); } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

// 비동기 함수 시작
async function run() {
  const value = await Promise.resolve(1);
  console.log(value);
}
run();

// 비동기 함수 시작
async function run(): Promise<void> {
  const value = await Promise.resolve(1);
  console.log(value);
}
run();

// 비동기 함수 시작
using System;
using System.Threading.Tasks;

var value = await Task.FromResult(1);
Console.WriteLine(value);

// 비동기 함수 시작
#include <future>
#include <iostream>

int main() {
    auto job = std::async(std::launch::async, [] { return 1; });
    std::cout << job.get() << "\n";
}

// 비동기 함수 시작
use std::thread;
fn main() {
    let handle = thread::spawn(|| 1);
    println!("{}", handle.join().unwrap());
}