LockEnabled: true,
	}

	expiryWorker := func(wg *sync.WaitGroup, readyCh chan<- struct{}, taskCh <-chan expiryOp, gotExpired *[]ObjectToDelete) {
		defer wg.Done()
		// signal the calling goroutine that the worker is ready tor receive tasks
		close(readyCh)
		var expired []ObjectToDelete
		for t := range taskCh {
			switch v := t.(type) {
			case noncurrentVersionsTask:
				expired = append(expired, v.versions...)

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

## Add the background task { #add-the-background-task }

Inside of your *path operation function*, pass your task function to the *background tasks* object with the method `.add_task()`:

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

`.add_task()` receives as arguments:

* A task function to be run in the background (`write_notification`).

 * decide not to by returning -1L.
 *
 * Task Queues
 * -----------
 *
 * Tasks are bound to the [TaskQueue] they are scheduled in. Each queue is sequential and the tasks
 * within it never execute concurrently. It is an error to use a task in multiple queues.
 */
abstract class Task(
  val name: String,
  val cancelable: Boolean = true,
) {
  // Guarded by the TaskRunner.
  internal var queue: TaskQueue? = null

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

## Agregar la tarea en segundo plano { #add-the-background-task }

Dentro de tu *path operation function*, pasa tu función de tarea al objeto de *background tasks* con el método `.add_task()`:

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

`.add_task()` recibe como argumentos:

# Hintergrundtasks { #background-tasks }

Sie können <abbr title="Hintergrund-Aufgaben">Hintergrundtasks</abbr> definieren, die *nach* der Rückgabe einer <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> ausgeführt werden sollen.

# Фоновые задачи { #background-tasks }

Вы можете создавать фоновые задачи, которые будут выполняться после возврата ответа.

Это полезно для операций, которые должны произойти после HTTP-запроса, но клиенту не обязательно ждать их завершения, чтобы получить ответ.

Например:

* Уведомления по электронной почте, отправляемые после выполнения действия:

# Tarefas em segundo plano { #background-tasks }

Você pode definir tarefas em segundo plano para serem executadas *após* retornar uma resposta.

Isso é útil para operações que precisam acontecer após uma request, mas que o cliente não precisa realmente esperar a operação terminar antes de receber a resposta.

Isso inclui, por exemplo:

* Notificações por e-mail enviadas após realizar uma ação:

    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o instanceof Task task) {
            return Objects.equals(getClass(), task.getClass()) && Objects.equals(value, task.value);
        } else {
            return false;
        }
    }

    @Override
    public int hashCode() {
        return Objects.hash(getClass(), value);

    AfterOtherTasks,
  }

  /** Returns the task that was started, or null if there were no tasks to start. */
  private fun startNextTask(): SerialTask? {
    taskRunner.assertLockHeld()

    val index = serialTaskQueue.indexOfFirst { it.isReady() }
    if (index == -1) return null

    val nextTask = serialTaskQueue.removeAt(index)
    currentTask = nextTask

 * cancelled).
 *
 * <p>This class serializes execution of <i>submitted</i> tasks but not any <i>listeners</i> of
 * those tasks.
 *
 * <p>Submitted tasks have a happens-before order as defined in the Java Language Specification.
 * Tasks execute with the same happens-before order that the function calls to {@link #submit} and
 * {@link #submitAsync} that submitted those tasks had.
 *