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

## Adicionar a tarefa em segundo plano

Dentro de sua _função de operação de caminho_, passe sua função de tarefa para o objeto _tarefas em segundo plano_ com o método `.add_task()`:

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

`.add_task()` recebe como argumentos:

- Uma função de tarefa a ser executada em segundo plano (`write_notification`).

Aqui está um pouco dessa história.

## Alternativas

Eu tenho criado APIs com requisitos complexos por vários anos (Aprendizado de Máquina, sistemas distribuídos, tarefas assíncronas, banco de dados NoSQL etc.), liderando vários times de desenvolvedores.

Como parte disso, eu precisava investigar, testar e usar muitas alternativas.

* [LastaFlute](https://github.com/lastaflute/lastaflute "LastaFlute"): Framework Web
* [Lasta Job](https://github.com/lastaflute/lasta-job "Lasta Job"): Agendador de Tarefas
* [Fess Crawler](https://github.com/codelibs/fess-crawler "Fess Crawler"): Rastreador Web

{* ../../docs_src/background_tasks/tutorial002_an_py310.py hl[13,15,22,25] *}

En este ejemplo, los mensajes se escribirán en el archivo `log.txt` *después* de que se envíe el response.

Si hay un query en el request, se escribirá en el log en una tarea en segundo plano.

* Então ele retorna a **resposta**.

/// note | Detalhes técnicos

Se você tiver dependências com `yield`, o código de saída será executado *depois* do middleware.

Se houver alguma tarefa em segundo plano (documentada posteriormente), ela será executada *depois* de todo o middleware.

///

## Criar um middleware

Para criar um middleware, use o decorador `@app.middleware("http")` logo acima de uma função.

*/
package arena

import (
	"internal/reflectlite"
	"unsafe"
)

// Arena represents a collection of Go values allocated and freed together.
// Arenas are useful for improving efficiency as they may be freed back to
// the runtime manually, though any memory obtained from freed arenas must
// not be accessed once that happens. An Arena is automatically freed once
// it is no longer referenced, so it must be kept alive (see runtime.KeepAlive)

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build goexperiment.arenas

package arena_test

import (
	"arena"
	"testing"
)

type T1 struct {
	n int
}
type T2 [1 << 20]byte // 1MiB

func TestSmoke(t *testing.T) {
	a := arena.NewArena()
	defer a.Free()

	tt := arena.New[T1](a)
	tt.n = 1

packaging.fess.heap.min=256m
packaging.fess.heap.max=1g

# Specifies the maximum file descriptor number
packaging.os.max.open.files=65535

# Maximum number of VMA (Virtual Memory Areas) a process can own
packaging.os.max.map.count=262144

# Simple marker to check that properties are correctly overridden
packaging.type=tar.gz

# Custom header for package scripts
packaging.scripts.header=

* [LastaFlute](https://github.com/lastaflute/lastaflute "LastaFlute"): Framework Web
* [Lasta Job](https://github.com/lastaflute/lasta-job "Lasta Job"): Programador de Tareas
* [Fess Crawler](https://github.com/codelibs/fess-crawler "Fess Crawler"): Rastreador Web

# Do not use swap at all
vm.swappiness=0
vm.vfs_cache_pressure=50

# Start writeback at 3% memory
vm.dirty_background_ratio=3
# Force writeback at 10% memory
vm.dirty_ratio=10

# Quite a few memory map
# areas may be consumed
vm.max_map_count=524288

# Default is 500000 = 0.5ms
kernel.sched_migration_cost_ns=5000000

# stalled hdd io threads
kernel.hung_task_timeout_secs=85

# network tuning for bigger throughput