asyncWriters <- struct{}{}
			bufp := xioutil.ODirectPoolMedium.Get()
			b := (*bufp)[:header.Size]
			if _, err := io.ReadFull(tarReader, b); err != nil {
				return err
			}
			wg.Add(1)
			go func(name string, fi fs.FileInfo, b []byte) {
				rc := disconnectReader{r: bytes.NewReader(b)}
				defer func() {
					rc.Close()
					<-asyncWriters
					wg.Done()

                    }

                    if (exceptionList == null) {
                        exceptionList = new ArrayList<>();
                    }
                    exceptionList.add(e);
                }

                ThreadUtil.sleep(retryInterval);
                count++;
            }
            final String message = "Failed to access to " + request.getUrl()

    var insertAt = futureTasks.indexOfFirst { it.nextExecuteNanoTime - now > delayNanos }
    if (insertAt == -1) insertAt = futureTasks.size
    futureTasks.add(insertAt, task)

    // Impact the coordinator if we inserted at the front.
    return insertAt == 0
  }

  /**
   * Schedules immediate execution of [Task.tryCancel] on all currently-enqueued tasks. These calls

      MutableCell<R, C, V> oldCell = table.get(row, column);
      if (oldCell == null) {
        MutableCell<R, C, V> cell = new MutableCell<>(row, column, value);
        insertionOrder.add(cell);
        table.put(row, column, cell);
      } else {
        oldCell.merge(value, merger);
      }
    }

    /*

                try {
                    popularWordsRequestBuilder.execute().getResponse().getItems().stream().forEach(item -> wordList.add(item.getText()));
                } catch (final SuggesterException e) {
                    logger.warn("Failed to generate popular words.", e);
                }

                return wordList;
            });

Und da der Schreibvorgang nicht `async` und `await` verwendet, definieren wir die Funktion mit normalem `def`:

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

## Den Hintergrundtask hinzufügen { #add-the-background-task }

Übergeben Sie innerhalb Ihrer *Pfadoperation-Funktion* Ihre Taskfunktion mit der Methode `.add_task()` an das *Hintergrundtasks*-Objekt:

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

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

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

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

			// Otherwise, we risk the decoder hanging.
		}
		r.readerWg.Done()
	}

	// We cannot reuse as we are sending parsed objects elsewhere.
	simdjson.ParseNDStream(readCloser, r.input, nil)
	r.readerWg.Add(1)
	go r.startReader()
	return &r
}

// NewElementReader - creates new JSON reader using readCloser.
func NewElementReader(ch chan simdjson.Object, err *error, args *json.ReaderArgs) *Reader {
	return &Reader{

      HashFunction first, HashFunction second, HashFunction... rest) {
    // We can't use Lists.asList() here because there's no hash->collect dependency
    List<HashFunction> list = new ArrayList<>();
    list.add(first);
    list.add(second);
    Collections.addAll(list, rest);
    return new ConcatenatedHashFunction(list.toArray(new HashFunction[0]));
  }

  /**

        assertObjectNotNull("builder", builder);
        if (aggregationAggregationBuilderList == null) {
            aggregationAggregationBuilderList = new ArrayList<>();
        }
        aggregationAggregationBuilderList.add(builder);
    }

    // ===================================================================================
    //                                                                 Invalid Aggregation