* is intended solely to help find problems during development.
 *
 * <p>The EventBus guarantees that it will not call a subscriber method from multiple threads
 * simultaneously, unless the method explicitly allows it by bearing the {@link
 * AllowConcurrentEvents} annotation. If this annotation is not present, subscriber methods need not

    var ms = nanos / 1_000_000L
    val ns = nanos - (ms * 1_000_000L)

    while (ms > 100) {
      Thread.sleep(100)
      if (javaNetSocket.isClosed) throw InterruptedIOException("socket closed")
      ms -= 100L
    }

    if (ms > 0L || ns > 0) {
      Thread.sleep(ms, ns.toInt())
    }
  }

  override fun cancel() {
    delegate.cancel()
  }

  override fun close() {

@J2ktIncompatible
@GwtIncompatible
public interface FinalizableReference {
  /**
   * Invoked on a background thread after the referent has been garbage collected unless security
   * restrictions prevented starting a background thread, in which case this method is invoked when
   * new references are created.
   */
  void finalizeReferent();

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

Usar `check_same_thread=False` permite que o FastAPI use o mesmo banco de dados SQLite em diferentes threads. Isso é necessário, pois **uma única requisição** pode usar **mais de uma thread** (por exemplo, em dependências).

    public void testSwitchIndex_unexpectedUpdateIndicesCount() throws Exception {
        final Suggester suggester = Suggester.builder().build(client, "switch-test");
        suggester.createIndexIfNothing();
        Thread.sleep(50);

        // Create additional update index (making 2 total)
        final String updateAlias = suggester.getIndex() + ".update";
        final String extraIndexName = suggester.getIndex() + ".extra";

                }
                return toReturn;
              }
            }
            return super.loadClass(name);
          }
        };
    oldClassLoader = Thread.currentThread().getContextClassLoader();
    Thread.currentThread().setContextClassLoader(classReloader);
    abstractFutureClass = classReloader.loadClass(AbstractFuture.class.getName());

 * comparator is not consistent with {@code equals}.
 *
 * <p>The {@code standard} methods are not guaranteed to be thread-safe, even when all of the
 * methods that they depend on are thread-safe.
 *
 * @author Mike Bostock
 * @author Louis Wasserman
 * @since 2.0
 */
@GwtCompatible

                }
                return toReturn;
              }
            }
            return super.loadClass(name);
          }
        };
    oldClassLoader = Thread.currentThread().getContextClassLoader();
    Thread.currentThread().setContextClassLoader(classReloader);
    abstractFutureClass = classReloader.loadClass(AbstractFuture.class.getName());

                                : Math.min(MAX_RETRY_DELAY, retryDelayMs * multiplier);
                        Thread.sleep(delay);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        throw new IOException("Interrupted during retry delay", e);
                    }
                }
            }

   * certain core JDK classes.
   */
  private void runTestMethod(ClassLoader classLoader) throws Exception {
    ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
    Thread.currentThread().setContextClassLoader(classLoader);
    try {
      Class<?> test = classLoader.loadClass(FuturesTest.class.getName());