async 와 await 는 구문 설탕입니다. 비동기 및 대기의 본질은 상태 머신입니다. 컴파일러는 async / await 코드를 상태 머신으로 변환합니다.

동시에 실제 프로젝트에서 async / await를 실제로 구현하려면 이미 많은 비동기 I / O 라이브러리 함수 가 있어야합니다 . C #의 경우 대부분의 원래 동기화 된 I / O 기능에는 대체 비동기 버전이 있습니다. 이러한 비동기 함수가 필요한 이유는 대부분의 경우 자체 비동기 / 대기 코드가 일부 라이브러리 비동기 메소드로 요약되기 때문입니다.

C #의 비동기 버전 라이브러리 함수는 Java의 AsynchronousChannel 개념과 비슷합니다. 예를 들어, 읽기 작업이 완료된 후 Future를 반환하거나 콜백을 실행할 수있는 AsynchronousFileChannel.read가 있습니다. 그러나 정확히 동일하지는 않습니다. 모든 C # 비동기 함수는 작업을 반환합니다 (미래와 비슷하지만 미래보다 더 강력 함).

Java가 async / await를 지원한다고 가정하면 다음과 같은 코드를 작성합니다.

public static async Future<Byte> readFirstByteAsync(String filePath) {
    Path path = Paths.get(filePath);
    AsynchronousFileChannel channel = AsynchronousFileChannel.open(path);

    ByteBuffer buffer = ByteBuffer.allocate(100_000);
    await channel.read(buffer, 0, buffer, this);
    return buffer.get(0);
}

그런 다음 컴파일러가 원래 async / await 코드를 다음과 같이 변환한다고 상상할 수 있습니다.

public static Future<Byte> readFirstByteAsync(String filePath) {

    CompletableFuture<Byte> result = new CompletableFuture<Byte>();

    AsyncHandler ah = new AsyncHandler(result, filePath);

    ah.completed(null, null);

    return result;
}

다음은 AsyncHandler의 구현입니다.

class AsyncHandler implements CompletionHandler<Integer, ByteBuffer>
{
    CompletableFuture<Byte> future;
    int state;
    String filePath;

    public AsyncHandler(CompletableFuture<Byte> future, String filePath)
    {
        this.future = future;
        this.state = 0;
        this.filePath = filePath;
    }

    @Override
    public void completed(Integer arg0, ByteBuffer arg1) {
        try {
            if (state == 0) {
                state = 1;
                Path path = Paths.get(filePath);
                AsynchronousFileChannel channel = AsynchronousFileChannel.open(path);

                ByteBuffer buffer = ByteBuffer.allocate(100_000);
                channel.read(buffer, 0, buffer, this);
                return;
            } else {
                Byte ret = arg1.get(0);
                future.complete(ret);
            }

        } catch (Exception e) {
            future.completeExceptionally(e);
        }
    }

    @Override
    public void failed(Throwable arg0, ByteBuffer arg1) {
        future.completeExceptionally(arg0);
    }
}

답변

public class AsyncAwaitNioFileChannelDemo {

public static void main(final String[] argv) throws Exception {

    ...
    final AsyncAwaitNioFileChannelDemo demo = new AsyncAwaitNioFileChannelDemo();
    final CompletionStage<String> result = demo.processFile("./.project");
    System.out.println("Returned to caller " + LocalTime.now());
    ...
}


public @async CompletionStage<String> processFile(final String fileName) throws IOException {
    final Path path = Paths.get(new File(fileName).toURI());
    try (
            final AsyncFileChannel file = new AsyncFileChannel(
                path, Collections.singleton(StandardOpenOption.READ), null
            );
            final FileLock lock = await(file.lockAll(true))
        ) {

        System.out.println("In process, shared lock: " + lock);
        final ByteBuffer buffer = ByteBuffer.allocateDirect((int)file.size());

        await( file.read(buffer, 0L) );
        System.out.println("In process, bytes read: " + buffer);
        buffer.rewind();

        final String result = processBytes(buffer);

        return asyncResult(result);

    } catch (final IOException ex) {
        ex.printStackTrace(System.out);
        throw ex;
    }
}