}

        synchronized void write(final byte[] b, final int n, final SmbFile dest, final long off) {
            this.b = b;
            this.n = n;
            this.dest = dest;
            this.off = off;
            ready = false;
            notify();
        }

        @Override
        public void run() {
            synchronized (this) {
                try {

     */
    protected short getSystemCpuPercent() {
        final long now = getCurrentTimeAsLong();
        if (now - systemCpuCheckTime > systemCpuCheckInterval) {
            synchronized (this) {
                if (now - systemCpuCheckTime > systemCpuCheckInterval) {
                    try {
                        final OsProbe osProbe = OsProbe.getInstance();

     */
    protected String trustManager;

    /**
     * Whether to enter local passive mode.
     */
    protected boolean enterLocalPassiveMode;

    @Override
    public synchronized void init() {
        if (ftpAuthenticationHolder != null) {
            return;
        }

        super.init();

    assertEquals("null=null", e.toString());
    assertEquals(0, e.hashCode());
  }

  /** See {@link SynchronizedBiMapTest} for more tests. */
  @J2ktIncompatible // Synchronized
  public void testSynchronizedBiMap() {
    BiMap<String, Integer> bimap = HashBiMap.create();
    bimap.put("one", 1);
    BiMap<String, Integer> sync = Maps.synchronizedBiMap(bimap);
    bimap.put("two", 2);

                        byte[] plaintext = message.getBytes();
                        long sessionId = (threadId * 1000L) + i;

                        synchronized (encrypted) {
                            byte[] encryptedData = context.encryptMessage(plaintext, sessionId);
                            messages.add(message);
                            encrypted.add(encryptedData);

   * safe to do so. The exact circumstances under which a copy will or will not be performed are
   * undocumented and subject to change.
   *
   * <p>This method is safe to use even when {@code sortedMultiset} is a synchronized or concurrent
   * collection that is currently being modified by another thread.
   *
   * @throws NullPointerException if {@code sortedMultiset} or any of its elements is null
   */

     * Returns the FesenClient instance, connecting if not already connected.
     * @return The FesenClient instance.
     */
    protected FesenClient getClient() {
        if (!fesenClient.connected()) {
            synchronized (fesenClient) {
                if (!fesenClient.connected()) {
                    fesenClient.connect();
                }
            }
        }
        return fesenClient;
    }

    /**

   * {@code ImmutableList.of(list)} returns an {@code ImmutableList<List<String>>} containing one
   * element (the given list itself).
   *
   * <p>This method is safe to use even when {@code elements} is a synchronized or concurrent
   * collection that is currently being modified by another thread.
   *
   * @throws NullPointerException if {@code elements} contains a null element
   */

new APIs so we can get out of alpha.

 *  New: Support Java 21's virtual threads (‘OpenJDK Project Loom’). We changed OkHttp's internals
    to use `Lock` and `Condition` instead of `synchronized` for best resource utilization.

 *  New: Switch our Internationalized Domain Name (IDN) implementation to [UTS #46 Nontransitional

    * user agent, proxy settings, request headers, cookie store, and connection manager.
    * It also processes form-based authentication schemes and sets up the HTTP client context.
    */
    @Override
    public synchronized void init() {
        if (httpClient != null) {
            return;
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Initializing {}", HcHttpClient.class.getName());
        }