* 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
   */

     */
    public void flushActiveProxy() {
        this.activeProxy = null;
    }

    /**
     * @return the first active proxy
     */
    public synchronized Proxy getActiveProxy() {
        if (activeProxy == null) {
            java.util.List<Proxy> proxies = getProxies();
            if (proxies != null && !proxies.isEmpty()) {
                for (Proxy proxy : proxies) {

        }

        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 {

   * {@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
   */

   * 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
   */

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

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

                            boolean contains = pool.contains(null); // Should handle gracefully
                            successCount.incrementAndGet();
                        } catch (Exception e) {
                            synchronized (exceptions) {
                                exceptions.add(e);
                            }
                        }
                    }
                    long threadEnd = System.nanoTime();

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

    }

    /**
     * {@inheritDoc}
     * Optimized to provide better resource cleanup with caching benefits.
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override
    public synchronized void close() {
        final SmbTreeHandleImpl th = this.treeHandle;
        if (th != null) {
            this.treeHandle = null;

            // Optimization: For non-strict lifecycle, delay tree handle closure

    assertThat(e.toString()).isEqualTo("null=null");
    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);