new LineProcessor<List<String>>() {
          final List<String> collector = new ArrayList<>();

          @Override
          public boolean processLine(String line) {
            collector.add(whitespace().trimFrom(line));
            return true;
          }

          @Override
          public List<String> getResult() {
            return collector;
          }
        };

        List<MavenProject> filtered = new ArrayList<>(projects.size());
        for (MavenProject project : projects) {
            if (whiteList.containsKey(project)) {
                filtered.add(project);
            } else if (!transitive) {
                filtered.addAll(upstream ? getUpstreamProjects(project, false) : getDownstreamProjects(project, false));
            }
        }

E como a operação de escrita não usa `async` e `await`, definimos a função com um `def` normal:

{* ../../docs_src/background_tasks/tutorial001_py310.py hl[6:9] *}

## Adicione a tarefa em segundo plano { #add-the-background-task }

Dentro da sua *função de operação de rota*, passe sua função de tarefa para o objeto de *tarefas em segundo plano* com o método `.add_task()`:

            final URL url = it.next();
            final Traverser resourcesType = getTraverser(url, rootPackage, baseName);
            if (resourcesType != null) {
                list.add(resourcesType);
            }
        }
        if (list.isEmpty()) {
            logger.log("WCL0014", rootPackage);
            return EMPTY_ARRAY;
        }

                final String basePath = System.getProperty(prop);
                if (basePath != null) {
                    final String baseCanonicalPath = new File(basePath).getCanonicalPath();
                    allowedPaths.add(baseCanonicalPath);
                    if (canonicalPath.startsWith(baseCanonicalPath)) {
                        isAllowed = true;
                        break;
                    }
                }
            }

        List<String> out = new ArrayList<>();
        for (String line : lines) {
            String s = line.replace("*", "").trim();
            if (!s.isEmpty()) {
                out.add(s);
            }
        }
        return out;
    }

    private static List<String> parentCommitsOf(String commit) throws IOException, InterruptedException, ExecutionException {

                        long startTime = System.nanoTime();
                        boolean result = correctAuth.equals(wrongAuth);
                        long endTime = System.nanoTime();
                        timings.add(endTime - startTime);
                        assertFalse(result, "Passwords should not be equal");
                    }
                });
            }

            executor.shutdown();

이 경우 작업 함수는 파일에 쓰기를 수행합니다(이메일 전송을 시뮬레이션).

그리고 쓰기 작업은 `async`와 `await`를 사용하지 않으므로, 일반 `def`로 함수를 정의합니다:

{* ../../docs_src/background_tasks/tutorial001_py310.py hl[6:9] *}

## 백그라운드 작업 추가 { #add-the-background-task }

*경로 처리 함수* 내부에서 `.add_task()` 메서드로 작업 함수를 *백그라운드 작업* 객체에 전달합니다:

{* ../../docs_src/background_tasks/tutorial001_py310.py hl[14] *}

`.add_task()`는 다음 인자를 받습니다:

   */
  public static List<Throwable> getCausalChain(Throwable throwable) {
    checkNotNull(throwable);
    List<Throwable> causes = new ArrayList<>(4);
    causes.add(throwable);

    // Keep a second pointer that slowly walks the causal chain. If the fast pointer ever catches
    // the slower pointer, then there's a loop.
    Throwable slowPointer = throwable;

    if (b == -1) {
      return bytes;
    }

    // the stream was longer, so read the rest normally
    Queue<byte[]> bufs = new ArrayDeque<>(TO_BYTE_ARRAY_DEQUE_SIZE + 2);
    bufs.add(bytes);
    bufs.add(new byte[] {(byte) b});
    return toByteArrayInternal(in, bufs, bytes.length + 1);
  }

  /**
   * Reads and discards data from the given {@code InputStream} until the end of the stream is