@RestController
@RequestMapping("/api/users")
@RequiredArgsConstructor
public class UserController {
 
    private final UserService userService;
 
    @GetMapping
    public ResponseEntity<UserResponse> getUsers() {
        // 스레드 A가 할당받아 작업을 처리합니다.
        UserResonse response = userService.getUsers();
        // 10번 줄의 작업이 완료된 이후에 12번 줄의 작업이 진행됩니다. 이것이 "동기"입니다.
        return ResponseEntity.ok(response);
    }
}

@Service
@RequiredArgsConstructor
public class UserService {
 
    private final UserRepository userRepository;
 
    public UserResponse getUsers() {
        // 10번 줄에서 DB I/O 작업이 시작되고 I/O 작업이 완료될 때까지
        // 스레드 A는 Blocked 상태로 변경되어 대기합니다. 이것이 "블로킹"입니다.
        List<User> users = userRepository.findAll();
        return UserResponse.from(users);
    }
}

[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    private readonly IUserService _userService;
 
    public UsersController(IUserService userService)
    {
        _userService = userService;
    }
 
    [HttpGet]
    public async Task<ActionResult<UserResponse>> GetUsersAsync()
    {
        // 스레드 A가 할당받아 작업을 처리합니다.
        UserResponse response = await _userService.GetUsersAsync();
        /*
        _userService.GetUsersAsync는 비동기입니다.
        작업의 완료를 기다리지 않고 즉시 Task를 반환하기 때문입니다.
        하지만 await 키워드가 동시에 사용되었기 때문에
        16번 줄의 작업이 완료된 이후에 22번 줄의 작업이 진행됩니다.
        하지만 이것은 완전히 "동기"라고 표현하기보다는 동기적인 코드 흐름이라고 표현할 수 있습니다.
        여전히 내부적으로는 완전히 비동기/논블로킹이기 때문입니다.
        */
        return Ok(response);
    }
}

public class UserService : IUserService
{
    private readonly IUserRepository _userRepository;
 
    public UserService(IUserRepository userRepository)
    {
        _userRepository = userRepository;
    }
 
    public async Task<UserResponse> GetUsersAsync()
    {
        // DB 조회 요청을 시작함과 동시에 await 키워드를 만나
        // 스레드 A는 대기하지 않고 즉시 스레드 풀에 반납됩니다. 이것이 "논블로킹"입니다.
        List<User> users = await _userRepository.GetAllUsersAsync();
        // DB 조회 작업이 완료되면 스레드 풀에서 새로운 스레드를 할당받아 이후 작업을 진행합니다.
        return UserResponse.From(users);
    }
}

public class UserService : IUserService
{
    private readonly IUserRepository _userRepository;
 
    public UserService(IUserRepository userRepository)
    {
        _userRepository = userRepository;
    }
 
    public async Task<UserResponse> GetUsersAsync()
    {
        /*
        DB 조회 요청을 보낸 뒤 I/O 작업이 완료되면 결과를 반환받을 것을 약속(Task) 받습니다.
        이때 작업이 완료되는 것을 기다리지 않고 바로 다음 PerformSomeCpuIntensiveWork()을 진행합니다.
        이것이 "비동기"입니다.
        */
        Task<List<User>> usersTask = _userRepository.GetAllUsersAsync();
 
        PerformSomeCpuIntensiveWork(); // CPU 집약 작업
 
        /*
        await 키워드를 만나는 순간 아직 DB I/O 작업이 완료되지 않았다면,
        스레드 A는 Blocked 상태로 변경되지 않고 즉시 스레드 풀에 반납됩니다.
        이것이 "논블로킹"입니다.
        하지만 만약 DB I/O 작업이 완료된 상태라면,
        스레드 A는 스레드 풀에 반환되지 않고 이어서 다음 작업을 진행합니다.
        이 경우도 마찬가지로 "논블로킹"입니다.
        */
        List<User> users = await usersTask;
        return UserResponse.From(users);
    }
}