return handles.size();
    }

    private void periodicMaintenance() {
        if (shutdown) {
            return;
        }

        lock.writeLock().lock();
        try {
            // Clean up expired handles
            handles.entrySet().removeIf(entry -> {
                HandleInfo info = entry.getValue();
                if (info.isExpired() && !info.isReconnecting()) {

This can be very useful for setting up **resources** that you need to use for the whole app, and that are **shared** among requests, and/or that you need to **clean up** afterwards. For example, a database connection pool, or loading a shared machine learning model.

## Use Case { #use-case }

Let's start with an example **use case** and then see how to solve it with this.

        gitExtension.setBwcBranch(versionInfoProvider.map(info -> info.branch));
        gitExtension.getCheckoutDir().set(checkoutDir);

        // we want basic lifecycle tasks like `clean` here.
        project.getPlugins().apply(LifecycleBasePlugin.class);

        TaskProvider<Task> buildBwcTaskProvider = project.getTasks().register("buildBwc");

- Java 17+
- Maven 3.9.0 or later
- Run Maven, specifying a location into which the completed Maven distro should be installed:
    ```
    mvn -DdistributionTargetDir="$HOME/app/maven/apache-maven-4.1.x-SNAPSHOT" clean package
    ```


[home]: https://maven.apache.org/
[license]: https://www.apache.org/licenses/LICENSE-2.0
[build]: https://ci-maven.apache.org/job/Maven/job/maven-box/job/maven/job/master/

```Python hl_lines="1"
async def get_burgers(number: int):
    # Hacer algunas cosas asíncronas para crear las hamburguesas
    return burgers
```

...en lugar de `def`:

```Python hl_lines="2"
# Esto no es asíncrono
def get_sequential_burgers(number: int):
    # Hacer algunas cosas secuenciales para crear las hamburguesas
    return burgers
```

        with:
          distribution: 'temurin'
          java-version: 21

      - name: Setup Gradle
        uses: gradle/actions/setup-gradle@v5

      - name: Upload Artifacts
        run: ./gradlew clean publish --stacktrace
        env:
          ORG_GRADLE_PROJECT_mavenCentralUsername: ${{ secrets.SONATYPE_CENTRAL_USERNAME }}
          ORG_GRADLE_PROJECT_mavenCentralPassword: ${{ secrets.SONATYPE_CENTRAL_PASSWORD }}

        action = new AdminDesignAction();
        tempDir = Files.createTempDirectory("fess_test");
    }

    @Override
    protected void tearDown(TestInfo testInfo) throws Exception {
        // Clean up temp directory
        if (tempDir != null) {
            deleteRecursively(tempDir.toFile());
        }
        super.tearDown(testInfo);
    }

    private void deleteRecursively(File file) {

        runner.ensureYellow();
    }

    @AfterClass
    public static void afterClass() throws Exception {
        if (runner != null) {
            runner.close();
            runner.clean();
        }
    }

    @Before
    public void before() throws Exception {
        runner.admin().indices().prepareDelete("_all").execute().actionGet();
        runner.refresh();

Pero todavía es parte de la misma aplicación/web API de **FastAPI** (es parte del mismo "paquete de Python").

Puedes crear las *path operations* para ese módulo usando `APIRouter`.

### Importar `APIRouter` { #import-apirouter }

Lo importas y creas una "instance" de la misma manera que lo harías con la clase `FastAPI`:

		}

		if err := tx.Find(reflectResults.Addr().Interface()).Error; err != nil {
			return err
		}
	}

	fieldValues := make([]interface{}, len(relForeignFields))

	// clean up old values before preloading
	switch reflectValue.Kind() {
	case reflect.Struct:
		switch rel.Type {
		case schema.HasMany, schema.Many2Many: