assertFalse(listenableFuture.isDone());

    listenableFuture.addListener(singleCallListener, directExecutor());
    /*
     * Don't shut down until the listenInPoolThread task has been accepted to
     * run. We want to see what happens when it's interrupted, not when it's
     * rejected.
     */
    submitSuccessful.await();
    executorService.shutdownNow();
    abstractFuture.set(DATA1);

예를 들면 다음과 같습니다.

* 작업을 수행한 후 전송되는 이메일 알림:
    * 이메일 서버에 연결하고 이메일을 전송하는 것은 (몇 초 정도) "느린" 경향이 있으므로, 응답은 즉시 반환하고 이메일 알림은 백그라운드에서 전송할 수 있습니다.
* 데이터 처리:
    * 예를 들어 처리에 오랜 시간이 걸리는 프로세스를 거쳐야 하는 파일을 받았다면, "Accepted"(HTTP 202) 응답을 반환하고 백그라운드에서 파일을 처리할 수 있습니다.

## `BackgroundTasks` 사용 { #using-backgroundtasks }

먼저 `BackgroundTasks`를 임포트하고, `BackgroundTasks` 타입 선언으로 *경로 처리 함수*에 매개변수를 정의합니다:

            logger.debug("url={}", url);
        }
        try (CurlResponse response = Curl.get(url)
                .header("Authorization", "Bearer " + user.getAuthenticationResult().accessToken())
                .header("Accept", "application/json")
                .execute()) {
            final Map<String, Object> contentMap = response.getContent(OpenSearchCurl.jsonParser());
            if (logger.isDebugEnabled()) {

* Processing data:
    * For example, let's say you receive a file that must go through a slow process, you can return a response of "Accepted" (HTTP 202) and process the file in the background.

## Using `BackgroundTasks` { #using-backgroundtasks }

            final int bufferSize, final Consumer<String> outputCallback) {
        final ProcessBuilder pb = new ProcessBuilder(cmdList);
        pbCall.accept(pb);

        // Remove and destroy any existing process for this session
        final JobProcess oldProcess = runningProcessMap.remove(sessionId);
        if (oldProcess != null) {

            if (commandLineArgsMatcher.find() && pidMatcher.find()) {
                String pid = pidMatcher.group(1);
                if (!MY_PID.equals(pid)) {
                    action.accept(pid, line);
                }
            }
        });
    }

    private static List<String> ps() {
        return run(determinePsCommand()).assertZeroExit().stdout.lines().collect(Collectors.toList());

              parameterTypes.length);

          checkArgument(
              !parameterTypes[0].isPrimitive(),
              "@Subscribe method %s's parameter is %s. "
                  + "Subscriber methods cannot accept primitives. "
                  + "Consider changing the parameter to %s.",
              method,
              parameterTypes[0].getName(),
              Primitives.wrap(parameterTypes[0]).getSimpleName());

        byte[] storedFileId = (byte[]) fileIdField.get(request);
        assertArrayEquals(testFileId, storedFileId);
    }

    @Test
    @DisplayName("Constructor with null file ID should accept null")
    void testConstructorWithNullFileId() {
        // Should not throw exception
        Smb2FlushRequest requestWithNull = new Smb2FlushRequest(mockConfig, null);
        assertNotNull(requestWithNull);
    }

        // When pointer is 0, the string should be null
        PacUnicodeString unicodeString = new PacUnicodeString((short) 0, (short) 0, 0);

        // check() expects null when pointer is 0 but doesn't accept empty string
        assertThrows(PACDecodingException.class, () -> {
            unicodeString.check("");
        });

        // The implementation has a bug - it doesn't handle null properly

///

### `Response` { #response }

The main `Response` class, all the other responses inherit from it.

You can return it directly.

It accepts the following parameters:

* `content` - A `str` or `bytes`.
* `status_code` - An `int` HTTP status code.
* `headers` - A `dict` of strings.
* `media_type` - A `str` giving the media type. E.g. `"text/html"`.