`check_same_thread=False` kullanmak, FastAPI’nin aynı SQLite veritabanını farklı thread’lerde kullanmasına izin verir. Bu gereklidir; çünkü **tek bir request** **birden fazla thread** kullanabilir (örneğin dependency’lerde).

Merak etmeyin; kodun yapısı gereği, ileride **her request için tek bir SQLModel *session*** kullandığımızdan emin olacağız. Zaten `check_same_thread` de temelde bunu mümkün kılmaya çalışır.

labels.queryId=ID da consulta
labels.rt=rt
labels.searchLog=Log de pesquisa
labels.sort=Ordenar
labels.start=Posição inicial
labels.loginRequired=Requer login
labels.loginLink=Mostrar link de login
labels.threadName=Nome da thread
labels.url=URL
labels.userFavorite=Log de favoritos
labels.userInfo=Informações do usuário
labels.webApiJson=Resposta JSON
labels.webConfigName=Nome da configuração de rastreamento da web

Die Verwendung von `check_same_thread=False` erlaubt FastAPI, dieselbe SQLite-Datenbank in verschiedenen Threads zu verwenden. Dies ist notwendig, da **ein einzelner <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr>** **mehr als einen Thread** verwenden könnte (zum Beispiel in Abhängigkeiten).

   * specified {@link MoreExecutors#directExecutor()}, those objects will be closed synchronously.
   *
   * @param mayInterruptIfRunning {@code true} if the thread executing this task should be
   *     interrupted; otherwise, in-progress tasks are allowed to complete, but the step will be
   *     cancelled regardless

        `MirroredStrategy.run` or `ReplicaContext.merge_call`. This is because a
        thread local variable is used to determine whether `AutoCastVariable`s
        are casted, and those two functions run with a different thread. Note
        this only applies if one of these two functions is called within
        `Layer.call`; if one of those two functions calls `Layer.call`,

      }

      OverrideParam.ReadTimeout -> {
        client =
          client
            .newBuilder()
            .socketFactory(
              DelayingSocketFactory(onRead = {
                Thread.sleep(100L)
              }),
            ).build()

        overrideBadImplementation(override = override.override, testItFails = testItFails)
      }

      OverrideParam.ConnectTimeout -> {

    val inputStream = response.body.byteStream()
    assertThat(inputStream.read().toChar()).isEqualTo('A')
    call.cancel()
    assertFailsWith<IOException> {
      // Reading 'B' may succeed if it's buffered.
      inputStream.read()

      // But 'C' shouldn't be buffered (the response is throttled) and this should fail.
      inputStream.read()
    }
    inputStream.close()
  }

  @Test

{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[14:18] hl[14:15,17:18] *}

L'utilisation de `check_same_thread=False` permet à FastAPI d'utiliser la même base SQLite dans différents threads. C'est nécessaire car **une seule requête** peut utiliser **plus d'un thread** (par exemple dans des dépendances).

### Outras funções de utilidade { #other-utility-functions }

    failover.handleFailure(channel, error);
    
    // Verify channel marked as failed
    assertEquals(ChannelState.FAILED, channel.getState());
    
    // Verify recovery attempted
    Thread.sleep(2000);
    assertTrue(channel.getState() == ChannelState.ESTABLISHED 
        || manager.getChannels().isEmpty());
}
```

### 7.2 Integration Tests
```java
@Test